VirtualBox

Changeset 81137 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Oct 8, 2019 8:28:31 AM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133770
Message:

IPRT/RTSystem*Firmware: Simplified the interface and made it follow the style of the rest of RTSystemQuery*. Added RTSystemFirmwareTypeName() to avoid duplicating enum->string code over and over again.

Location:
trunk/src/VBox
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/glue/VBoxLogRelCreate.cpp

    r81131 r81137  
    8686
    8787            RTSYSFWTYPE enmType;
    88             vrc = RTSystemFirmwareQueryType(&enmType);
     88            vrc = RTSystemQueryFirmwareType(&enmType);
    8989            if (RT_SUCCESS(vrc))
    9090            {
    91                 pfnLog(pReleaseLogger, "Firmware type: ");
    92 
    93                 switch (enmType)
    94                 {
    95                     case RTSYSFWTYPE_BIOS:
    96                         pfnLog(pReleaseLogger, "BIOS\n");
    97                         break;
    98                     case RTSYSFWTYPE_UEFI:
    99                         pfnLog(pReleaseLogger, "UEFI\n");
    100                         break;
    101                     case RTSYSFWTYPE_UNKNOWN: /* Not implemented on this platforms? */
    102                         pfnLog(pReleaseLogger, "Unknown\n");
    103                         break;
    104                     default:
    105                         AssertFailed();
    106                         break;
    107                 }
    108 
     91                pfnLog(pReleaseLogger, "Firmware type: %s\n", RTSystemFirmwareTypeName(enmType));
    10992                if (enmType == RTSYSFWTYPE_UEFI)
    11093                {
    111                      RTSYSFWVALUE Value;
    112                      vrc = RTSystemFirmwareQueryValue(RTSYSFWPROP_SECURE_BOOT, &Value);
     94                     bool fValue;
     95                     vrc = RTSystemQueryFirmwareBoolean(RTSYSFWPROP_SECURE_BOOT, &fValue);
    11396                     if (RT_SUCCESS(vrc))
    114                      {
    115                          Assert(Value.enmType == RTSYSFWVALUETYPE_BOOLEAN);
    116                          pfnLog(pReleaseLogger, "Secure Boot: %s\n", Value.u.fVal ? "Enabled" : "Disabled");
    117                          RTSystemFirmwareFreeValue(&Value);
    118                      }
     97                         pfnLog(pReleaseLogger, "Secure Boot: %s\n", fValue ? "Enabled" : "Disabled");
     98                     else
     99                         pfnLog(pReleaseLogger, "Secure Boot: %Rrc\n", vrc);
    119100                }
    120101            }
     102            else
     103                pfnLog(pReleaseLogger, "Firmware type: failed - %Rrc\n", vrc);
    121104
    122105            uint64_t cbHostRam = 0, cbHostRamAvail = 0;
    … …  
    154137            break;
    155138        }
     139
    156140        case RTLOGPHASE_PREROTATE:
    157141            pfnLog(pReleaseLogger, "Log rotated - Log started %s\n", szTmp);

  • trunk/src/VBox/Runtime/Makefile.kmk

    r81079 r81137  
    484484        common/misc/RTFileOpenV.cpp \
    485485        common/misc/RTMemWipeThoroughly.cpp \
     486        common/misc/RTSystemFirmwareTypeName.cpp \
    486487        common/misc/assert.cpp \
    487488        common/misc/buildconfig.cpp \

  • trunk/src/VBox/Runtime/generic/RTSystemFirmware-generic.cpp

    r81062 r81137  
    3636
    3737
    38 RTDECL(int) RTSystemFirmwareQueryType(PRTSYSFWTYPE penmFirmwareType)
     38RTDECL(int) RTSystemQueryFirmwareType(PRTSYSFWTYPE penmFirmwareType)
    3939{
    4040    RT_NOREF(penmFirmwareType);
    … …  
    4242    return VERR_NOT_SUPPORTED;
    4343}
    44 RT_EXPORT_SYMBOL(RTSystemFirmwareQueryType);
     44RT_EXPORT_SYMBOL(RTSystemQueryFirmwareType);
    4545
    4646
    47 RTDECL(void) RTSystemFirmwareFreeValue(PRTSYSFWVALUE pValue)
     47RTDECL(int) RTSystemQueryFirmwareBoolean(RTSYSFWPROP enmProp, bool *pfValue)
    4848{
    49     RT_NOREF(pValue);
    50 }
    51 RT_EXPORT_SYMBOL(RTSystemFirmwareFreeValue);
    52 
    53 
    54 RTDECL(int) RTSystemFirmwareQueryValue(RTSYSFWPROP enmProp, PRTSYSFWVALUE pValue)
    55 {
    56     RT_ZERO(*pValue);
    57     RT_NOREF(enmProp);
     49    RT_NOREF(enmProp, pfValue);
    5850    return VERR_NOT_SUPPORTED;
    5951}
    60 RT_EXPORT_SYMBOL(RTSystemFirmwareQueryValue);
     52RT_EXPORT_SYMBOL(RTSystemQueryFirmwareBoolean);
    6153

  • trunk/src/VBox/Runtime/r3/linux/RTSystemFirmware-linux.cpp

    r81068 r81137  
    4545
    4646
    47 RTDECL(int) RTSystemFirmwareQueryType(PRTSYSFWTYPE penmFirmwareType)
     47RTDECL(int) RTSystemQueryFirmwareType(PRTSYSFWTYPE penmFirmwareType)
    4848{
    4949    if (RTLinuxSysFsExists("firmware/efi/"))
    … …  
    5858    return VINF_SUCCESS;
    5959}
    60 RT_EXPORT_SYMBOL(RTSystemFirmwareQueryType);
     60RT_EXPORT_SYMBOL(RTSystemQueryFirmwareType);
    6161
    6262
    63 RTDECL(void) RTSystemFirmwareFreeValue(PRTSYSFWVALUE pValue)
     63RTDECL(int) RTSystemQueryFirmwareBoolean(RTSYSFWPROP enmProp, bool *pfValue)
    6464{
    65     RT_NOREF(pValue);
    66 }
    67 RT_EXPORT_SYMBOL(RTSystemFirmwareFreeValue);
    68 
    69 
    70 RTDECL(int) RTSystemFirmwareQueryValue(RTSYSFWPROP enmProp, PRTSYSFWVALUE pValue)
    71 {
    72     RT_ZERO(*pValue);
     65    *pfValue = false;
    7366
    7467    /*
    75      * Translate the property into type and variable base filename.
     68     * Translate the property to variable base filename.
    7669     */
    7770    const char *pszName;
    … …  
    7972    {
    8073        case RTSYSFWPROP_SECURE_BOOT:
    81             pValue->enmType = RTSYSFWVALUETYPE_BOOLEAN;
    8274            pszName = "firmware/efi/efivars/SecureBoot";
    8375            break;
    … …  
    9587    int rc = RTLinuxSysFsOpen(&hFile, "%s-" VBOX_UEFI_UUID_GLOBALS, pszName);
    9688    /** @todo try other suffixes if file-not-found. */
    97 
    98     switch (pValue->enmType)
     89    if (RT_SUCCESS(rc))
    9990    {
    100         case RTSYSFWVALUETYPE_BOOLEAN:
    101         {
    102             if (RT_SUCCESS(rc))
    103             {
    104                 uint8_t abBuf[16];
    105                 size_t  cbRead = 0;
    106                 rc = RTLinuxSysFsReadFile(hFile, abBuf, sizeof(abBuf), &cbRead);
    107                 pValue->u.fVal = cbRead > 1 && abBuf[cbRead - 1] != 0;
    108                 RTFileClose(hFile);
    109             }
    110             else if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
    111                 rc = VINF_SUCCESS;
    112             else if (rc == VERR_PERMISSION_DENIED)
    113                 rc = VERR_NOT_SUPPORTED;
    114             break;
    115         }
    116 
    117         default:
    118             AssertFailedReturn(VERR_INTERNAL_ERROR);
     91        uint8_t abBuf[16];
     92        size_t  cbRead = 0;
     93        rc = RTLinuxSysFsReadFile(hFile, abBuf, sizeof(abBuf), &cbRead);
     94        *pfValue = cbRead > 1 && abBuf[cbRead - 1] != 0;
     95        RTFileClose(hFile);
    11996    }
     97    else if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
     98        rc = VINF_SUCCESS;
     99    else if (rc == VERR_PERMISSION_DENIED)
     100        rc = VERR_NOT_SUPPORTED;
    120101
    121102    return rc;
    122103}
    123 RT_EXPORT_SYMBOL(RTSystemFirmwareQueryValue);
     104RT_EXPORT_SYMBOL(RTSystemQueryFirmwareBoolean);
    124105

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

    r81063 r81137  
    119119
    120120
    121 RTDECL(int) RTSystemFirmwareQueryType(PRTSYSFWTYPE penmFirmwareType)
     121RTDECL(int) RTSystemQueryFirmwareType(PRTSYSFWTYPE penmFirmwareType)
    122122{
    123123    AssertPtrReturn(penmFirmwareType, VERR_INVALID_POINTER);
    … …  
    173173
    174174
    175 RTDECL(void) RTSystemFirmwareFreeValue(PRTSYSFWVALUE pValue)
    176 {
    177     RT_NOREF(pValue);
    178 }
    179 
    180 
    181 RTDECL(int) RTSystemFirmwareQueryValue(RTSYSFWPROP enmProp, PRTSYSFWVALUE pValue)
    182 {
    183     RT_ZERO(*pValue);
     175RTDECL(int) RTSystemQueryFirmwareBoolean(RTSYSFWPROP enmProp, bool *pfValue)
     176{
     177    *pfValue = false;
    184178
    185179    /*
    186      * Translate the enmProp to a name and type:
     180     * Translate the enmProp to a name:
    187181     */
    188182    const wchar_t *pwszName = NULL;
    … …  
    191185        case RTSYSFWPROP_SECURE_BOOT:
    192186            pwszName = L"SecureBoot";
    193             pValue->enmType = RTSYSFWVALUETYPE_BOOLEAN;
    194187            break;
    195188
    … …  
    200193
    201194    /*
    202      * Do type specific query.
     195     * Do the query.
    203196     */
    204197    if (!g_pfnGetFirmwareEnvironmentVariableW)
    … …  
    206199    rtSystemFirmwareGetPrivileges(SE_SYSTEM_ENVIRONMENT_NAME);
    207200
    208     int rc;
    209     switch (pValue->enmType)
    210     {
    211         case RTSYSFWVALUETYPE_BOOLEAN:
    212         {
    213             uint8_t bValue = 0;
    214             DWORD cbRet = g_pfnGetFirmwareEnvironmentVariableW(pwszName, VBOX_UEFI_UUID_GLOBALS, &bValue, sizeof(bValue));
    215             pValue->u.fVal = cbRet != 0 && bValue != 0;
    216             rc = cbRet != 0 || GetLastError() == ERROR_INVALID_FUNCTION ? VINF_SUCCESS : RTErrConvertFromWin32(GetLastError());
    217             break;
    218         }
    219 
    220         default:
    221             AssertFailedReturn(VERR_INTERNAL_ERROR);
    222     }
    223 
    224     return rc;
    225 }
    226 
     201    uint8_t bValue = 0;
     202    DWORD cbRet = g_pfnGetFirmwareEnvironmentVariableW(pwszName, VBOX_UEFI_UUID_GLOBALS, &bValue, sizeof(bValue));
     203    *pfValue = cbRet != 0 && bValue != 0;
     204    return cbRet != 0 || GetLastError() == ERROR_INVALID_FUNCTION ? VINF_SUCCESS : RTErrConvertFromWin32(GetLastError());
     205}
     206

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

    r81064 r81137  
    4646
    4747    /*
    48      * RTSystemFirmwareQueryType
     48     * RTSystemQueryFirmwareType
    4949     */
    50     RTTestSub(hTest, "RTSystemFirmwareQueryType");
     50    RTTestSub(hTest, "RTSystemQueryFirmwareType");
    5151    RTSYSFWTYPE enmType = (RTSYSFWTYPE)-42;
    52     int rc = RTSystemFirmwareQueryType(&enmType);
     52    int rc = RTSystemQueryFirmwareType(&enmType);
    5353    if (RT_SUCCESS(rc))
    5454    {
    … …  
    5656        {
    5757            case RTSYSFWTYPE_BIOS:
    58                 RTTestPrintf(hTest, RTTESTLVL_INFO, "  Firmware type: BIOS (Legacy)\n");
    59                 break;
    6058            case RTSYSFWTYPE_UEFI:
    61                 RTTestPrintf(hTest, RTTESTLVL_INFO, "  Firmware type: UEFI\n");
    62                 break;
    6359            case RTSYSFWTYPE_UNKNOWN: /* Do not fail on not-implemented platforms. */
    64                 RTTestPrintf(hTest, RTTESTLVL_INFO, "  Firmware type: Unknown\n");
     60                RTTestPrintf(hTest, RTTESTLVL_INFO, "  Firmware type: %s\n", RTSystemFirmwareTypeName(enmType));
    6561                break;
    6662            default:
    67                 RTTestFailed(hTest, "RTSystemFirmwareQueryType return invalid type: %d (%#x)", enmType, enmType);
     63                RTTestFailed(hTest, "RTSystemQueryFirmwareType return invalid type: %d (%#x)", enmType, enmType);
    6864                break;
    6965        }
    7066    }
    7167    else if (rc != VERR_NOT_SUPPORTED)
    72         RTTestFailed(hTest, "RTSystemFirmwareQueryType failed: %Rrc", rc);
     68        RTTestFailed(hTest, "RTSystemQueryFirmwareType failed: %Rrc", rc);
    7369
    7470    /*
    75      * RTSystemFirmwareQueryValue
     71     * RTSystemQueryFirmwareBoolean
    7672     */
    77     RTTestSub(hTest, "RTSystemFirmwareQueryValue");
    78     RTSYSFWVALUE Value;
    79     rc = RTSystemFirmwareQueryValue(RTSYSFWPROP_SECURE_BOOT, &Value);
     73    RTTestSub(hTest, "RTSystemQueryFirmwareBoolean");
     74    bool fValue;
     75    rc = RTSystemQueryFirmwareBoolean(RTSYSFWPROP_SECURE_BOOT, &fValue);
    8076    if (RT_SUCCESS(rc))
    81     {
    82         RTTEST_CHECK(hTest, Value.enmType == RTSYSFWVALUETYPE_BOOLEAN);
    83         RTTestPrintf(hTest, RTTESTLVL_INFO, "  Secure Boot:   %s\n", Value.u.fVal ? "enabled" : "disabled");
    84         RTSystemFirmwareFreeValue(&Value);
    85         RTSystemFirmwareFreeValue(&Value);
    86     }
     77        RTTestPrintf(hTest, RTTESTLVL_INFO, "  Secure Boot:   %s\n", fValue ? "enabled" : "disabled");
    8778    else if (rc != VERR_NOT_SUPPORTED && rc != VERR_SYS_UNSUPPORTED_FIRMWARE_PROPERTY)
    88         RTTestIFailed("RTSystemFirmwareQueryValue/RTSYSFWPROP_SECURE_BOOT failed: %Rrc", rc);
     79        RTTestIFailed("RTSystemQueryFirmwareBoolean/RTSYSFWPROP_SECURE_BOOT failed: %Rrc", rc);
    8980
    9081    return RTTestSummaryAndDestroy(hTest);
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