VirtualBox

Changeset 23973 in vbox for trunk


Ignore:
Timestamp:
Oct 22, 2009 12:34:22 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
53801
Message:

*,RTFileOpen: Fixing RTFileOpen flag misdesign: The deny, access and action flags are mandatory now.

Location:
trunk
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/iprt/file.h

    r23047 r23973  
    8787                                     /* 0x00000008 is unused atm. */
    8888
    89 /** Sharing mode: deny none (the default mode). */
    90 #define RTFILE_O_DENY_NONE              0x00000000
     89/** Sharing mode: deny none. */
     90#define RTFILE_O_DENY_NONE              0x00000080
    9191/** Sharing mode: deny read. */
    9292#define RTFILE_O_DENY_READ              0x00000010
    … …  
    103103#define RTFILE_O_DENY_NOT_DELETE        0x00000040
    104104/** Sharing mode mask. */
    105 #define RTFILE_O_DENY_MASK              0x00000070
     105#define RTFILE_O_DENY_MASK              0x000000f0
    106106
    107107/** Action: Open an existing file (the default action). */
    108 #define RTFILE_O_OPEN                   0x00000000
     108#define RTFILE_O_OPEN                   0x00000700
    109109/** Action: Create a new file or open an existing one. */
    110110#define RTFILE_O_OPEN_CREATE            0x00000100
    … …  
    114114#define RTFILE_O_CREATE_REPLACE         0x00000300
    115115/** Action mask. */
    116 #define RTFILE_O_ACTION_MASK            0x00000300
    117 
    118                                       /*0x00000400
    119                                     and 0x00000800 are unused atm. */
     116#define RTFILE_O_ACTION_MASK            0x00000700
     117
    120118/** Turns off indexing of files on Windows hosts, *CREATE* only.
    121119 * @remarks Window only. */
    … …  
    201199 * @remark  This doesn't validate the access mode properly.
    202200 */
    203 #define RTFILE_O_VALID_MASK             0x1ffFFB77
     201#define RTFILE_O_VALID_MASK             0x1ffFFFF7
    204202
    205203/** @} */
    … …  
    224222 * @param   pszFilename     Path to the file which is to be opened. (UTF-8)
    225223 * @param   fOpen           Open flags, i.e a combination of the RTFILE_O_* defines.
    226  */
    227 RTR3DECL(int)  RTFileOpen(PRTFILE pFile, const char *pszFilename, unsigned fOpen);
     224 *                          The ACCESS, ACTION and DENY flags are mandatory!
     225 */
     226RTR3DECL(int)  RTFileOpen(PRTFILE pFile, const char *pszFilename, uint32_t fOpen);
    228227
    229228/**

  • trunk/src/VBox/Devices/Network/slirp/slirp.c

    r23923 r23973  
    375375    {
    376376        RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", etc);
    377         rc = RTFileOpen(&f, buff, RTFILE_O_READ);
     377        rc = RTFileOpen(&f, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    378378    }
    379379    if (RT_FAILURE(rc))
    380380    {
    381381        RTStrmPrintf(buff, sizeof(buff), "%s/RESOLV2", _PATH_ETC);
    382         rc = RTFileOpen(&f, buff, RTFILE_O_READ);
     382        rc = RTFileOpen(&f, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    383383    }
    384384    if (RT_FAILURE(rc))
    385385    {
    386386        RTStrmPrintf(buff, sizeof(buff), "%s/resolv.conf", _PATH_ETC);
    387         rc = RTFileOpen(&f, buff, RTFILE_O_READ);
     387        rc = RTFileOpen(&f, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    388388    }
    389389#else
    390390# ifndef DEBUG_vvl
    391     rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ);
     391    rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    392392# else
    393393    char *home = getenv("HOME");
    394394    RTStrPrintf(buff, sizeof(buff), "%s/resolv.conf", home);
    395     rc = RTFileOpen(&f, buff, RTFILE_O_READ);
     395    rc = RTFileOpen(&f, buff, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    396396    if (RT_SUCCESS(rc))
    397397    {
    … …  
    400400    else
    401401    {
    402         rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ);
     402        rc = RTFileOpen(&f, "/etc/resolv.conf", RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    403403        Log(("NAT: DNS we're using %s\n", buff));
    404404    }
    … …  
    771771    if (!link_up)
    772772        goto done;
    773    
     773
    774774    /*
    775775     * *_slowtimo needs calling if there are IP fragments
    … …  
    804804        if (pData->fmbuf_water_line == 1)
    805805        {
    806             if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
     806            if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    807807            {
    808808                pData->fmbuf_water_warn_sent = 0;
    … …  
    887887        if (pData->fmbuf_water_line == 1)
    888888        {
    889             if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
     889            if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    890890            {
    891891                pData->fmbuf_water_line = 0;
    … …  
    10271027        if (pData->fmbuf_water_line == 1)
    10281028        {
    1029             if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
     1029            if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    10301030            {
    10311031                pData->fmbuf_water_line = 0;
    … …  
    13241324        if (pData->fmbuf_water_line == 1)
    13251325        {
    1326             if (mbuf_alloced < pData->mbuf_water_line_limit/2) 
     1326            if (mbuf_alloced < pData->mbuf_water_line_limit/2)
    13271327            {
    13281328                pData->fmbuf_water_line = 0;
    … …  
    15491549        return;
    15501550    }
    1551     eh = mtod(m, struct ethhdr *); 
     1551    eh = mtod(m, struct ethhdr *);
    15521552    proto = ntohs(eh->h_proto);
    15531553#else
    … …  
    16211621#endif
    16221622#if 1
    1623             if (   pData->fmbuf_water_line 
     1623            if (   pData->fmbuf_water_line
    16241624                && pData->fmbuf_water_warn_sent == 0
    16251625                && (curtime - pData->tsmbuf_water_warn_sent) > 500)
    16261626            {
    1627                 icmp_error(pData, m, ICMP_SOURCEQUENCH, 0, 0, "Out of resources!!!"); 
     1627                icmp_error(pData, m, ICMP_SOURCEQUENCH, 0, 0, "Out of resources!!!");
    16281628                pData->fmbuf_water_warn_sent = 1;
    16291629                pData->tsmbuf_water_warn_sent = curtime;

  • trunk/src/VBox/Devices/Parallel/DrvHostParallel.cpp

    r22277 r23973  
    260260/**
    261261 * Construct a host parallel driver instance.
    262  * 
     262 *
    263263 * @copydoc FNPDMDRVCONSTRUCT
    264264 */
    … …  
    303303     * Open the device
    304304     */
    305     rc = RTFileOpen(&pThis->FileDevice, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
     305    rc = RTFileOpen(&pThis->FileDevice, pThis->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    306306    if (RT_FAILURE(rc))
    307307        return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Parallel#%d could not open '%s'"),
    … …  
    433433    NULL,
    434434    /* pfnDetach */
    435     NULL, 
     435    NULL,
    436436    /* pfnPowerOff */
    437     NULL, 
     437    NULL,
    438438    /* pfnSoftReset */
    439439    NULL,

  • trunk/src/VBox/Devices/Serial/DrvHostSerial.cpp

    r23160 r23973  
    12111211/**
    12121212 * Construct a char driver instance.
    1213  * 
     1213 *
    12141214 * @copydoc FNPDMDRVCONSTRUCT
    12151215 */
    … …  
    12881288#else
    12891289
    1290     rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
     1290    rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    12911291# ifdef RT_OS_DARWIN
    12921292    if (RT_SUCCESS(rc))
    1293         rc = RTFileOpen(&pThis->DeviceFileR, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READ);
     1293        rc = RTFileOpen(&pThis->DeviceFileR, pThis->pszDevicePath, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    12941294# endif
    12951295
    … …  
    14951495    NULL,
    14961496    /* pfnDetach */
    1497     NULL, 
     1497    NULL,
    14981498    /* pfnPowerOff */
    1499     NULL, 
     1499    NULL,
    15001500    /* pfnSoftReset */
    15011501    NULL,

  • trunk/src/VBox/Devices/Serial/DrvRawFile.cpp

    r22653 r23973  
    150150     * Open the raw file.
    151151     */
    152     rc = RTFileOpen(&pThis->OutputFile, pThis->pszLocation, RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
     152    rc = RTFileOpen(&pThis->OutputFile, pThis->pszLocation, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE);
    153153    if (RT_FAILURE(rc))
    154154    {
    … …  
    180180
    181181    if (pThis->OutputFile != NIL_RTFILE)
    182     {   
     182    {
    183183        RTFileClose(pThis->OutputFile);
    184184        pThis->OutputFile = NIL_RTFILE;
    … …  
    200200
    201201    if (pThis->OutputFile != NIL_RTFILE)
    202     {   
     202    {
    203203        RTFileClose(pThis->OutputFile);
    204204        pThis->OutputFile = NIL_RTFILE;

  • trunk/src/VBox/Devices/Storage/DrvHostBase.cpp

    r23739 r23973  
    961961    RTFILE FileDevice;
    962962
    963     rc = RTFileOpen(&FileDevice, pThis->pszDeviceOpen, RTFILE_O_READWRITE);
     963    rc = RTFileOpen(&FileDevice, pThis->pszDeviceOpen, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    964964    if (RT_FAILURE(rc))
    965965        return rc;
    … …  
    983983            RTFILE PassthroughDevice;
    984984
    985             rc = RTFileOpen(&PassthroughDevice, pszPassthroughDevice, RTFILE_O_READWRITE);
     985            rc = RTFileOpen(&PassthroughDevice, pszPassthroughDevice, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    986986
    987987            RTStrFree(pszPassthroughDevice);
    … …  
    10461046static int drvHostBaseOpen(PDRVHOSTBASE pThis, PRTFILE pFileBlockDevice, PRTFILE pFileRawDevice, bool fReadOnly)
    10471047{
    1048     unsigned fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE) | RTFILE_O_NON_BLOCK;
     1048    unsigned fFlags = (fReadOnly ? RTFILE_O_READ : RTFILE_O_READWRITE)
     1049                    | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK;
    10491050    int rc = RTFileOpen(pFileBlockDevice, pThis->pszDeviceOpen, fFlags);
    10501051    if (RT_SUCCESS(rc))

  • trunk/src/VBox/Devices/Storage/DrvSCSIHost.cpp

    r23970 r23973  
    478478                                N_("Configuration error: Failed to get the \"DevicePath\" value"));
    479479
    480     rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_OPEN | RTFILE_O_READWRITE);
     480    rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    481481    if (RT_FAILURE(rc))
    482482        return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,

  • trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp

    r23223 r23973  
    143143
    144144#ifndef VBOX_WITH_NEW_IO_CODE
    145     unsigned uFileFlags = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
    146                                     : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
     145    uint32_t fOpen = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
     146                               : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
    147147
    148148    if (fCreate)
    149         uFileFlags |= RTFILE_O_CREATE;
    150     else
    151         uFileFlags |= RTFILE_O_OPEN;
    152 
    153     rc = RTFileOpen(&pImage->File, pImage->pszFilename, uFileFlags);
     149        fOpen |= RTFILE_O_CREATE;
     150    else
     151        fOpen |= RTFILE_O_OPEN;
     152
     153    rc = RTFileOpen(&pImage->File, pImage->pszFilename, fOpen);
    154154#else
    155155
    … …  
    415415    int rc;
    416416
    417     rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ);
     417    rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    418418    if (RT_FAILURE(rc))
    419419        return VERR_VD_GEN_INVALID_HEADER;

  • trunk/src/VBox/Devices/Storage/RawHDDCore.cpp

    r23913 r23973  
    122122
    123123#ifndef VBOX_WITH_NEW_IO_CODE
    124     unsigned uFileFlags = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
    125                                     : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
     124    uint32_t fOpen = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
     125                               : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
    126126
    127127    if (fCreate)
    128         uFileFlags |= RTFILE_O_CREATE;
    129     else
    130         uFileFlags |= RTFILE_O_OPEN;
    131 
    132     rc = RTFileOpen(&pImage->File, pImage->pszFilename, uFileFlags);
     128        fOpen |= RTFILE_O_CREATE;
     129    else
     130        fOpen |= RTFILE_O_OPEN;
     131
     132    rc = RTFileOpen(&pImage->File, pImage->pszFilename, fOpen);
    133133#else
    134134

  • trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

    r23223 r23973  
    738738    pStorage->pfnCompleted = pfnCompleted;
    739739
    740     unsigned uFlags = 0;
     740    uint32_t fOpen = 0;
    741741
    742742    if (uOpenFlags & VD_INTERFACEASYNCIO_OPEN_FLAGS_READONLY)
    743         uFlags |= RTFILE_O_READ | RTFILE_O_DENY_NONE;
     743        fOpen |= RTFILE_O_READ      | RTFILE_O_DENY_NONE;
    744744    else
    745         uFlags |= RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
     745        fOpen |= RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
    746746
    747747    if (uOpenFlags & VD_INTERFACEASYNCIO_OPEN_FLAGS_CREATE)
    748         uFlags |= RTFILE_O_CREATE;
     748        fOpen |= RTFILE_O_CREATE;
    749749    else
    750         uFlags |= RTFILE_O_OPEN;
     750        fOpen |= RTFILE_O_OPEN;
    751751
    752752    /* Open the file. */
    753     int rc = RTFileOpen(&pStorage->File, pszLocation, uFlags);
     753    int rc = RTFileOpen(&pStorage->File, pszLocation, fOpen);
    754754    if (RT_SUCCESS(rc))
    755755    {

  • trunk/src/VBox/Devices/Storage/VBoxHDDFormats/AppleDiskImage/VBoxDMG.cpp

    r21405 r23973  
    10351035     */
    10361036    RTFILE hFile;
    1037     int rc = RTFileOpen(&hFile, pszFilename, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     1037    int rc = RTFileOpen(&hFile, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    10381038    if (RT_FAILURE(rc))
    10391039        return rc;

  • trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

    r23223 r23973  
    8989
    9090#ifndef VBOX_WITH_NEW_IO_CODE
    91     unsigned uFileFlags = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
    92                                     : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
     91    uint32_t fOpen = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
     92                               : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
    9393
    9494    if (fCreate)
    95         uFileFlags |= RTFILE_O_CREATE;
     95        fOpen |= RTFILE_O_CREATE;
    9696    else
    97         uFileFlags |= RTFILE_O_OPEN;
    98 
    99     rc = RTFileOpen(&pImage->File, pImage->pszFilename, uFileFlags);
     97        fOpen |= RTFILE_O_OPEN;
     98
     99    rc = RTFileOpen(&pImage->File, pImage->pszFilename, fOpen);
    100100#else
    101101

  • trunk/src/VBox/Devices/Storage/VHDHDDCore.cpp

    r23223 r23973  
    226226
    227227#ifndef VBOX_WITH_NEW_IO_CODE
    228     unsigned uFileFlags = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
    229                                     : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
     228    uint32_t fOpen = fReadonly ? RTFILE_O_READ      | RTFILE_O_DENY_NONE
     229                               : RTFILE_O_READWRITE | RTFILE_O_DENY_WRITE;
    230230
    231231    if (fCreate)
    232         uFileFlags |= RTFILE_O_CREATE;
    233     else
    234         uFileFlags |= RTFILE_O_OPEN;
    235 
    236     rc = RTFileOpen(&pImage->File, pImage->pszFilename, uFileFlags);
     232        fOpen |= RTFILE_O_CREATE;
     233    else
     234        fOpen |= RTFILE_O_OPEN;
     235
     236    rc = RTFileOpen(&pImage->File, pImage->pszFilename, fOpen);
    237237#else
    238238
    … …  
    774774    VHDFooter vhdFooter;
    775775
    776     rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN);
     776    rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    777777    if (RT_FAILURE(rc))
    778778        return VERR_VD_VHD_INVALID_HEADER;
    … …  
    20152015        /* Interface doesn't provide such a feature. */
    20162016        RTFILE File;
    2017         rc = RTFileOpen(&File, pImage->pszFilename, RTFILE_O_OPEN | RTFILE_O_READ);
     2017        rc = RTFileOpen(&File, pImage->pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    20182018        if (RT_SUCCESS(rc))
    20192019        {

  • trunk/src/VBox/Devices/Storage/testcase/tstVD.cpp

    r22982 r23973  
    100100    {
    101101        RTFILE File;
    102         rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ);
     102        rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    103103        if (RT_SUCCESS(rc))
    104104        {
    … …  
    153153    VDClose(pVD, true);
    154154    RTFILE File;
    155     rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ);
     155    rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    156156    if (RT_SUCCESS(rc))
    157157    {
    … …  
    535535
    536536    RTFILE File;
    537     rc = RTFileOpen(&File, pszBaseFilename, RTFILE_O_READ);
     537    rc = RTFileOpen(&File, pszBaseFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    538538    if (RT_SUCCESS(rc))
    539539    {
    … …  
    658658
    659659    RTFILE File;
    660     rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ);
     660    rc = RTFileOpen(&File, pszFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    661661    if (RT_SUCCESS(rc))
    662662    {
    … …  
    827827
    828828    RTFILE File;
    829     rc = RTFileOpen(&File, DST_PATH, RTFILE_O_CREATE | RTFILE_O_WRITE);
     829    rc = RTFileOpen(&File, DST_PATH, RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_DENY_NONE);
    830830    if (RT_SUCCESS(rc))
    831831        RTFileClose(File);

  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r23223 r23973  
    824824
    825825    RTFILE RawFile;
    826     int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     826    int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    827827    if (RT_FAILURE(vrc))
    828828    {
    … …  
    944944#endif /* RT_OS_DARWIN */
    945945    RTFILE RawFile;
    946     int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     946    int vrc = RTFileOpen(&RawFile, rawdisk.raw(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    947947    if (RT_FAILURE(vrc))
    948948    {
    … …  
    12711271                {
    12721272                    RTFILE MBRFile;
    1273                     vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     1273                    vrc = RTFileOpen(&MBRFile, pszMBRFilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    12741274                    if (RT_FAILURE(vrc))
    12751275                    {
    … …  
    15081508        outFile = 1;
    15091509    else
    1510         vrc = RTFileOpen(&outFile, Utf8Str(dst).raw(), RTFILE_O_OPEN | RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_ALL);
     1510        vrc = RTFileOpen(&outFile, Utf8Str(dst).raw(), RTFILE_O_WRITE | RTFILE_O_CREATE | RTFILE_O_DENY_ALL);
    15111511    if (RT_FAILURE(vrc))
    15121512    {

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r23223 r23973  
    825825        File = 0;
    826826    else
    827         rc = RTFileOpen(&File, srcfilename, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
     827        rc = RTFileOpen(&File, srcfilename, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
    828828    if (RT_FAILURE(rc))
    829829    {

  • trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

    r23879 r23973  
    22932293        const char *pcszLf = "\n";
    22942294        RTFILE PidFile;
    2295         RTFileOpen(&PidFile, gpszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE);
     2295        RTFileOpen(&PidFile, gpszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE);
    22962296        RTStrFormatNumber(szBuf, RTProcSelf(), 10, 0, 0, 0);
    22972297        RTFileWrite(PidFile, szBuf, strlen(szBuf), NULL);

  • trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp

    r21485 r23973  
    608608 * @retval pfOpen     iprt create flags
    609609 */
    610 static int vbsfConvertFileOpenFlags(unsigned fShflFlags, RTFMODE fMode, SHFLHANDLE handleInitial, unsigned *pfOpen)
    611 {
    612     unsigned fOpen = 0;
     610static int vbsfConvertFileOpenFlags(unsigned fShflFlags, RTFMODE fMode, SHFLHANDLE handleInitial, uint32_t *pfOpen)
     611{
     612    uint32_t fOpen = 0;
    613613    int rc = VINF_SUCCESS;
    614614
    … …  
    842842    SHFLFILEHANDLE *pHandle = 0;
    843843    /* Open or create a file. */
    844     unsigned fOpen = 0;
     844    uint32_t fOpen = 0;
    845845    bool fNoError = false;
    846846    static int cErrors;

  • trunk/src/VBox/Main/MachineImpl.cpp

    r23945 r23973  
    447447            /* check for the file existence */
    448448            RTFILE f = NIL_RTFILE;
    449             int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ);
     449            int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    450450            if (    RT_SUCCESS(vrc)
    451451                 || vrc == VERR_SHARING_VIOLATION
    … …  
    60046004        path = Utf8Str(mData->m_strConfigFileFull);
    60056005        vrc = RTFileOpen(&mData->mHandleCfgFile, path.c_str(),
    6006                          RTFILE_O_READWRITE | RTFILE_O_CREATE |
    6007                          RTFILE_O_DENY_WRITE);
     6006                         RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_WRITE);
    60086007        if (RT_FAILURE(vrc))
    60096008        {

  • trunk/src/VBox/Main/MediumImpl.cpp

    r23947 r23973  
    34563456            {
    34573457                RTFILE file;
    3458                 vrc = RTFileOpen(&file, locationFull.c_str(), RTFILE_O_READ);
     3458                vrc = RTFileOpen(&file, locationFull.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    34593459                if (RT_SUCCESS(vrc))
    34603460                    RTFileClose(file);

  • trunk/src/VBox/Main/freebsd/HostHardwareFreeBSD.cpp

    r23855 r23973  
    169169    RTFILE FileXpt;
    170170
    171     rc = RTFileOpen(&FileXpt, "/dev/xpt0", RTFILE_O_READWRITE);
     171    rc = RTFileOpen(&FileXpt, "/dev/xpt0", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    172172    if (RT_SUCCESS(rc))
    173173    {

  • trunk/src/VBox/Main/linux/HostHardwareLinux.cpp

    r23855 r23973  
    160160    AssertReturn(Number <= 7, false);
    161161    RTFILE File;
    162     int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_NON_BLOCK);
     162    int rc = RTFileOpen(&File, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
    163163    if (RT_SUCCESS(rc))
    164164    {
    … …  
    330330    int rc, rcIoCtl = 0;
    331331    RTFILE file;
    332     rc = RTFileOpen(&file, pcszNode, RTFILE_O_READ | RTFILE_O_NON_BLOCK);
     332    rc = RTFileOpen(&file, pcszNode, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
    333333    if (RT_SUCCESS(rc))
    334334    {

  • trunk/src/VBox/Main/xpcom/server.cpp

    r23223 r23973  
    10631063            char szBuf[32];
    10641064            const char *lf = "\n";
    1065             RTFileOpen(&pidFile, pszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE);
     1065            RTFileOpen(&pidFile, pszPidFile, RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE);
    10661066            RTStrFormatNumber(szBuf, getpid(), 10, 0, 0, 0);
    10671067            RTFileWrite(pidFile, szBuf, strlen(szBuf), NULL);

  • trunk/src/VBox/Runtime/common/misc/s3.cpp

    r22735 r23973  
    873873    /* Open the file */
    874874    RTFILE hFile;
    875     int rc = RTFileOpen(&hFile, pszFileName, RTFILE_O_CREATE | RTFILE_O_WRITE);
     875    int rc = RTFileOpen(&hFile, pszFileName, RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_NONE);
    876876    if (RT_FAILURE(rc))
    877877        return rc;
    … …  
    931931    /* Open the file */
    932932    RTFILE hFile;
    933     int rc = RTFileOpen(&hFile, pszFileName, RTFILE_O_OPEN | RTFILE_O_READ);
     933    int rc = RTFileOpen(&hFile, pszFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
    934934    if (RT_FAILURE(rc))
    935935        return rc;

  • trunk/src/VBox/Runtime/common/misc/tar.cpp

    r21859 r23973  
    324324    /* Open the tar file */
    325325    RTFILE hFile;
    326     int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ);
     326    int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    327327    if (RT_FAILURE(rc))
    328328        return rc;
    … …  
    383383    /* Open the tar file */
    384384    RTFILE hFile;
    385     int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ);
     385    int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    386386    if (RT_FAILURE(rc))
    387387        return rc;
    … …  
    473473    /* Open the tar file */
    474474    RTFILE hFile;
    475     int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ);
     475    int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    476476    if (RT_FAILURE(rc))
    477477        return rc;
    … …  
    567567    /* Open the tar file */
    568568    RTFILE hFile;
    569     int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ);
     569    int rc = RTFileOpen(&hFile, pszTarFile, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    570570    if (RT_FAILURE(rc))
    571571        return rc;

  • trunk/src/VBox/Runtime/include/internal/file.h

    r20374 r23973  
    4646 * @internal
    4747 */
    48 int rtFileRecalcAndValidateFlags(unsigned *pfOpen);
     48int rtFileRecalcAndValidateFlags(uint32_t *pfOpen);
    4949
    5050RT_C_DECLS_END

  • trunk/src/VBox/Runtime/r3/fileio.cpp

    r8913 r23973  
    111111 * @internal
    112112 */
    113 int rtFileRecalcAndValidateFlags(unsigned *pfOpen)
     113int rtFileRecalcAndValidateFlags(uint32_t *pfOpen)
    114114{
    115115    /*
    116116     * Recalc.
    117117     */
    118     unsigned fOpen = *pfOpen;
     118    uint32_t fOpen = *pfOpen;
    119119    switch (fOpen & RTFILE_O_ACCESS_MASK)
    120120    {
    … …  
    132132            break;
    133133        default:
    134             AssertMsgFailed(("RTFileOpen received an invalid RW value, fOpen=%#x\n", fOpen));
     134            AssertMsgFailed(("Invalid RW value, fOpen=%#x\n", fOpen));
    135135            return VERR_INVALID_PARAMETER;
    136136    }
    … …  
    139139     * Validate                                                                                                                                       .
    140140     */
    141     if (    !(fOpen & RTFILE_O_ACCESS_MASK)
     141    AssertMsgReturn(fOpen & RTFILE_O_ACCESS_MASK, ("Missing RTFILE_O_READ/WRITE: fOpen=%#x\n", fOpen), VERR_INVALID_PARAMETER);
    142142#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
    143         ||  (fOpen & (~RTFILE_O_VALID_MASK | RTFILE_O_NON_BLOCK))
     143    AssertMsgReturn(!(fOpen & (~RTFILE_O_VALID_MASK | RTFILE_O_NON_BLOCK)), ("%#x\n", fOpen), VERR_INVALID_PARAMETER);
    144144#else
    145         ||  (fOpen & ~RTFILE_O_VALID_MASK)
     145    AssertMsgReturn(!(fOpen & ~RTFILE_O_VALID_MASK), ("%#x\n", fOpen), VERR_INVALID_PARAMETER);
    146146#endif
    147         ||  (fOpen & (RTFILE_O_TRUNCATE | RTFILE_O_WRITE)) == RTFILE_O_TRUNCATE
    148         ||  (   fOpen & RTFILE_O_NOT_CONTENT_INDEXED
    149              && !(   (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
    150                   || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
    151                   || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE))
    152        )
    153     {
    154         AssertMsgFailed(("Invalid parameters! fOpen=%#x\n", fOpen));
    155         return VERR_INVALID_PARAMETER;
     147    AssertMsgReturn((fOpen & (RTFILE_O_TRUNCATE | RTFILE_O_WRITE)) != RTFILE_O_TRUNCATE, ("%#x\n", fOpen), VERR_INVALID_PARAMETER);
     148
     149    switch (fOpen & RTFILE_O_ACTION_MASK)
     150    {
     151        case 0: /* temporarily */
     152            AssertMsgFailed(("Missing RTFILE_O_OPEN/CREATE*! (continuable assertion)\n"));
     153            fOpen |= RTFILE_O_OPEN;
     154            break;
     155        case RTFILE_O_OPEN:
     156            AssertMsgReturn(!(RTFILE_O_NOT_CONTENT_INDEXED & fOpen), ("%#x\n", fOpen), VERR_INVALID_PARAMETER);
     157        case RTFILE_O_OPEN_CREATE:
     158        case RTFILE_O_CREATE:
     159        case RTFILE_O_CREATE_REPLACE:
     160            break;
     161        default:
     162            AssertMsgFailed(("Invalid action value: fOpen=%#x\n", fOpen));
     163            return VERR_INVALID_PARAMETER;
     164    }
     165
     166    switch (fOpen & RTFILE_O_DENY_MASK)
     167    {
     168        case 0: /* temporarily */
     169            AssertMsgFailed(("Missing RTFILE_O_DENY_*! (continuable assertion)\n"));
     170            fOpen |= RTFILE_O_DENY_NONE;
     171            break;
     172        case RTFILE_O_DENY_NONE:
     173        case RTFILE_O_DENY_READ:
     174        case RTFILE_O_DENY_WRITE:
     175        case RTFILE_O_DENY_WRITE | RTFILE_O_DENY_READ:
     176        case RTFILE_O_DENY_NOT_DELETE:
     177        case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_READ:
     178        case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_WRITE:
     179        case RTFILE_O_DENY_NOT_DELETE | RTFILE_O_DENY_WRITE | RTFILE_O_DENY_READ:
     180            break;
     181        default:
     182            AssertMsgFailed(("Invalid deny value: fOpen=%#x\n", fOpen));
     183            return VERR_INVALID_PARAMETER;
    156184    }
    157185
    … …  
    288316    RTFILE FileSrc;
    289317    int rc = RTFileOpen(&FileSrc, pszSrc,
    290                         RTFILE_O_READ | (fFlags & RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE ? 0 : RTFILE_O_DENY_WRITE) | RTFILE_O_OPEN);
     318                        RTFILE_O_READ | RTFILE_O_OPEN
     319                        | (fFlags & RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
    291320    if (RT_SUCCESS(rc))
    292321    {
    293322        RTFILE FileDst;
    294323        rc = RTFileOpen(&FileDst, pszDst,
    295                         RTFILE_O_WRITE | (fFlags & RTFILECOPY_FLAGS_NO_DST_DENY_WRITE ? 0 : RTFILE_O_DENY_WRITE) | RTFILE_O_CREATE);
     324                        RTFILE_O_WRITE | RTFILE_O_CREATE
     325                        | (fFlags & RTFILECOPY_FLAGS_NO_DST_DENY_WRITE ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
    296326        if (RT_SUCCESS(rc))
    297327        {

  • trunk/src/VBox/Runtime/r3/posix/fileio-posix.cpp

    r22516 r23973  
    109109
    110110
    111 RTR3DECL(int)  RTFileOpen(PRTFILE pFile, const char *pszFilename, unsigned fOpen)
     111RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, uint32_t fOpen)
    112112{
    113113    /*
    114114     * Validate input.
    115115     */
    116     if (!VALID_PTR(pFile))
    117     {
    118         AssertMsgFailed(("Invalid pFile %p\n", pFile));
    119         return VERR_INVALID_PARAMETER;
    120     }
     116    AssertPtrReturn(pFile, VERR_INVALID_POINTER);
    121117    *pFile = NIL_RTFILE;
    122     if (!VALID_PTR(pszFilename))
    123     {
    124         AssertMsgFailed(("Invalid pszFilename %p\n", pszFilename));
    125         return VERR_INVALID_PARAMETER;
    126     }
     118    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
    127119
    128120    /*

  • trunk/src/VBox/Runtime/r3/win/fileio-win.cpp

    r23302 r23973  
    151151
    152152
    153 RTR3DECL(int)  RTFileOpen(PRTFILE pFile, const char *pszFilename, unsigned fOpen)
     153RTR3DECL(int) RTFileOpen(PRTFILE pFile, const char *pszFilename, uint32_t fOpen)
    154154{
    155155    /*

  • trunk/src/VBox/Runtime/r3/xml.cpp

    r23903 r23973  
    181181    m->strFileName = aFileName;
    182182
    183     unsigned flags = 0;
     183    uint32_t flags = 0;
    184184    switch (aMode)
    185185    {
     186        /** @todo change to RTFILE_O_DENY_WRITE where appropriate. */
    186187        case Mode_Read:
    187             flags = RTFILE_O_READ;
     188            flags = RTFILE_O_READ      | RTFILE_O_OPEN           | RTFILE_O_DENY_NONE;
    188189            break;
    189190        case Mode_WriteCreate:      // fail if file exists
    190             flags = RTFILE_O_WRITE | RTFILE_O_CREATE;
     191            flags = RTFILE_O_WRITE     | RTFILE_O_CREATE         | RTFILE_O_DENY_NONE;
    191192            break;
    192193        case Mode_Overwrite:        // overwrite if file exists
    193             flags = RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE;
     194            flags = RTFILE_O_WRITE     | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_NONE;
    194195            break;
    195196        case Mode_ReadWrite:
    196             flags = RTFILE_O_READ | RTFILE_O_WRITE;
    197     }
    198 
    199     int vrc = RTFileOpen (&m->handle, aFileName, flags);
    200     if (RT_FAILURE (vrc))
    201         throw EIPRTFailure (vrc);
     197            flags = RTFILE_O_READWRITE | RTFILE_O_OPEN           | RTFILE_O_DENY_NONE;;
     198    }
     199
     200    int vrc = RTFileOpen(&m->handle, aFileName, flags);
     201    if (RT_FAILURE(vrc))
     202        throw EIPRTFailure(vrc);
    202203
    203204    m->opened = true;

  • trunk/src/VBox/Runtime/testcase/tstFileAio.cpp

    r19562 r23973  
    274274    /* Reopen the file. */
    275275    RTFileClose(File);
    276     rc = RTFileOpen(&File, "tstFileAio#1.tst", RTFILE_O_READWRITE | RTFILE_O_DENY_NONE | RTFILE_O_ASYNC_IO);
     276    rc = RTFileOpen(&File, "tstFileAio#1.tst", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_ASYNC_IO);
    277277    if (RT_SUCCESS(rc))
    278278    {

  • trunk/src/VBox/Runtime/testcase/tstFileAppend-1.cpp

    r21737 r23973  
    9191    rc = RTFileOpen(&File,
    9292                    "tstFileAppend-1.tst",
    93                     RTFILE_O_OPEN_CREATE |
    94                     RTFILE_O_WRITE |
    95                     RTFILE_O_APPEND |
    96                     RTFILE_O_DENY_NONE |
    97                     (0644 << RTFILE_O_CREATE_MODE_SHIFT)
     93                      RTFILE_O_WRITE
     94                    | RTFILE_O_APPEND
     95                    | RTFILE_O_OPEN_CREATE
     96                    | RTFILE_O_DENY_NONE
     97                    | (0644 << RTFILE_O_CREATE_MODE_SHIFT)
    9898                   );
    9999    if (RT_FAILURE(rc))
    … …  
    140140    rc = RTFileOpen(&File,
    141141                    "tstFileAppend-1.tst",
    142                     RTFILE_O_OPEN |
    143                     RTFILE_O_WRITE |
    144                     RTFILE_O_APPEND |
    145                     RTFILE_O_DENY_NONE
     142                      RTFILE_O_WRITE
     143                    | RTFILE_O_APPEND
     144                    | RTFILE_O_OPEN
     145                    | RTFILE_O_DENY_NONE
    146146                   );
    147147    if (RT_FAILURE(rc))
    … …  
    180180    rc = RTFileOpen(&File,
    181181                    "tstFileAppend-1.tst",
    182                     RTFILE_O_OPEN |
    183                     RTFILE_O_READWRITE |
    184                     RTFILE_O_APPEND |
    185                     RTFILE_O_DENY_NONE
     182                      RTFILE_O_READWRITE
     183                    | RTFILE_O_APPEND
     184                    | RTFILE_O_OPEN
     185                    | RTFILE_O_DENY_NONE
    186186                   );
    187187    if (RT_FAILURE(rc))
    … …  
    260260    rc = RTFileOpen(&File,
    261261                    "tstFileAppend-1.tst",
    262                     RTFILE_O_OPEN |
    263                     RTFILE_O_READ |
    264                     RTFILE_O_APPEND |
    265                     RTFILE_O_DENY_NONE
     262                      RTFILE_O_READ
     263                    | RTFILE_O_APPEND
     264                    | RTFILE_O_OPEN
     265                    | RTFILE_O_DENY_NONE
    266266                   );
    267267    if (RT_FAILURE(rc))

  • trunk/src/VBox/Runtime/testcase/tstIoCtl.cpp

    r8245 r23973  
    6868    RTFILE    File;
    6969
    70     if (RT_FAILURE(err = RTFileOpen(&File, "/dev/dsp", (RTFILE_O_READWRITE) | RTFILE_O_NON_BLOCK))) {
     70    err = RTFileOpen(&File, "/dev/dsp", RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE | RTFILE_O_NON_BLOCK);
     71    if (RT_FAILURE(err)) {
    7172        printf("Fatal error: failed to open /dev/dsp:\n"
    7273               "VBox error code: %d\n", err);

  • trunk/src/VBox/VMM/PDMAsyncCompletionFile.cpp

    r23959 r23973  
    578578        RTFILE File = NIL_RTFILE;
    579579
    580         rc = RTFileOpen(&File, pszUri, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
     580        rc = RTFileOpen(&File, pszUri, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
    581581        if (RT_SUCCESS(rc))
    582582        {

  • trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletion.cpp

    r23404 r23973  
    137137        /* Create the destination as the async completion API can't do this. */
    138138        RTFILE FileTmp;
    139         rc = RTFileOpen(&FileTmp, argv[2], RTFILE_O_READWRITE | RTFILE_O_OPEN_CREATE);
     139        rc = RTFileOpen(&FileTmp, argv[2], RTFILE_O_READWRITE | RTFILE_O_OPEN_CREATE | RTFILE_O_DENY_NONE);
    140140        if (RT_FAILURE(rc))
    141141        {

  • trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletionStress.cpp

    r23813 r23973  
    145145    volatile uint32_t          cTasksActiveCurr;
    146146    /** Pointer to the array of task. */
    147     PPDMACTESTFILETASK         paTasks; 
     147    PPDMACTESTFILETASK         paTasks;
    148148    /** I/O thread handle. */
    149149    PPDMTHREAD                 hThread;
    … …  
    167167    while (cbLeft)
    168168    {
    169         size_t cbCompare; 
     169        size_t cbCompare;
    170170        unsigned iSeg = off / pTestFile->cbFileSegment;
    171171        PPDMACTESTFILESEG pSeg = &pTestFile->paSegs[iSeg];
    … …  
    195195    while (cbLeft)
    196196    {
    197         size_t cbFill; 
     197        size_t cbFill;
    198198        unsigned iSeg = off / pTestFile->cbFileSegment;
    199199        PPDMACTESTFILESEG pSeg = &pTestFile->paSegs[iSeg];
    … …  
    251251    /* Set new file size of required */
    252252    if ((uint64_t)pTestTask->off + pTestTask->DataSeg.cbSeg > pTestFile->cbFileCurr)
    253         pTestFile->cbFileCurr = pTestTask->off + pTestTask->DataSeg.cbSeg; 
     253        pTestFile->cbFileCurr = pTestTask->off + pTestTask->DataSeg.cbSeg;
    254254
    255255    AssertMsg(pTestFile->cbFileCurr <= pTestFile->cbFileMax,
    … …  
    286286
    287287    AssertMsg(pTestFile->cbFileCurr >= pTestTask->DataSeg.cbSeg, ("Impossible\n"));
    288     pTestTask->off = RTRandU64Ex(0, pTestFile->cbFileCurr - pTestTask->DataSeg.cbSeg); 
     288    pTestTask->off = RTRandU64Ex(0, pTestFile->cbFileCurr - pTestTask->DataSeg.cbSeg);
    289289
    290290    /* Allocate data buffer. */
    … …  
    329329    {
    330330        unsigned iTaskCurr = 0;
    331        
     331
    332332
    333333        /* Fill all tasks */
    … …  
    411411    pTestFile->cbFileMax     = RTRandU64Ex(FILE_SIZE_MIN, FILE_SIZE_MAX) & ~(511UL);
    412412    pTestFile->cbFileCurr    = 0;
    413     pTestFile->cbFileSegment = RTRandU32Ex(SEGMENT_SIZE_MIN, RT_MIN(pTestFile->cbFileMax, SEGMENT_SIZE_MAX)) & ~((size_t)511); 
     413    pTestFile->cbFileSegment = RTRandU32Ex(SEGMENT_SIZE_MIN, RT_MIN(pTestFile->cbFileMax, SEGMENT_SIZE_MAX)) & ~((size_t)511);
    414414
    415415    Assert(pTestFile->cbFileMax >= pTestFile->cbFileSegment);
    … …  
    454454
    455455                RTFILE FileTmp;
    456                 rc = RTFileOpen(&FileTmp, szFile, RTFILE_O_CREATE | RTFILE_O_READWRITE);
     456                rc = RTFileOpen(&FileTmp, szFile, RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_NONE);
    457457                if (RT_SUCCESS(rc))
    458458                {
    … …  
    504504}
    505505
    506 /** 
     506/**
    507507 * Closes a test file.
    508508 *
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