SdReaderWriterのResultをハンドリングするように

git-svn-id: file:///Volumes/Transfer/gigaleak_20231201/2020-05-23%20-%20ctr.7z%20+%20svn_v1.068.zip/ctr/svn/ctr_Repair@359 385bec56-5757-e545-9c3a-d8741f4650f1

trunk/ConsoleDataMigration/sources/ConsoleBackup/Controller.cpp

@@ -163,7 +163,11 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
             InitializeFileListContext();
 
             // データを書き込む
-            ExportTwlSaveData();
+            if(ExportTwlSaveData().IsFailure())
+            {
+                s_BackupState = FAIL;
+                break;
+            }
             init = false;
         }
 
@@ -234,7 +238,6 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
             {
                 s_BackupState = FAIL;
             }
-
         }
     }
     break;
@@ -252,8 +255,12 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
         }
 
         // データを書き込む
-        ExportData(manager);
+        if (!ExportData(manager))
-
+        {
+            s_BackupState = FAIL;
+        }
+        else
+        {
             // 処理が完了した
             if (continueBackup && IsExportThreadFinished())
             {
@@ -276,6 +283,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
                     s_BackupState = FAIL;
                 }
             }
+
+        }
     }
     break;
 

trunk/ConsoleDataMigration/sources/ConsoleBackup/Exporter.cpp

@@ -70,7 +70,7 @@ nn::crypto::Sha256Context s_FileListContext;
 
 void AddCmac(nn::fs::FileOutputStream* file, nn::crypto::Sha256Context* context);
 
-void DeleteTrash(std::wstring currentDirectory)
+nn::Result DeleteTrash(std::wstring currentDirectory)
 {
     // TODO: リードオンリーのファイルが消去できない
 
@@ -82,12 +82,12 @@ void DeleteTrash(std::wstring currentDirectory)
     std::vector<nn::fs::DirectoryEntry> entryList; //カレントディレクトリのエントリ一覧を格納
     std::vector<nn::fs::DirectoryEntry>::iterator entryIndex;
 
-    common::SdMountManager::Mount();
+    result = common::SdMountManager::Mount();
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = dir.TryInitialize(currentDirectory.c_str());
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
-    if (result.IsSuccess())
-    {
     nn::fs::DirectoryEntry entry;
     s32 numEntry;
     for (;;)
@@ -109,21 +109,21 @@ void DeleteTrash(std::wstring currentDirectory)
                 if (entryIndex->attributes.isDirectory)
                 {
                     NN_LOG("Try Delete %ls%ls/\n", currentDirectory.c_str(), entryIndex->entryName);
-                        result = nn::fs::TryDeleteDirectoryRecursively((currentDirectory + ::std::wstring(
+                    result = nn::fs::TryDeleteDirectoryRecursively(
-                                entryIndex->entryName)).c_str());
+                            (currentDirectory + ::std::wstring(entryIndex->entryName)).c_str());
-                        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
                 }
                 // ファイルならログとAP設定以外は削除する
                 else
                 {
-                        if (std::wcscmp(entryIndex->entryName, common::AP_SETTING_FILENAME) != 0 && std::wcscmp(
+                    if (std::wcscmp(entryIndex->entryName, common::AP_SETTING_FILENAME) != 0
-                                entryIndex->entryName, common::LOG_FILENAME) != 0)
+                            && std::wcscmp(entryIndex->entryName, common::LOG_FILENAME) != 0)
                     {
                         NN_LOG("Try Delete %ls%ls\n", currentDirectory.c_str(), entryIndex->entryName);
                         result = nn::fs::TryDeleteFile(
                                 (currentDirectory + ::std::wstring(entryIndex->entryName)).c_str());
-                            COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
                     }
                 }
             }
@@ -145,15 +145,9 @@ void DeleteTrash(std::wstring currentDirectory)
             }
         }
     }
-    }
-    else
-    {
-        NN_LOG("failed initialize directory\n");
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-        dir.Finalize();
-    }
 
-    common::SdMountManager::Unmount();
+    result = common::SdMountManager::Unmount();
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 }
 
 nn::Result WriteTwlTitleList(std::vector<std::wstring>& programIdList)
@@ -180,17 +174,17 @@ nn::Result WriteTwlTitleList(std::vector<std::wstring>& programIdList)
 }
 
 
-void WriteRegionData()
+nn::Result WriteRegionData()
 {
     COMMON_LOGGER("Export Region Data.\n");
 
     nn::cfg::CTR::CfgRegionCode region;
     region = nn::cfg::CTR::GetRegion();
 
-    s_SdWriter.WriteBufWithCmac(common::REGION_DATA_PATHNAME, &region, sizeof(nn::cfg::CTR::CfgRegionCode));
+    return s_SdWriter.WriteBufWithCmac(common::REGION_DATA_PATHNAME, &region, sizeof(nn::cfg::CTR::CfgRegionCode));
 }
 
-void WriteCountryLanguageData()
+nn::Result WriteCountryLanguageData()
 {
     COMMON_LOGGER("Export Country and Language Data.\n");
 
@@ -205,11 +199,13 @@ void WriteCountryLanguageData()
         // 言語設定
         s_CountryLanguage.language = nn::cfg::CTR::GetLanguage();
 
-        s_SdWriter.WriteBufWithCmac(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage));
+        return s_SdWriter.WriteBufWithCmac(common::COUNTRY_SETTING_PATHNAME, &s_CountryLanguage, sizeof(s_CountryLanguage));
     }
+
+    return nn::ResultSuccess();
 }
 
-void WriteNorData()
+nn::Result WriteNorData()
 {
     COMMON_LOGGER("Export NOR Data.\n");
 
@@ -221,20 +217,20 @@ void WriteNorData()
 
     // NTR設定
     result = nn::cfg::nor::CTR::GetNtrSetting(&s_NtrNorData.ntrConfig.ncd, &s_NtrNorData.ntrConfig.ncd_ex);
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     // TWL WiFi設定
     result = nn::cfg::nor::CTR::ReadTwlWifiSetting(0, s_NtrNorData.TwlWiFiSetting, common::TWL_WIFI_SETTING_SIZE);
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     // NTR WiFi設定
     result = nn::cfg::nor::CTR::ReadNtrWifiSetting(0, s_NtrNorData.NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE);
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
-    s_SdWriter.WriteBufWithCmac(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData));
+    return s_SdWriter.WriteBufWithCmac(common::NOR_PATHNAME, &s_NtrNorData, sizeof(common::NtrNorData));
 }
 
-void WriteSerialNumber(common::HardwareStateManager& manager)
+nn::Result WriteSerialNumber(common::HardwareStateManager& manager)
 {
     COMMON_LOGGER("Export Serial Number.\n");
 
@@ -242,19 +238,19 @@ void WriteSerialNumber(common::HardwareStateManager& manager)
     size_t size;
     manager.GetSerialNumber(&serial, &size);
 
-    s_SdWriter.WriteBufWithCmac(common::SERIAL_PATHNAME, serial, size);
+    return s_SdWriter.WriteBufWithCmac(common::SERIAL_PATHNAME, serial, size);
 }
 
-void WriteDeviceId(common::HardwareStateManager& manager)
+nn::Result WriteDeviceId(common::HardwareStateManager& manager)
 {
     COMMON_LOGGER("Export Device ID.\n");
 
     bit32 deviceId = manager.GetDeviceId();
 
-    s_SdWriter.WriteBufWithCmac(common::DEVICE_ID_PATHNAME, &deviceId, sizeof(deviceId));
+    return s_SdWriter.WriteBufWithCmac(common::DEVICE_ID_PATHNAME, &deviceId, sizeof(deviceId));
 }
 
-void WriteIvs(common::HardwareStateManager& manager)
+nn::Result WriteIvs(common::HardwareStateManager& manager)
 {
     COMMON_LOGGER("Export SDCI.\n");
 
@@ -276,7 +272,12 @@ void WriteIvs(common::HardwareStateManager& manager)
         swAesCtrContest.Initialize(common::iv, common::key, sizeof(common::key));
         swAesCtrContest.Encrypt(enc, ivs, size);
 
-        s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size);
+        return s_SdWriter.WriteBufWithCmac(common::IVS_PATHNAME, enc, size);
+    }
+    else
+    {
+        return nn::Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_OUT_OF_RESOURCE, nn::Result::MODULE_COMMON,
+                nn::Result::DESCRIPTION_OUT_OF_MEMORY);
     }
 }
 
@@ -679,12 +680,15 @@ void InitializeFileListContext()
     s_FileListContext.Initialize();
 }
 
-void ExportTwlSaveData()
+nn::Result ExportTwlSaveData()
 {
     // 不要なデータを削除する
-    DeleteTrash((std::wstring(common::LOG_ROOT_DIRECTORY_PATH) + std::wstring(L"/")).c_str());
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(
+    DeleteTrash((std::wstring(common::LOG_ROOT_DIRECTORY_PATH) + std::wstring(L"/")).c_str()));
 
     s_ExportThread.Start(WriteTwlSaveData, s_ExportThreadStack);
+
+    return nn::ResultSuccess();
 }
 
 void ExportTwlPhotoData()
@@ -698,7 +702,7 @@ void ExportTwlSoundData()
 }
 
 
-void WriteMcuRtcData(common::HardwareStateManager& manager)
+nn::Result WriteMcuRtcData(common::HardwareStateManager& manager)
 {
     COMMON_LOGGER("Export RTC Data.\n");
     nn::Result result;
@@ -709,26 +713,27 @@ void WriteMcuRtcData(common::HardwareStateManager& manager)
         nn::mcu::CTR::HwCheck mcu(handle);
 
         nn::mcu::CTR::RtcData rtc;
-        result = mcu.GetRtcAll(&rtc);
         const u8 RETRY = 10;
         for (u8 i = 0; i < RETRY; i++)
         {
+            result = mcu.GetRtcAll(&rtc);
             if (result.IsSuccess())
             {
                 NN_LOG("RTC = 20%02d/%02d/%02d %02d:%02d:%02d\n", rtc.m_Year, rtc.m_Month, rtc.m_Day, rtc.m_Hour, rtc.m_Minute, rtc.m_Second);
-                COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
 
-                s_SdWriter.WriteBufWithCmac(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc));
+                return s_SdWriter.WriteBufWithCmac(common::MCU_RTC_PATHNAME, &rtc, sizeof(rtc));
-                break;
             }
             nn::os::Thread::Sleep(
                     nn::fnd::TimeSpan::FromMilliSeconds(
                             nn::os::Tick::GetSystemCurrent().ToTimeSpan().GetMilliSeconds() % 100));
         }
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
     }
     else
     {
         NN_LOG("invalid handle\n");
+        return nn::Result(nn::Result::LEVEL_FATAL, nn::Result::SUMMARY_INVALID_STATE, nn::Result::MODULE_COMMON,
+                nn::Result::DESCRIPTION_INVALID_HANDLE);
     }
 }
 
@@ -793,13 +798,15 @@ nn::Result WriteSaveData(::std::string& sysSaveRoot)
     nn::Result result;
 
     result = nn::fs::MountSpecialArchive(common::NAND_ARCHIVE_NAME, nn::fs::CTR::ARCHIVE_TYPE_CTR_NAND);
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     u32 fileNum = 0;
     s64 fileSize = 0;
-    common::CalculateFileNum(::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH), fileNum, fileSize);
+    result = common::CalculateFileNum(::std::wstring(common::NAND_DATA_ROOT_PATHNAME_WITH_SLASH), fileNum, fileSize);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
-    nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
+    result = nn::fs::Unmount(common::NAND_ARCHIVE_NAME);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     NN_LOG("File Number = %d\n", fileNum);
     NN_LOG("File Size   = %d\n", fileSize);
@@ -812,8 +819,9 @@ nn::Result WriteSaveData(::std::string& sysSaveRoot)
 
     // セーブデータディレクトリ以下のデータをSDカードにコピー
     // コピー用ディレクトリ作成
-    s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
+    result = s_SdWriter.CreateDirectory((::std::wstring(common::SDMC_ROOT_DIRECTORY_PATH) + ::std::wstring(
             common::SD_SAVEDATA_ROOT_NAME)).c_str());
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     COMMON_LOGGER("Export NAND Data Start...\n");
 
@@ -829,14 +837,14 @@ void FinalizeExportThread()
     s_ExportThread.Finalize();
 }
 
-void WriteVersionData(common::HardwareStateManager& manager)
+nn::Result WriteVersionData(common::HardwareStateManager& manager)
 {
     COMMON_LOGGER("Export Version Data.\n");
 
     common::VerDef versionData;
     manager.GetVersionData(&versionData);
 
-    s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef));
+    return s_SdWriter.WriteBufWithCmac(common::VERSION_DATA_PATHNAME, &versionData, sizeof(common::VerDef));
 }
 
 bool DeleteNimSaveData()
@@ -872,29 +880,48 @@ void AddShutDownPtmEvent()
             nn::fnd::DateTime::GetNow());
 }
 
-void ExportData(common::HardwareStateManager& manager)
+bool ExportData(common::HardwareStateManager& manager)
 {
     static bool init = true;
 
     if (init)
     {
+        nn::Result result;
+
         // リージョンデータをSDに書き込む
-        WriteRegionData();
+        result = WriteRegionData();
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         // 国データと言語データをSDに書き込む
-        WriteCountryLanguageData();
+        result = WriteCountryLanguageData();
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         // NORデータをSDカードに書き込む
-        WriteNorData();
+        result = WriteNorData();
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         // シリアルナンバーをSDカードに書き込む
-        WriteSerialNumber(manager);
+        result = WriteSerialNumber(manager);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         // デバイスIDをSDカードに書き込む
-        WriteDeviceId(manager);
+        result = WriteDeviceId(manager);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         // 完全性検証SEEDをSDカードに書き込む
-        WriteIvs(manager);
+        result = WriteIvs(manager);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
+
+        // 電源断の履歴をptmに追加する
+        AddShutDownPtmEvent();
+
+        // RTCをSDに書き出す
+        result = WriteMcuRtcData(manager);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
+
+        // バージョン情報をSDに書き出す
+        result = WriteVersionData(manager);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         ::std::string systemSaveRoot;
         void* ivs;
@@ -903,20 +930,14 @@ void ExportData(common::HardwareStateManager& manager)
         // IVSからセーブデータディレクトリ名を計算
         common::Util::GetSaveDataDirectoryRoot(systemSaveRoot, ivs, size);
 
-        // 電源断の履歴をptmに追加する
-        AddShutDownPtmEvent();
-
-        // RTCをSDに書き出す
-        WriteMcuRtcData(manager);
-
-        // バージョン情報をSDに書き出す
-        WriteVersionData(manager);
-
         // NANDのセーブデータをSDに書き出す
-        WriteSaveData(systemSaveRoot);
+        result = WriteSaveData(systemSaveRoot);
+        COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
 
         init = false;
     }
+
+    return true;
 }
 
 u32 GetProgress()

trunk/ConsoleDataMigration/sources/ConsoleBackup/Exporter.h

@@ -27,7 +27,7 @@ namespace ConsoleBackup
 void InitializeFileListContext();
 
 // 新たにスレッドを起動して、DSiWareのセーブデータをSDカードに出力する
-void ExportTwlSaveData();
+nn::Result ExportTwlSaveData();
 
 // 新たにスレッドを起動して、TWL写真領域のデータをSDカードに出力する
 void ExportTwlPhotoData();
@@ -37,7 +37,7 @@ void ExportTwlSoundData();
 
 // 本体固有情報をSDカードに出力する
 // 新たにスレッドを起動して、CTR領域のセーブデータをSDカードに出力する
-void ExportData(common::HardwareStateManager& manager);
+bool ExportData(common::HardwareStateManager& manager);
 
 // NIMのセーブデータをSDカードから削除する
 bool DeleteNimSaveData();

trunk/ConsoleDataMigration/sources/ConsoleRestore/Controller.cpp

@@ -1223,7 +1223,8 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
             {
                 s_RestoreState = FAIL;
             }
-
+            else
+            {
                 PutAliveMessage(operationMessage, "Importing Nand Data");
 
                 // 処理が完了した
@@ -1249,6 +1250,7 @@ void ControlState(common::HardwareStateManager& manager, ::std::vector<std::stri
                     }
                 }
             }
+        }
         break;
 
             // リブート中

trunk/ConsoleDataMigration/sources/ConsoleRestore/Importer.cpp

@@ -773,7 +773,7 @@ nn::Result ImportNorData()
             // cfgを使ってセットする
             result = nn::cfg::nor::CTR::SetNtrSetting(&reinterpret_cast<common::NtrNorData*>(buf)->ntrConfig.ncd,
                     &reinterpret_cast<common::NtrNorData*>(buf)->ntrConfig.ncd_ex);
-            COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+            COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
             // WiFiコネクションIDが仮の値であればWiFi設定は移行しない
             // TWL修理に準拠している
@@ -801,26 +801,25 @@ nn::Result ImportNorData()
                 // TWL WiFi設定
                 result = nn::cfg::nor::CTR::WriteTwlWifiSetting(0,
                         reinterpret_cast<common::NtrNorData*> (buf)->TwlWiFiSetting, common::TWL_WIFI_SETTING_SIZE);
-                COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
                 // NTR WiFi設定
                 result = nn::cfg::nor::CTR::WriteNtrWifiSetting(0,
                         reinterpret_cast<common::NtrNorData*> (buf)->NtrWiFiSetting, common::NTR_WIFI_SETTING_SIZE);
-                COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
             }
             else
             {
                 // クリアしておく
                 result = nn::cfg::nor::CTR::ClearTwlWifiSetting();
-                COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
                 result = nn::cfg::nor::CTR::ClearNtrWifiSetting();
-                COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+                COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
             }
         }
 
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
-        NN_UTIL_RETURN_IF_FAILED(result);
     }
     else
     {
@@ -861,8 +860,7 @@ nn::Result ReadVersionData()
                     s_SDVersionData.nup.majorVersion);
         }
 
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
-        NN_UTIL_RETURN_IF_FAILED(result);
     }
     else
     {
@@ -925,7 +923,7 @@ bool ExistsIvsDirectory(std::string& ivsRoot)
     }
 }
 
-void Cleanup()
+nn::Result Cleanup()
 {
     nn::Result result;
     bool execCleanup;
@@ -936,10 +934,11 @@ void Cleanup()
         if(execCleanup)
         {
             COMMON_LOGGER("Cleanup NAND\n");
-            nn::am::DoCleanup(nn::fs::MEDIA_TYPE_NAND);
+            return nn::am::DoCleanup(nn::fs::MEDIA_TYPE_NAND);
         }
     }
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+
+    return result;
 }
 
 void DeleteAllCheckFiles()
@@ -1591,7 +1590,7 @@ void ClearFileReadResult()
     s_ReadSerialNumber = false;
 }
 
-void ExportCalData()
+nn::Result ExportCalData()
 {
     using namespace nn::cfg::CTR::detail;
 
@@ -1601,43 +1600,48 @@ void ExportCalData()
 
     COMMON_LOGGER("Export CalData\n");
 
-    common::SdMountManager::Mount();
+    result = common::SdMountManager::Mount();
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.touchPanelCfgData, sizeof(TouchPanelCfgData),
             GET_CFG_KEY(NN_CFG_HID, NN_CFG_HID_CAL_TOUCHPANEL));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.lcdFlickerCfgData, sizeof(LcdFlickerCfgData),
             GET_CFG_KEY(NN_CFG_LCD, NN_CFG_LCD_CAL_FLICKER));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.fcramCfgData, sizeof(FcramCfgData),
             GET_CFG_KEY(NN_CFG_FCRAM, NN_CFG_FCRAM_CAL_DELAY));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.rtcCfgData, sizeof(RtcCfgData),
             GET_CFG_KEY(NN_CFG_RTC, NN_CFG_RTC_CAL_COMPENSATION));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.gyroscopeCfgData, sizeof(GyroscopeCfgData),
             GET_CFG_KEY(NN_CFG_HID, NN_CFG_HID_CAL_GYROSCOPE));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.accelCfgData, sizeof(AccelCfgData),
             GET_CFG_KEY(NN_CFG_HID, NN_CFG_HID_CAL_ACCELEROMETER));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.codecCfgData, sizeof(CodecCfgData),
             GET_CFG_KEY(NN_CFG_CODEC, NN_CFG_CODEC_CAL));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = nn::cfg::CTR::init::GetConfig(&cfgCalData.mcuSlideVolumeRangeCfgData, sizeof(McuSlideVolumeRangeCfgData),
             GET_CFG_KEY(NN_CFG_MCU, NN_CFG_MCU_SLIDE_VOLUME));
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
-    sdWriter.WriteBufWithCmac(common::CFG_CALIBRATION_PATHNAME, &cfgCalData, sizeof(cfgCalData));
+    result = sdWriter.WriteBufWithCmac(common::CFG_CALIBRATION_PATHNAME, &cfgCalData, sizeof(cfgCalData));
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
-    common::SdMountManager::Unmount();
+    result = common::SdMountManager::Unmount();
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
+
+    return nn::ResultSuccess();
 }
 
 nn::Result ImportCalData(common::CfgCalData *data)
@@ -1664,8 +1668,7 @@ nn::Result ImportCalData(common::CfgCalData *data)
             // SDから読み出し成功
             std::memcpy(data, buf, readSize);
         }
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
-        NN_UTIL_RETURN_IF_FAILED(result);
     }
     else
     {
@@ -1863,18 +1866,20 @@ nn::Result ImportData()
 
         // インポート前にACを止める
         result = nn::ndm::SuspendScheduler();
-        NN_UTIL_RETURN_IF_FAILED(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
         // NANDのごみを削除する
-        Cleanup();
+        result = Cleanup();
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
         // NORデータを書き込む
         result = ImportNorData();
-        NN_UTIL_RETURN_IF_FAILED(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
         // 固体固有calLデータをSDカードに出力する
         // 本体初期化後はcal値が設定されている
-        ExportCalData();
+        result = ExportCalData();
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
         // SDカードのセーブデータをNANDに書き込む
         ImportSaveData();

trunk/ConsoleDataMigration/sources/ConsoleRestore/Importer.h

@@ -81,7 +81,7 @@ void CreateTransferAccountFinishedFile();
 u32 GetImportProgress();
 
 // NANDのごみを削除する
-void Cleanup();
+nn::Result Cleanup();
 
 
 // ファイルが存在するかどうか確認するためのテーブル

trunk/ConsoleDataMigration/sources/common/FileTransfer.cpp

@@ -83,12 +83,12 @@ nn::Result CalculateFileNum(std::wstring currentDirectory, u32& fileNum, s64& fi
             {
                 if (entryIndex->attributes.isDirectory)
                 {
-                    CalculateFileNum(currentDirectory + std::wstring(entryIndex->entryName) + std::wstring(L"/"),
+                    result = CalculateFileNum(currentDirectory + std::wstring(entryIndex->entryName) + std::wstring(L"/"),
                             fileNum, fileSize);
                 }
             }
 
-            return nn::ResultSuccess();
+            return result;
         }
 
         entryList.push_back(entry);
@@ -531,11 +531,7 @@ bool CopyDirectory(ImportDataList* fileList, const wchar_t * from_path, const wc
                         }
                     }
 
-                    if (result.IsFailure())
+                    COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
-                    {
-                        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-                        return false;
-                    }
 
                 }
             }
@@ -592,20 +588,10 @@ bool VerifyMac(nn::fs::FileInputStream* sdFile, nn::fs::FileStream* nandFile, s6
     // ハッシュを取得する
     nn::crypto::Initialize();
     result = sdFile->TrySetPosition(sdFileSize - nn::crypto::AES_CMAC_MAC_SIZE);
-    if (result.IsSuccess())
+    COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
-    {
+
     result = sdFile->TryRead(&readSize, sdCmac, sizeof(sdCmac));
-        if(result.IsFailure())
+    COMMON_LOGGER_RETURN_FALSE_IF_FAILED(result);
-        {
-            COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-            return false;
-        }
-    }
-    else
-    {
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-        return false;
-    }
 
     sdFile->Finalize();
 

trunk/ConsoleDataMigration/sources/common/SdReaderWriter.cpp

@@ -66,7 +66,7 @@ nn::Result SdReaderWriter::WriteBufCore(const wchar_t* path, void* buf, size_t s
     NN_ASSERT(size > 0);
 
     nn::Result result = Initialize();
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     result = file.TryInitialize(path, nn::fs::OPEN_MODE_WRITE | nn::fs::OPEN_MODE_CREATE);
 
@@ -81,13 +81,13 @@ nn::Result SdReaderWriter::WriteBufCore(const wchar_t* path, void* buf, size_t s
         else
         {
             NN_LOG("SD TryWrite failed\n");
-            COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+            COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
         }
     }
     else
     {
         NN_LOG("SD TryInitialize failed\n");
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+        COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
     }
 
     return result;
@@ -101,11 +101,11 @@ nn::Result SdReaderWriter::WriteBuf(const wchar_t* path, void* buf, size_t size)
     NN_UTIL_RETURN_IF_FAILED(result);
 
     result = file.TryFlush();
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
     file.Finalize();
 
     result = Finalize();
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     return result;
 }
@@ -154,26 +154,14 @@ nn::Result SdReaderWriter::ReadBufCore(const wchar_t* path, void* buf, size_t si
     }
 
     result = file.TryInitialize(path, nn::fs::OPEN_MODE_READ);
-    if (result.IsSuccess())
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
-    {
+
     s32 readSize;
     result = file.TryRead(&readSize, buf, size);
-        if (result.IsSuccess())
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
-        {
+
     // TODO バッファを超えるサイズのファイル読み込み
     *totalSize = readSize;
-        }
-        else
-        {
-            NN_LOG("SD TryRead failed\n");
-            COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-        }
-    }
-    else
-    {
-        NN_LOG("SD TryInitialize failed\n");
-        COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
-    }
 
     return result;
 }
@@ -213,7 +201,7 @@ nn::Result SdReaderWriter::ReadBufWithCmac(const wchar_t* path, void* buf, size_
 
     bit8 cmac[nn::crypto::AES_CMAC_MAC_SIZE];
     result = nn::crypto::CalculateAesCmacSw(cmac, sha256Hash, nn::crypto::Sha256Context::HASH_SIZE, common::cmacKey);
-    COMMON_LOGGER_RESULT_IF_FAILED_WITH_LINE(result);
+    COMMON_LOGGER_RETURN_RESULT_IF_FAILED(result);
 
     if(std::memcmp(reinterpret_cast<bit8*>(buf) + *totalSize, cmac, sizeof(cmac)) != 0)
     {