renderer_opengl: Use LOG_DEBUG for GL_DEBUG_SEVERITY_NOTIFICATION and GL_DEBUG_SEVERITY_LOW logs

LOG_TRACE is only enabled on debug builds which can be quite slow when
trying to debug graphics issues. Instead we can log the messages to the
debug log, which is available on both release and debug builds.

appveyor.yml

@@ -53,7 +53,7 @@ build_script:
           # https://www.appveyor.com/docs/build-phase
           msbuild msvc_build/yuzu.sln /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
         } else {
-          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -j4 -C mingw_build/ 2>&1'
+          C:\msys64\usr\bin\bash.exe -lc 'mingw32-make -C mingw_build/ 2>&1'
         }
 
 after_build:

src/common/telemetry.cpp

@@ -3,8 +3,15 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <cstring>
+#include "common/assert.h"
+#include "common/scm_rev.h"
 #include "common/telemetry.h"
 
+#ifdef ARCHITECTURE_x86_64
+#include "common/x64/cpu_detect.h"
+#endif
+
 namespace Telemetry {
 
 void FieldCollection::Accept(VisitorInterface& visitor) const {
@@ -37,4 +44,62 @@ template class Field<std::string>;
 template class Field<const char*>;
 template class Field<std::chrono::microseconds>;
 
+#ifdef ARCHITECTURE_x86_64
+static const char* CpuVendorToStr(Common::CPUVendor vendor) {
+    switch (vendor) {
+    case Common::CPUVendor::INTEL:
+        return "Intel";
+    case Common::CPUVendor::AMD:
+        return "Amd";
+    case Common::CPUVendor::OTHER:
+        return "Other";
+    }
+    UNREACHABLE();
+}
+#endif
+
+void AppendBuildInfo(FieldCollection& fc) {
+    const bool is_git_dirty{std::strstr(Common::g_scm_desc, "dirty") != nullptr};
+    fc.AddField(FieldType::App, "Git_IsDirty", is_git_dirty);
+    fc.AddField(FieldType::App, "Git_Branch", Common::g_scm_branch);
+    fc.AddField(FieldType::App, "Git_Revision", Common::g_scm_rev);
+    fc.AddField(FieldType::App, "BuildDate", Common::g_build_date);
+    fc.AddField(FieldType::App, "BuildName", Common::g_build_name);
+}
+
+void AppendCPUInfo(FieldCollection& fc) {
+#ifdef ARCHITECTURE_x86_64
+    fc.AddField(FieldType::UserSystem, "CPU_Model", Common::GetCPUCaps().cpu_string);
+    fc.AddField(FieldType::UserSystem, "CPU_BrandString", Common::GetCPUCaps().brand_string);
+    fc.AddField(FieldType::UserSystem, "CPU_Vendor", CpuVendorToStr(Common::GetCPUCaps().vendor));
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_FMA4", Common::GetCPUCaps().fma4);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE", Common::GetCPUCaps().sse);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE2", Common::GetCPUCaps().sse2);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE3", Common::GetCPUCaps().sse3);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSSE3", Common::GetCPUCaps().ssse3);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE41", Common::GetCPUCaps().sse4_1);
+    fc.AddField(FieldType::UserSystem, "CPU_Extension_x64_SSE42", Common::GetCPUCaps().sse4_2);
+#else
+    fc.AddField(FieldType::UserSystem, "CPU_Model", "Other");
+#endif
+}
+
+void AppendOSInfo(FieldCollection& fc) {
+#ifdef __APPLE__
+    fc.AddField(FieldType::UserSystem, "OsPlatform", "Apple");
+#elif defined(_WIN32)
+    fc.AddField(FieldType::UserSystem, "OsPlatform", "Windows");
+#elif defined(__linux__) || defined(linux) || defined(__linux)
+    fc.AddField(FieldType::UserSystem, "OsPlatform", "Linux");
+#else
+    fc.AddField(FieldType::UserSystem, "OsPlatform", "Unknown");
+#endif
+}
+
 } // namespace Telemetry

src/common/telemetry.h

@@ -180,4 +180,16 @@ struct NullVisitor : public VisitorInterface {
     void Complete() override {}
 };
 
+/// Appends build-specific information to the given FieldCollection,
+/// such as branch name, revision hash, etc.
+void AppendBuildInfo(FieldCollection& fc);
+
+/// Appends CPU-specific information to the given FieldCollection,
+/// such as instruction set extensions, etc.
+void AppendCPUInfo(FieldCollection& fc);
+
+/// Appends OS-specific information to the given FieldCollection,
+/// such as platform name, etc.
+void AppendOSInfo(FieldCollection& fc);
+
 } // namespace Telemetry

src/core/file_sys/content_archive.h

@@ -27,6 +27,7 @@ enum class NCAContentType : u8 {
     Control = 2,
     Manual = 3,
     Data = 4,
+    Data_Unknown5 = 5, ///< Seems to be used on some system archives
 };
 
 enum class NCASectionCryptoType : u8 {

src/core/file_sys/registered_cache.cpp

@@ -77,12 +77,13 @@ static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     case NCAContentType::Control:
         return ContentRecordType::Control;
     case NCAContentType::Data:
+    case NCAContentType::Data_Unknown5:
         return ContentRecordType::Data;
     case NCAContentType::Manual:
         // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
         return ContentRecordType::Manual;
     default:
-        UNREACHABLE();
+        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
     }
 }
 

src/core/file_sys/romfs_factory.cpp

@@ -6,7 +6,9 @@
 #include <memory>
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/file_sys/romfs_factory.h"
+#include "core/hle/kernel/process.h"
 
 namespace FileSys {
 
@@ -17,9 +19,41 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     }
 }
 
-ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id) {
-    // TODO(DarkLordZach): Use title id.
+ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
     return MakeResult<VirtualFile>(file);
 }
 
+ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
+    switch (storage) {
+    case StorageId::NandSystem: {
+        const auto res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);
+        if (res == nullptr) {
+            // TODO(DarkLordZach): Find the right error code to use here
+            return ResultCode(-1);
+        }
+        const auto romfs = res->GetRomFS();
+        if (romfs == nullptr) {
+            // TODO(DarkLordZach): Find the right error code to use here
+            return ResultCode(-1);
+        }
+        return MakeResult<VirtualFile>(romfs);
+    }
+    case StorageId::NandUser: {
+        const auto res = Service::FileSystem::GetUserNANDContents()->GetEntry(title_id, type);
+        if (res == nullptr) {
+            // TODO(DarkLordZach): Find the right error code to use here
+            return ResultCode(-1);
+        }
+        const auto romfs = res->GetRomFS();
+        if (romfs == nullptr) {
+            // TODO(DarkLordZach): Find the right error code to use here
+            return ResultCode(-1);
+        }
+        return MakeResult<VirtualFile>(romfs);
+    }
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
+    }
+}
+
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -11,12 +11,22 @@
 
 namespace FileSys {
 
+enum class StorageId : u8 {
+    None = 0,
+    Host = 1,
+    GameCard = 2,
+    NandSystem = 3,
+    NandUser = 4,
+    SdCard = 5,
+};
+
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
 
-    ResultVal<VirtualFile> Open(u64 title_id);
+    ResultVal<VirtualFile> OpenCurrentProcess();
+    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
 
 private:
     VirtualFile file;

src/core/hle/service/acc/acc.cpp

@@ -13,7 +13,7 @@
 #include "core/hle/service/acc/acc_su.h"
 #include "core/hle/service/acc/acc_u0.h"
 #include "core/hle/service/acc/acc_u1.h"
-#include "core/settings.h"
+#include "core/hle/service/acc/profile_manager.h"
 
 namespace Service::Account {
 // TODO: RE this structure
@@ -27,13 +27,10 @@ struct UserData {
 };
 static_assert(sizeof(UserData) == 0x80, "UserData structure has incorrect size");
 
-// TODO(ogniK): Generate a real user id based on username, md5(username) maybe?
-static UUID DEFAULT_USER_ID{1ull, 0ull};
-
 class IProfile final : public ServiceFramework<IProfile> {
 public:
     explicit IProfile(UUID user_id, ProfileManager& profile_manager)
-        : ServiceFramework("IProfile"), user_id(user_id), profile_manager(profile_manager) {
+        : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, &IProfile::Get, "Get"},
             {1, &IProfile::GetBase, "GetBase"},
@@ -79,8 +76,8 @@ private:
         LOG_WARNING(Service_ACC, "(STUBBED) called");
         // smallest jpeg https://github.com/mathiasbynens/small/blob/master/jpeg.jpg
         // TODO(mailwl): load actual profile image from disk, width 256px, max size 0x20000
-        const u32 jpeg_size = 107;
-        static const std::array<u8, jpeg_size> jpeg{
+        constexpr u32 jpeg_size = 107;
+        static constexpr std::array<u8, jpeg_size> jpeg{
             0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43, 0x00, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
             0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04,
             0x08, 0x06, 0x06, 0x05, 0x06, 0x09, 0x08, 0x0a, 0x0a, 0x09, 0x08, 0x09, 0x09, 0x0a,
@@ -90,7 +87,7 @@ private:
             0xff, 0xcc, 0x00, 0x06, 0x00, 0x10, 0x10, 0x05, 0xff, 0xda, 0x00, 0x08, 0x01, 0x01,
             0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
         };
-        ctx.WriteBuffer(jpeg.data(), jpeg_size);
+        ctx.WriteBuffer(jpeg);
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
         rb.Push<u32>(jpeg_size);
@@ -205,6 +202,8 @@ Module::Interface::Interface(std::shared_ptr<Module> module,
     : ServiceFramework(name), module(std::move(module)),
       profile_manager(std::move(profile_manager)) {}
 
+Module::Interface::~Interface() = default;
+
 void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module = std::make_shared<Module>();
     auto profile_manager = std::make_shared<ProfileManager>();

src/core/hle/service/acc/acc.h

@@ -4,17 +4,19 @@
 
 #pragma once
 
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Account {
 
+class ProfileManager;
+
 class Module final {
 public:
     class Interface : public ServiceFramework<Interface> {
     public:
         explicit Interface(std::shared_ptr<Module> module,
                            std::shared_ptr<ProfileManager> profile_manager, const char* name);
+        ~Interface() override;
 
         void GetUserCount(Kernel::HLERequestContext& ctx);
         void GetUserExistence(Kernel::HLERequestContext& ctx);

src/core/hle/service/acc/profile_manager.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <random>
 #include <boost/optional.hpp>
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/settings.h"
@@ -12,6 +13,15 @@ constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, -1);
 constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, -2);
 constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
+const UUID& UUID::Generate() {
+    std::random_device device;
+    std::mt19937 gen(device());
+    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
+    uuid[0] = distribution(gen);
+    uuid[1] = distribution(gen);
+    return *this;
+}
+
 ProfileManager::ProfileManager() {
     // TODO(ogniK): Create the default user we have for now until loading/saving users is added
     auto user_uuid = UUID{1, 0};
@@ -25,7 +35,7 @@ boost::optional<size_t> ProfileManager::AddToProfiles(const ProfileInfo& user) {
     if (user_count >= MAX_USERS) {
         return boost::none;
     }
-    profiles[user_count] = std::move(user);
+    profiles[user_count] = user;
     return user_count++;
 }
 
@@ -43,7 +53,7 @@ bool ProfileManager::RemoveProfileAtIndex(size_t index) {
 }
 
 /// Helper function to register a user to the system
-ResultCode ProfileManager::AddUser(ProfileInfo user) {
+ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
     if (AddToProfiles(user) == boost::none) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -52,7 +62,7 @@ ResultCode ProfileManager::AddUser(ProfileInfo user) {
 
 /// Create a new user on the system. If the uuid of the user already exists, the user is not
 /// created.
-ResultCode ProfileManager::CreateNewUser(UUID uuid, std::array<u8, 0x20>& username) {
+ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
     if (user_count == MAX_USERS) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -67,7 +77,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, std::array<u8, 0x20>& userna
         return ERROR_USER_ALREADY_EXISTS;
     }
     ProfileInfo profile;
-    profile.user_uuid = std::move(uuid);
+    profile.user_uuid = uuid;
     profile.username = username;
     profile.data = {};
     profile.creation_time = 0x0;
@@ -79,7 +89,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, std::array<u8, 0x20>& userna
 /// specifically by allowing an std::string for the username. This is required specifically since
 /// we're loading a string straight from the config
 ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
-    std::array<u8, 0x20> username_output;
+    ProfileUsername username_output;
     if (username.size() > username_output.size()) {
         std::copy_n(username.begin(), username_output.size(), username_output.begin());
     } else {
@@ -102,7 +112,7 @@ boost::optional<size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
 }
 
 /// Returns a users profile index based on their profile
-boost::optional<size_t> ProfileManager::GetUserIndex(ProfileInfo user) const {
+boost::optional<size_t> ProfileManager::GetUserIndex(const ProfileInfo& user) const {
     return GetUserIndex(user.user_uuid);
 }
 
@@ -125,7 +135,7 @@ bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
 }
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(ProfileInfo user, ProfileBase& profile) const {
+bool ProfileManager::GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const {
     return GetProfileBase(user.user_uuid, profile);
 }
 
@@ -168,8 +178,8 @@ void ProfileManager::CloseUser(UUID uuid) {
 }
 
 /// Gets all valid user ids on the system
-std::array<UUID, MAX_USERS> ProfileManager::GetAllUsers() const {
-    std::array<UUID, MAX_USERS> output;
+UserIDArray ProfileManager::GetAllUsers() const {
+    UserIDArray output;
     std::transform(profiles.begin(), profiles.end(), output.begin(),
                    [](const ProfileInfo& p) { return p.user_uuid; });
     return output;
@@ -177,8 +187,8 @@ std::array<UUID, MAX_USERS> ProfileManager::GetAllUsers() const {
 
 /// Get all the open users on the system and zero out the rest of the data. This is specifically
 /// needed for GetOpenUsers and we need to ensure the rest of the output buffer is zero'd out
-std::array<UUID, MAX_USERS> ProfileManager::GetOpenUsers() const {
-    std::array<UUID, MAX_USERS> output;
+UserIDArray ProfileManager::GetOpenUsers() const {
+    UserIDArray output;
     std::transform(profiles.begin(), profiles.end(), output.begin(), [](const ProfileInfo& p) {
         if (p.is_open)
             return p.user_uuid;
@@ -195,9 +205,9 @@ UUID ProfileManager::GetLastOpenedUser() const {
 
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
-                                           std::array<u8, MAX_DATA>& data) const {
+                                           ProfileData& data) const {
     if (GetProfileBase(index, profile)) {
-        std::memcpy(data.data(), profiles[index.get()].data.data(), MAX_DATA);
+        data = profiles[index.get()].data;
         return true;
     }
     return false;
@@ -205,14 +215,14 @@ bool ProfileManager::GetProfileBaseAndData(boost::optional<size_t> index, Profil
 
 /// Return the users profile base and the unknown arbitary data.
 bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
-                                           std::array<u8, MAX_DATA>& data) const {
+                                           ProfileData& data) const {
     auto idx = GetUserIndex(uuid);
     return GetProfileBaseAndData(idx, profile, data);
 }
 
 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
-                                           std::array<u8, MAX_DATA>& data) const {
+bool ProfileManager::GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
+                                           ProfileData& data) const {
     return GetProfileBaseAndData(user.user_uuid, profile, data);
 }
 

src/core/hle/service/acc/profile_manager.h

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <array>
-#include <random>
+
 #include "boost/optional.hpp"
 #include "common/common_types.h"
 #include "common/swap.h"
@@ -14,23 +14,21 @@
 namespace Service::Account {
 constexpr size_t MAX_USERS = 8;
 constexpr size_t MAX_DATA = 128;
-static const u128 INVALID_UUID = {0, 0};
+constexpr u128 INVALID_UUID{{0, 0}};
 
 struct UUID {
     // UUIDs which are 0 are considered invalid!
     u128 uuid = INVALID_UUID;
     UUID() = default;
     explicit UUID(const u128& id) : uuid{id} {}
-    explicit UUID(const u64 lo, const u64 hi) {
-        uuid[0] = lo;
-        uuid[1] = hi;
-    };
+    explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
+
     explicit operator bool() const {
-        return uuid[0] != INVALID_UUID[0] || uuid[1] != INVALID_UUID[1];
+        return uuid != INVALID_UUID;
     }
 
     bool operator==(const UUID& rhs) const {
-        return std::tie(uuid[0], uuid[1]) == std::tie(rhs.uuid[0], rhs.uuid[1]);
+        return uuid == rhs.uuid;
     }
 
     bool operator!=(const UUID& rhs) const {
@@ -38,15 +36,7 @@ struct UUID {
     }
 
     // TODO(ogniK): Properly generate uuids based on RFC-4122
-    const UUID& Generate() {
-        std::random_device device;
-        std::mt19937 gen(device());
-        std::uniform_int_distribution<uint64_t> distribution(1,
-                                                             std::numeric_limits<uint64_t>::max());
-        uuid[0] = distribution(gen);
-        uuid[1] = distribution(gen);
-        return *this;
-    }
+    const UUID& Generate();
 
     // Set the UUID to {0,0} to be considered an invalid user
     void Invalidate() {
@@ -58,20 +48,24 @@ struct UUID {
 };
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
+using ProfileUsername = std::array<u8, 0x20>;
+using ProfileData = std::array<u8, MAX_DATA>;
+using UserIDArray = std::array<UUID, MAX_USERS>;
+
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
     UUID user_uuid;
-    std::array<u8, 0x20> username;
+    ProfileUsername username;
     u64 creation_time;
-    std::array<u8, MAX_DATA> data; // TODO(ognik): Work out what this is
+    ProfileData data; // TODO(ognik): Work out what this is
     bool is_open;
 };
 
 struct ProfileBase {
     UUID user_uuid;
     u64_le timestamp;
-    std::array<u8, 0x20> username;
+    ProfileUsername username;
 
     // Zero out all the fields to make the profile slot considered "Empty"
     void Invalidate() {
@@ -88,27 +82,26 @@ static_assert(sizeof(ProfileBase) == 0x38, "ProfileBase is an invalid size");
 class ProfileManager {
 public:
     ProfileManager(); // TODO(ogniK): Load from system save
-    ResultCode AddUser(ProfileInfo user);
-    ResultCode CreateNewUser(UUID uuid, std::array<u8, 0x20>& username);
+    ResultCode AddUser(const ProfileInfo& user);
+    ResultCode CreateNewUser(UUID uuid, const ProfileUsername& username);
     ResultCode CreateNewUser(UUID uuid, const std::string& username);
     boost::optional<size_t> GetUserIndex(const UUID& uuid) const;
-    boost::optional<size_t> GetUserIndex(ProfileInfo user) const;
+    boost::optional<size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(boost::optional<size_t> index, ProfileBase& profile) const;
     bool GetProfileBase(UUID uuid, ProfileBase& profile) const;
-    bool GetProfileBase(ProfileInfo user, ProfileBase& profile) const;
+    bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(boost::optional<size_t> index, ProfileBase& profile,
-                               std::array<u8, MAX_DATA>& data) const;
-    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
-                               std::array<u8, MAX_DATA>& data) const;
-    bool GetProfileBaseAndData(ProfileInfo user, ProfileBase& profile,
-                               std::array<u8, MAX_DATA>& data) const;
+                               ProfileData& data) const;
+    bool GetProfileBaseAndData(UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
+                               ProfileData& data) const;
     size_t GetUserCount() const;
     size_t GetOpenUserCount() const;
     bool UserExists(UUID uuid) const;
     void OpenUser(UUID uuid);
     void CloseUser(UUID uuid);
-    std::array<UUID, MAX_USERS> GetOpenUsers() const;
-    std::array<UUID, MAX_USERS> GetAllUsers() const;
+    UserIDArray GetOpenUsers() const;
+    UserIDArray GetAllUsers() const;
     UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
@@ -118,7 +111,7 @@ private:
     size_t user_count = 0;
     boost::optional<size_t> AddToProfiles(const ProfileInfo& profile);
     bool RemoveProfileAtIndex(size_t index);
-    UUID last_opened_user{0, 0};
+    UUID last_opened_user{INVALID_UUID};
 };
 
 }; // namespace Service::Account

src/core/hle/service/filesystem/filesystem.cpp

@@ -256,15 +256,28 @@ ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
     return RESULT_SUCCESS;
 }
 
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id) {
-    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}", title_id);
+ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
+    LOG_TRACE(Service_FS, "Opening RomFS for current process");
 
     if (romfs_factory == nullptr) {
         // TODO(bunnei): Find a better error code for this
         return ResultCode(-1);
     }
 
-    return romfs_factory->Open(title_id);
+    return romfs_factory->OpenCurrentProcess();
+}
+
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
+                                          FileSys::ContentRecordType type) {
+    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
+              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));
+
+    if (romfs_factory == nullptr) {
+        // TODO(bunnei): Find a better error code for this
+        return ResultCode(-1);
+    }
+
+    return romfs_factory->Open(title_id, storage_id, type);
 }
 
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,

src/core/hle/service/filesystem/filesystem.h

@@ -27,7 +27,9 @@ ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory)
 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
 ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
-ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id);
+ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess();
+ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
+                                          FileSys::ContentRecordType type);
 ResultVal<FileSys::VirtualDir> OpenSaveData(FileSys::SaveDataSpaceId space,
                                             FileSys::SaveDataDescriptor save_struct);
 ResultVal<FileSys::VirtualDir> OpenSDMC();

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -23,15 +23,6 @@
 
 namespace Service::FileSystem {
 
-enum class StorageId : u8 {
-    None = 0,
-    Host = 1,
-    GameCard = 2,
-    NandSystem = 3,
-    NandUser = 4,
-    SdCard = 5,
-};
-
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(FileSys::VirtualFile backend_)
@@ -467,7 +458,7 @@ FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
         {110, nullptr, "OpenContentStorageFileSystem"},
         {200, &FSP_SRV::OpenDataStorageByCurrentProcess, "OpenDataStorageByCurrentProcess"},
         {201, nullptr, "OpenDataStorageByProgramId"},
-        {202, nullptr, "OpenDataStorageByDataId"},
+        {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
         {203, &FSP_SRV::OpenRomStorage, "OpenRomStorage"},
         {400, nullptr, "OpenDeviceOperator"},
         {500, nullptr, "OpenSdCardDetectionEventNotifier"},
@@ -580,7 +571,7 @@ void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_FS, "called");
 
-    auto romfs = OpenRomFS(Core::System::GetInstance().CurrentProcess()->program_id);
+    auto romfs = OpenRomFSCurrentProcess();
     if (romfs.Failed()) {
         // TODO (bunnei): Find the right error code to use here
         LOG_CRITICAL(Service_FS, "no file system interface available!");
@@ -596,10 +587,37 @@ void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IStorage>(std::move(storage));
 }
 
+void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
+    const auto unknown = rp.PopRaw<u32>();
+    const auto title_id = rp.PopRaw<u64>();
+
+    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
+              static_cast<u8>(storage_id), unknown, title_id);
+
+    auto data = OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);
+    if (data.Failed()) {
+        // TODO(DarkLordZach): Find the right error code to use here
+        LOG_ERROR(Service_FS,
+                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
+                  static_cast<u8>(storage_id));
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultCode(-1));
+        return;
+    }
+
+    IStorage storage(std::move(data.Unwrap()));
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IStorage>(std::move(storage));
+}
+
 void FSP_SRV::OpenRomStorage(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
-    auto storage_id = rp.PopRaw<StorageId>();
+    auto storage_id = rp.PopRaw<FileSys::StorageId>();
     auto title_id = rp.PopRaw<u64>();
 
     LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",

src/core/hle/service/filesystem/fsp_srv.h

@@ -25,6 +25,7 @@ private:
     void MountSaveData(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
+    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
     void OpenRomStorage(Kernel::HLERequestContext& ctx);
 
     FileSys::VirtualFile romfs;

src/core/telemetry_session.cpp

@@ -2,34 +2,16 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <cstring>
-
 #include "common/assert.h"
+#include "common/common_types.h"
 #include "common/file_util.h"
-#include "common/scm_rev.h"
-#ifdef ARCHITECTURE_x86_64
-#include "common/x64/cpu_detect.h"
-#endif
+
 #include "core/core.h"
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 
 namespace Core {
 
-#ifdef ARCHITECTURE_x86_64
-static const char* CpuVendorToStr(Common::CPUVendor vendor) {
-    switch (vendor) {
-    case Common::CPUVendor::INTEL:
-        return "Intel";
-    case Common::CPUVendor::AMD:
-        return "Amd";
-    case Common::CPUVendor::OTHER:
-        return "Other";
-    }
-    UNREACHABLE();
-}
-#endif
-
 static u64 GenerateTelemetryId() {
     u64 telemetry_id{};
     return telemetry_id;
@@ -37,8 +19,8 @@ static u64 GenerateTelemetryId() {
 
 u64 GetTelemetryId() {
     u64 telemetry_id{};
-    static const std::string& filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
-                                       "telemetry_id"};
+    const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
+                               "telemetry_id"};
 
     if (FileUtil::Exists(filename)) {
         FileUtil::IOFile file(filename, "rb");
@@ -62,8 +44,8 @@ u64 GetTelemetryId() {
 
 u64 RegenerateTelemetryId() {
     const u64 new_telemetry_id{GenerateTelemetryId()};
-    static const std::string& filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
-                                       "telemetry_id"};
+    const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
+                               "telemetry_id"};
 
     FileUtil::IOFile file(filename, "wb");
     if (!file.IsOpen()) {
@@ -112,48 +94,11 @@ TelemetrySession::TelemetrySession() {
     }
 
     // Log application information
-    const bool is_git_dirty{std::strstr(Common::g_scm_desc, "dirty") != nullptr};
-    AddField(Telemetry::FieldType::App, "Git_IsDirty", is_git_dirty);
-    AddField(Telemetry::FieldType::App, "Git_Branch", Common::g_scm_branch);
-    AddField(Telemetry::FieldType::App, "Git_Revision", Common::g_scm_rev);
-    AddField(Telemetry::FieldType::App, "BuildDate", Common::g_build_date);
-    AddField(Telemetry::FieldType::App, "BuildName", Common::g_build_name);
+    Telemetry::AppendBuildInfo(field_collection);
 
-// Log user system information
-#ifdef ARCHITECTURE_x86_64
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Model", Common::GetCPUCaps().cpu_string);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_BrandString",
-             Common::GetCPUCaps().brand_string);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Vendor",
-             CpuVendorToStr(Common::GetCPUCaps().vendor));
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AES", Common::GetCPUCaps().aes);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AVX", Common::GetCPUCaps().avx);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_AVX2", Common::GetCPUCaps().avx2);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_BMI1", Common::GetCPUCaps().bmi1);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_BMI2", Common::GetCPUCaps().bmi2);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_FMA", Common::GetCPUCaps().fma);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_FMA4", Common::GetCPUCaps().fma4);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE", Common::GetCPUCaps().sse);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE2", Common::GetCPUCaps().sse2);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE3", Common::GetCPUCaps().sse3);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSSE3",
-             Common::GetCPUCaps().ssse3);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE41",
-             Common::GetCPUCaps().sse4_1);
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Extension_x64_SSE42",
-             Common::GetCPUCaps().sse4_2);
-#else
-    AddField(Telemetry::FieldType::UserSystem, "CPU_Model", "Other");
-#endif
-#ifdef __APPLE__
-    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Apple");
-#elif defined(_WIN32)
-    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Windows");
-#elif defined(__linux__) || defined(linux) || defined(__linux)
-    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Linux");
-#else
-    AddField(Telemetry::FieldType::UserSystem, "OsPlatform", "Unknown");
-#endif
+    // Log user system information
+    Telemetry::AppendCPUInfo(field_collection);
+    Telemetry::AppendOSInfo(field_collection);
 
     // Log user configuration information
     AddField(Telemetry::FieldType::UserConfig, "Core_UseCpuJit", Settings::values.use_cpu_jit);

src/video_core/engines/shader_bytecode.h

@@ -477,7 +477,9 @@ union Instruction {
             if (texture_info >= 12 && texture_info <= 13)
                 return TextureType::TextureCube;
 
-            UNIMPLEMENTED();
+            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
+                         static_cast<u32>(texture_info.Value()));
+            UNREACHABLE();
         }
 
         bool IsArrayTexture() const {
@@ -523,7 +525,9 @@ union Instruction {
                 return TextureType::Texture3D;
             }
 
-            UNIMPLEMENTED();
+            LOG_CRITICAL(HW_GPU, "Unhandled texture_info: {}",
+                         static_cast<u32>(texture_info.Value()));
+            UNREACHABLE();
         }
 
         bool IsArrayTexture() const {

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -26,6 +26,7 @@ using Tegra::Shader::Sampler;
 using Tegra::Shader::SubOp;
 
 constexpr u32 PROGRAM_END = MAX_PROGRAM_CODE_LENGTH;
+constexpr u32 PROGRAM_HEADER_SIZE = 0x50;
 
 class DecompileFail : public std::runtime_error {
 public:
@@ -621,6 +622,23 @@ public:
     }
 
 private:
+    // Shader program header for a Fragment Shader.
+    struct FragmentHeader {
+        INSERT_PADDING_WORDS(5);
+        INSERT_PADDING_WORDS(13);
+        u32 enabled_color_outputs;
+        union {
+            BitField<0, 1, u32> writes_samplemask;
+            BitField<1, 1, u32> writes_depth;
+        };
+
+        bool IsColorComponentOutputEnabled(u32 render_target, u32 component) const {
+            u32 bit = render_target * 4 + component;
+            return enabled_color_outputs & (1 << bit);
+        }
+    };
+    static_assert(sizeof(FragmentHeader) == PROGRAM_HEADER_SIZE, "FragmentHeader size is wrong");
+
     /// Gets the Subroutine object corresponding to the specified address.
     const Subroutine& GetSubroutine(u32 begin, u32 end) const {
         auto iter = subroutines.find(Subroutine{begin, end, suffix});
@@ -894,6 +912,31 @@ private:
         shader.AddLine('}');
     }
 
+    /// Writes the output values from a fragment shader to the corresponding GLSL output variables.
+    void EmitFragmentOutputsWrite() {
+        ASSERT(stage == Maxwell3D::Regs::ShaderStage::Fragment);
+        FragmentHeader header;
+        std::memcpy(&header, program_code.data(), PROGRAM_HEADER_SIZE);
+
+        ASSERT_MSG(header.writes_depth == 0, "Depth write is unimplemented");
+        ASSERT_MSG(header.writes_samplemask == 0, "Samplemask write is unimplemented");
+
+        // Write the color outputs using the data in the shader registers, disabled
+        // rendertargets/components are skipped in the register assignment.
+        u32 current_reg = 0;
+        for (u32 render_target = 0; render_target < Maxwell3D::Regs::NumRenderTargets;
+             ++render_target) {
+            // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
+            for (u32 component = 0; component < 4; ++component) {
+                if (header.IsColorComponentOutputEnabled(render_target, component)) {
+                    shader.AddLine(fmt::format("color[{}][{}] = {};", render_target, component,
+                                               regs.GetRegisterAsFloat(current_reg)));
+                    ++current_reg;
+                }
+            }
+        }
+    }
+
     /**
      * Compiles a single instruction from Tegra to GLSL.
      * @param offset the offset of the Tegra shader instruction.
@@ -1514,7 +1557,7 @@ private:
                 switch (instr.tex.texture_type) {
                 case Tegra::Shader::TextureType::Texture2D: {
                     std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                     coord = "vec2 coords = vec2(" + x + ", " + y + ");";
                     break;
                 }
@@ -1525,8 +1568,18 @@ private:
                     coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
                     break;
                 }
+                case Tegra::Shader::TextureType::TextureCube: {
+                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
+                    ASSERT(instr.gpr20.Value() == Register::ZeroIndex);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    break;
+                }
                 default:
-                    UNIMPLEMENTED();
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                                 static_cast<u32>(instr.tex.texture_type.Value()));
+                    UNREACHABLE();
                 }
 
                 const std::string sampler =
@@ -1568,6 +1621,13 @@ private:
                     }
                     break;
                 }
+                case Tegra::Shader::TextureType::Texture3D: {
+                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                    std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                    std::string z = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    break;
+                }
                 case Tegra::Shader::TextureType::TextureCube: {
                     std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                     std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
@@ -1576,7 +1636,9 @@ private:
                     break;
                 }
                 default:
-                    UNIMPLEMENTED();
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                                 static_cast<u32>(instr.texs.GetTextureType()));
+                    UNREACHABLE();
                 }
                 const std::string sampler = GetSampler(instr.sampler, instr.texs.GetTextureType(),
                                                        instr.texs.IsArrayTexture());
@@ -1593,7 +1655,8 @@ private:
                 switch (instr.tlds.GetTextureType()) {
                 case Tegra::Shader::TextureType::Texture2D: {
                     if (instr.tlds.IsArrayTexture()) {
-                        UNIMPLEMENTED();
+                        LOG_CRITICAL(HW_GPU, "Unhandled 2d array texture");
+                        UNREACHABLE();
                     } else {
                         std::string x = regs.GetRegisterAsInteger(instr.gpr8);
                         std::string y = regs.GetRegisterAsInteger(instr.gpr20);
@@ -1602,7 +1665,9 @@ private:
                     break;
                 }
                 default:
-                    UNIMPLEMENTED();
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                                 static_cast<u32>(instr.tlds.GetTextureType()));
+                    UNREACHABLE();
                 }
                 const std::string sampler = GetSampler(instr.sampler, instr.tlds.GetTextureType(),
                                                        instr.tlds.IsArrayTexture());
@@ -1623,7 +1688,9 @@ private:
                     break;
                 }
                 default:
-                    UNIMPLEMENTED();
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
+                                 static_cast<u32>(instr.tld4.texture_type.Value()));
+                    UNREACHABLE();
                 }
 
                 const std::string sampler =
@@ -1960,12 +2027,8 @@ private:
         default: {
             switch (opcode->GetId()) {
             case OpCode::Id::EXIT: {
-                // Final color output is currently hardcoded to GPR0-3 for fragment shaders
                 if (stage == Maxwell3D::Regs::ShaderStage::Fragment) {
-                    shader.AddLine("color.r = " + regs.GetRegisterAsFloat(0) + ';');
-                    shader.AddLine("color.g = " + regs.GetRegisterAsFloat(1) + ';');
-                    shader.AddLine("color.b = " + regs.GetRegisterAsFloat(2) + ';');
-                    shader.AddLine("color.a = " + regs.GetRegisterAsFloat(3) + ';');
+                    EmitFragmentOutputsWrite();
                 }
 
                 switch (instr.flow.cond) {

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -87,7 +87,7 @@ ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSCo
             .get_value_or({});
     out += R"(
 in vec4 position;
-out vec4 color;
+layout(location = 0) out vec4 color[8];
 
 layout (std140) uniform fs_config {
     vec4 viewport_flip;

src/video_core/renderer_opengl/gl_stream_buffer.h

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#pragma once
+
 #include <tuple>
 #include <glad/glad.h>
 #include "common/common_types.h"

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -432,7 +432,7 @@ static void APIENTRY DebugHandler(GLenum source, GLenum type, GLuint id, GLenum
         break;
     case GL_DEBUG_SEVERITY_NOTIFICATION:
     case GL_DEBUG_SEVERITY_LOW:
-        LOG_TRACE(Render_OpenGL, format, str_source, str_type, id, message);
+        LOG_DEBUG(Render_OpenGL, format, str_source, str_type, id, message);
         break;
     }
 }