VirtualBox

Changeset 53071 in vbox for trunk/src


Ignore:
Timestamp:
Oct 15, 2014 5:00:50 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
96576
Message:

VUSBSniffer: use semaphore to protect data against concurrent access

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/USB/VUSBSniffer.cpp

    r53060 r53071  
    2626#include <iprt/string.h>
    2727#include <iprt/system.h>
     28#include <iprt/semaphore.h>
    2829
    2930#include "VUSBSniffer.h"
    … …  
    254255    /** Pointer to the block data which will be written on commit. */
    255256    uint8_t          *pbBlockData;
     257    /** Fast Mutex protecting the state against concurrent access. */
     258    RTSEMFASTMUTEX    hMtx;
    256259} VUSBSNIFFERINT;
    257260/** Pointer to the internal VUSB sniffer state. */
    … …  
    431434        pThis->cbBlockMax  = 0;
    432435        pThis->pbBlockData = NULL;
    433 
    434         rc = RTFileOpen(&pThis->hFile, pszCaptureFilename, RTFILE_O_DENY_NONE | RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_READ);
     436        pThis->hMtx        = NIL_RTSEMFASTMUTEX;
     437
     438        rc = RTSemFastMutexCreate(&pThis->hMtx);
    435439        if (RT_SUCCESS(rc))
    436440        {
    437             /* Write header and link type blocks. */
    438             DumpFileShb Shb;
    439 
    440             Shb.Hdr.u32BlockType        = DUMPFILE_SHB_BLOCK_TYPE;
    441             Shb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
    442             Shb.u32ByteOrderMagic       = DUMPFILE_SHB_BYTE_ORDER_MAGIC;
    443             Shb.u16VersionMajor         = DUMPFILE_SHB_VERSION_MAJOR;
    444             Shb.u16VersionMinor         = DUMPFILE_SHB_VERSION_MINOR;
    445             Shb.u64SectionLength        = UINT64_C(0xffffffffffffffff); /* -1 */
    446 
    447             /* Write the blocks. */
    448             rc = vusbSnifferBlockNew(pThis, &Shb.Hdr, sizeof(Shb));
     441            rc = RTFileOpen(&pThis->hFile, pszCaptureFilename, RTFILE_O_DENY_NONE | RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_READ);
    449442            if (RT_SUCCESS(rc))
    450443            {
    451                 const char *pszOpt = RTBldCfgTargetDotArch();
    452                 rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_HARDWARE, pszOpt, strlen(pszOpt) + 1);
    453             }
    454 
    455             if (RT_SUCCESS(rc))
    456             {
    457                 char szTmp[512];
    458                 size_t cbTmp = sizeof(szTmp);
    459 
    460                 RT_ZERO(szTmp);
    461 
    462                 /* Build the OS code. */
    463                 rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, cbTmp);
     444                /* Write header and link type blocks. */
     445                DumpFileShb Shb;
     446
     447                Shb.Hdr.u32BlockType        = DUMPFILE_SHB_BLOCK_TYPE;
     448                Shb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
     449                Shb.u32ByteOrderMagic       = DUMPFILE_SHB_BYTE_ORDER_MAGIC;
     450                Shb.u16VersionMajor         = DUMPFILE_SHB_VERSION_MAJOR;
     451                Shb.u16VersionMinor         = DUMPFILE_SHB_VERSION_MINOR;
     452                Shb.u64SectionLength        = UINT64_C(0xffffffffffffffff); /* -1 */
     453
     454                /* Write the blocks. */
     455                rc = vusbSnifferBlockNew(pThis, &Shb.Hdr, sizeof(Shb));
    464456                if (RT_SUCCESS(rc))
    465457                {
    466                     size_t cb = strlen(szTmp);
    467 
    468                     szTmp[cb] = ' ';
    469                     rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, &szTmp[cb + 1], cbTmp - (cb + 1));
     458                    const char *pszOpt = RTBldCfgTargetDotArch();
     459                    rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_HARDWARE, pszOpt, strlen(pszOpt) + 1);
     460                }
     461
     462                if (RT_SUCCESS(rc))
     463                {
     464                    char szTmp[512];
     465                    size_t cbTmp = sizeof(szTmp);
     466
     467                    RT_ZERO(szTmp);
     468
     469                    /* Build the OS code. */
     470                    rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, cbTmp);
    470471                    if (RT_SUCCESS(rc))
    471472                    {
    472                         cb = strlen(szTmp);
     473                        size_t cb = strlen(szTmp);
     474
    473475                        szTmp[cb] = ' ';
    474                         rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, &szTmp[cb + 1], cbTmp - (cb + 1));
     476                        rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, &szTmp[cb + 1], cbTmp - (cb + 1));
     477                        if (RT_SUCCESS(rc))
     478                        {
     479                            cb = strlen(szTmp);
     480                            szTmp[cb] = ' ';
     481                            rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, &szTmp[cb + 1], cbTmp - (cb + 1));
     482                        }
    475483                    }
     484
     485                    if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
     486                        rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_OS, szTmp, strlen(szTmp) + 1);
     487                    else
     488                        rc = VINF_SUCCESS; /* Skip OS code if building the string failed. */
    476489                }
    477490
    478                 if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
    479                     rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_OS, szTmp, strlen(szTmp) + 1);
    480                 else
    481                     rc = VINF_SUCCESS; /* Skip OS code if building the string failed. */
    482             }
    483 
    484             if (RT_SUCCESS(rc))
    485             {
    486                 /** @todo: Add product info. */
    487             }
    488 
    489             if (RT_SUCCESS(rc))
    490                 rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
    491             if (RT_SUCCESS(rc))
    492                 rc = vusbSnifferBlockCommit(pThis);
    493 
    494             /* Write Interface descriptor block. */
    495             if (RT_SUCCESS(rc))
    496             {
    497                 DumpFileIdb Idb;
    498 
    499                 Idb.Hdr.u32BlockType        = DUMPFILE_IDB_BLOCK_TYPE;
    500                 Idb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
    501                 Idb.u16LinkType             = DUMPFILE_IDB_LINK_TYPE_USB_LINUX_MMAPED;
    502                 Idb.u16Reserved             = 0;
    503                 Idb.u32SnapLen              = UINT32_C(0xffffffff);
    504 
    505                 rc = vusbSnifferBlockNew(pThis, &Idb.Hdr, sizeof(Idb));
    506491                if (RT_SUCCESS(rc))
    507492                {
    508                     uint8_t u8TsResolution = 9; /* Nano second resolution. */
    509                     /* Add timestamp resolution option. */
    510                     rc = vusbSnifferAddOption(pThis, DUMPFILE_IDB_OPTION_TS_RESOLUTION,
    511                                               &u8TsResolution, sizeof(u8TsResolution));
     493                    /** @todo: Add product info. */
    512494                }
     495
    513496                if (RT_SUCCESS(rc))
    514497                    rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
    515498                if (RT_SUCCESS(rc))
    516499                    rc = vusbSnifferBlockCommit(pThis);
     500
     501                /* Write Interface descriptor block. */
     502                if (RT_SUCCESS(rc))
     503                {
     504                    DumpFileIdb Idb;
     505
     506                    Idb.Hdr.u32BlockType        = DUMPFILE_IDB_BLOCK_TYPE;
     507                    Idb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
     508                    Idb.u16LinkType             = DUMPFILE_IDB_LINK_TYPE_USB_LINUX_MMAPED;
     509                    Idb.u16Reserved             = 0;
     510                    Idb.u32SnapLen              = UINT32_C(0xffffffff);
     511
     512                    rc = vusbSnifferBlockNew(pThis, &Idb.Hdr, sizeof(Idb));
     513                    if (RT_SUCCESS(rc))
     514                    {
     515                        uint8_t u8TsResolution = 9; /* Nano second resolution. */
     516                        /* Add timestamp resolution option. */
     517                        rc = vusbSnifferAddOption(pThis, DUMPFILE_IDB_OPTION_TS_RESOLUTION,
     518                                                  &u8TsResolution, sizeof(u8TsResolution));
     519                    }
     520                    if (RT_SUCCESS(rc))
     521                        rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
     522                    if (RT_SUCCESS(rc))
     523                        rc = vusbSnifferBlockCommit(pThis);
     524                }
     525
     526                if (RT_SUCCESS(rc))
     527                {
     528                    *phSniffer = pThis;
     529                    return VINF_SUCCESS;
     530                }
     531
     532                RTFileClose(pThis->hFile);
     533                pThis->hFile = NIL_RTFILE;
     534                RTFileDelete(pszCaptureFilename);
    517535            }
    518 
    519             if (RT_SUCCESS(rc))
    520             {
    521                 *phSniffer = pThis;
    522                 return VINF_SUCCESS;
    523             }
    524 
    525             RTFileClose(pThis->hFile);
    526             pThis->hFile = NIL_RTFILE;
    527             RTFileDelete(pszCaptureFilename);
     536            RTSemFastMutexDestroy(pThis->hMtx);
    528537        }
    529538        VUSBSnifferDestroy(pThis);
    … …  
    545554    PVUSBSNIFFERINT pThis = hSniffer;
    546555
     556    int rc = RTSemFastMutexRequest(pThis->hMtx);
     557    AssertRC(rc);
     558
    547559    if (pThis->hFile != NIL_RTFILE)
    548560        RTFileClose(pThis->hFile);
    549561    if (pThis->pbBlockData)
    550562        RTMemFree(pThis->pbBlockData);
     563
     564    RTSemFastMutexRelease(pThis->hMtx);
     565    RTSemFastMutexDestroy(pThis->hMtx);
    551566    RTMemFree(pThis);
    552567}
    … …  
    669684        UsbHdr.u8SetupFlag  = '-'; /* Follow usbmon source here. */
    670685
    671     rc = vusbSnifferBlockNew(pThis, &Epb.Hdr, sizeof(Epb));
     686    /* Write the packet to the capture file. */
     687    rc = RTSemFastMutexRequest(pThis->hMtx);
    672688    if (RT_SUCCESS(rc))
    673         rc = vusbSnifferBlockAddData(pThis, &UsbHdr, sizeof(UsbHdr));
    674 
    675     if (pUrb->enmType == VUSBXFERTYPE_ISOC)
    676     {
    677         /* Add Isochronous descriptors now. */
    678         for (unsigned i = 0; i < pUrb->cIsocPkts && RT_SUCCESS(rc); i++)
     689    {
     690        rc = vusbSnifferBlockNew(pThis, &Epb.Hdr, sizeof(Epb));
     691        if (RT_SUCCESS(rc))
     692            rc = vusbSnifferBlockAddData(pThis, &UsbHdr, sizeof(UsbHdr));
     693
     694        if (pUrb->enmType == VUSBXFERTYPE_ISOC)
    679695        {
    680             DumpFileUsbIsoDesc IsoDesc;
    681             IsoDesc.i32Status = pUrb->aIsocPkts[i].enmStatus;
    682             IsoDesc.u32Offset = pUrb->aIsocPkts[i].off;
    683             IsoDesc.u32Len    = pUrb->aIsocPkts[i].cb;
    684             rc = vusbSnifferBlockAddData(pThis, &IsoDesc, sizeof(IsoDesc));
     696            /* Add Isochronous descriptors now. */
     697            for (unsigned i = 0; i < pUrb->cIsocPkts && RT_SUCCESS(rc); i++)
     698            {
     699                DumpFileUsbIsoDesc IsoDesc;
     700                IsoDesc.i32Status = pUrb->aIsocPkts[i].enmStatus;
     701                IsoDesc.u32Offset = pUrb->aIsocPkts[i].off;
     702                IsoDesc.u32Len    = pUrb->aIsocPkts[i].cb;
     703                rc = vusbSnifferBlockAddData(pThis, &IsoDesc, sizeof(IsoDesc));
     704            }
    685705        }
    686     }
    687 
    688     /* Record data. */
    689     if (   RT_SUCCESS(rc)
    690         && fRecordData)
    691         rc = vusbSnifferBlockAddData(pThis, pUrb->abData, pUrb->cbData);
    692 
    693     if (RT_SUCCESS(rc))
    694         rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
    695 
    696     if (RT_SUCCESS(rc))
    697         rc = vusbSnifferBlockCommit(pThis);
     706
     707        /* Record data. */
     708        if (   RT_SUCCESS(rc)
     709            && fRecordData)
     710            rc = vusbSnifferBlockAddData(pThis, pUrb->abData, pUrb->cbData);
     711
     712        if (RT_SUCCESS(rc))
     713            rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
     714
     715        if (RT_SUCCESS(rc))
     716            rc = vusbSnifferBlockCommit(pThis);
     717
     718        RTSemFastMutexRelease(pThis->hMtx);
     719    }
    698720
    699721    return rc;
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