VirtualBox

Changeset 37596 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Jun 22, 2011 7:30:06 PM (14 years ago)
Author:
vboxsync
Message:

*: RTFILE becomes a pointer, RTFileOpen++ expands it's flags paramter from uint32_t to uint64_t.

Location:
trunk/src/VBox/Main
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Main/include/USBProxyService.h

    r36993 r37596  
    256256private:
    257257    /** File handle to the '/proc/bus/usb/devices' file. */
    258     RTFILE mFile;
     258    RTFILE mhFile;
    259259    /** Pipe used to interrupt wait(), the read end. */
    260     RTFILE mWakeupPipeR;
     260    RTPIPE mhWakeupPipeR;
    261261    /** Pipe used to interrupt wait(), the write end. */
    262     RTFILE mWakeupPipeW;
     262    RTPIPE mhWakeupPipeW;
    263263    /** The root of usbfs. */
    264264    Utf8Str mDevicesRoot;
  • trunk/src/VBox/Main/src-server/linux/USBProxyServiceLinux.cpp

    r36997 r37596  
    3939#include <iprt/param.h>
    4040#include <iprt/path.h>
     41#include <iprt/pipe.h>
    4142#include <iprt/stream.h>
    4243#include <iprt/linux/sysfs.h>
     
    6061 */
    6162USBProxyServiceLinux::USBProxyServiceLinux(Host *aHost)
    62     : USBProxyService(aHost), mFile(NIL_RTFILE), mWakeupPipeR(NIL_RTFILE),
    63       mWakeupPipeW(NIL_RTFILE), mUsingUsbfsDevices(true /* see init */),
     63    : USBProxyService(aHost), mhFile(NIL_RTFILE), mhWakeupPipeR(NIL_RTPIPE),
     64      mhWakeupPipeW(NIL_RTPIPE), mUsingUsbfsDevices(true /* see init */),
    6465      mUdevPolls(0), mpWaiter(NULL)
    6566#ifdef UNIT_TEST
     
    209210    if (pszDevices)
    210211    {
    211         rc = RTFileOpen(&mFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
     212        rc = RTFileOpen(&mhFile, pszDevices, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    212213        if (RT_SUCCESS(rc))
    213214        {
    214             int pipes[2];
    215             if (!pipe(pipes))
     215            rc = RTPipeCreate(&mhWakeupPipeR, &mhWakeupPipeW, 0 /*fFlags*/);
     216            if (RT_SUCCESS(rc))
    216217            {
    217                 /* Set close on exec (race here!) */
    218                 if (   fcntl(pipes[0], F_SETFD, FD_CLOEXEC) >= 0
    219                     && fcntl(pipes[1], F_SETFD, FD_CLOEXEC) >= 0)
     218                /*
     219                 * Start the poller thread.
     220                 */
     221                rc = start();
     222                if (RT_SUCCESS(rc))
    220223                {
    221                     mWakeupPipeR = pipes[0];
    222                     mWakeupPipeW = pipes[1];
    223                     /*
    224                      * Start the poller thread.
    225                      */
    226                     rc = start();
    227                     if (RT_SUCCESS(rc))
    228                     {
    229                         RTStrFree(pszDevices);
    230                         LogFlowThisFunc(("returns successfully - mWakeupPipeR/W=%d/%d\n",
    231                                          mWakeupPipeR, mWakeupPipeW));
    232                         return VINF_SUCCESS;
    233                     }
    234 
    235                     RTFileClose(mWakeupPipeR);
    236                     RTFileClose(mWakeupPipeW);
    237                     mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
     224                    RTStrFree(pszDevices);
     225                    LogFlowThisFunc(("returns successfully\n"));
     226                    return VINF_SUCCESS;
    238227                }
    239                 else
    240                 {
    241                     rc = RTErrConvertFromErrno(errno);
    242                     Log(("USBProxyServiceLinux::USBProxyServiceLinux: fcntl failed, errno=%d\n", errno));
    243                     close(pipes[0]);
    244                     close(pipes[1]);
    245                 }
     228
     229                RTPipeClose(mhWakeupPipeR);
     230                RTPipeClose(mhWakeupPipeW);
     231                mhWakeupPipeW = mhWakeupPipeR = NIL_RTPIPE;
    246232            }
    247233            else
    248             {
    249                 rc = RTErrConvertFromErrno(errno);
    250                 Log(("USBProxyServiceLinux::USBProxyServiceLinux: pipe failed, errno=%d\n", errno));
    251             }
    252             RTFileClose(mFile);
     234                Log(("USBProxyServiceLinux::USBProxyServiceLinux: RTFilePipe failed with rc=%Rrc\n", rc));
     235            RTFileClose(mhFile);
    253236        }
    254237
     
    332315     * Free resources.
    333316     */
    334     if (mFile != NIL_RTFILE)
    335     {
    336         RTFileClose(mFile);
    337         mFile = NIL_RTFILE;
    338     }
    339 
    340     if (mWakeupPipeR != NIL_RTFILE)
    341         RTFileClose(mWakeupPipeR);
    342     if (mWakeupPipeW != NIL_RTFILE)
    343         RTFileClose(mWakeupPipeW);
    344     mWakeupPipeW = mWakeupPipeR = NIL_RTFILE;
     317    RTFileClose(mhFile);
     318    mhFile = NIL_RTFILE;
     319
     320    RTPipeClose(mhWakeupPipeR);
     321    RTPipeClose(mhWakeupPipeW);
     322    mhWakeupPipeW = mhWakeupPipeR = NIL_RTPIPE;
    345323}
    346324
     
    434412
    435413    memset(&PollFds, 0, sizeof(PollFds));
    436     PollFds[0].fd        = mFile;
     414    PollFds[0].fd        = RTFileToNative(mhFile);
    437415    PollFds[0].events    = POLLIN;
    438     PollFds[1].fd        = mWakeupPipeR;
     416    PollFds[1].fd        = RTPipeToNative(mhWakeupPipeR);
    439417    PollFds[1].events    = POLLIN | POLLERR | POLLHUP;
    440418
     
    448426        {
    449427            char szBuf[WAKE_UP_STRING_LEN];
    450             rc = RTFileRead(mWakeupPipeR, szBuf, sizeof(szBuf), NULL);
     428            rc = RTPipeReadBlocking(mhWakeupPipeR, szBuf, sizeof(szBuf), NULL);
    451429            AssertRC(rc);
    452430        }
     
    484462    }
    485463#endif /* VBOX_USB_WITH_SYSFS */
    486     int rc = RTFileWrite(mWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
     464    int rc = RTPipeWriteBlocking(mhWakeupPipeW, WAKE_UP_STRING, WAKE_UP_STRING_LEN, NULL);
    487465    if (RT_SUCCESS(rc))
    488         RTFileFlush(mWakeupPipeW);
     466        RTPipeFlush(mhWakeupPipeW);
    489467    LogFlowFunc(("returning %Rrc\n", rc));
    490468    return rc;
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