7 files changed, 52 insertions, 32 deletions

diff --git a/src/core/hle/service/apt/apt.h b/src/core/hle/service/apt/apt.h
index 9bc6327ed..bcc437f93 100644
--- a/src/core/hle/service/apt/apt.h
+++ b/src/core/hle/service/apt/apt.h
@@ -14,7 +14,8 @@ class Interface;
 
 namespace APT {
 
-static const u32 MaxAPTSessions = 2; ///< Each APT service can only have up to 2 sessions connected at the same time.
+/// Each APT service can only have up to 2 sessions connected at the same time.
+static const u32 MaxAPTSessions = 2;
 
 /// Holds information about the parameters used in Send/Glance/ReceiveParameter
 struct MessageParameter {
diff --git a/src/core/hle/service/fs/archive.cpp b/src/core/hle/service/fs/archive.cpp
index bca57061e..6184e6f1b 100644
--- a/src/core/hle/service/fs/archive.cpp
+++ b/src/core/hle/service/fs/archive.cpp
@@ -175,7 +175,9 @@ void File::HandleSyncRequest(Kernel::SharedPtr<Kernel::ServerSession> server_ses
         LOG_WARNING(Service_FS, "(STUBBED) File command OpenLinkFile %s", GetName().c_str());
         auto sessions = Kernel::ServerSession::CreateSessionPair(GetName(), shared_from_this());
         ClientConnected(std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions));
-        cmd_buff[3] = Kernel::g_handle_table.Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions)).ValueOr(INVALID_HANDLE);
+        cmd_buff[3] = Kernel::g_handle_table
+                          .Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions))
+                          .ValueOr(INVALID_HANDLE);
         break;
     }
 
@@ -307,8 +309,8 @@ ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factor
 }
 
 ResultVal<std::shared_ptr<File>> OpenFileFromArchive(ArchiveHandle archive_handle,
-                                                       const FileSys::Path& path,
-                                                       const FileSys::Mode mode) {
+                                                     const FileSys::Path& path,
+                                                     const FileSys::Mode mode) {
     ArchiveBackend* archive = GetArchive(archive_handle);
     if (archive == nullptr)
         return ERR_INVALID_ARCHIVE_HANDLE;
@@ -398,7 +400,7 @@ ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
 }
 
 ResultVal<std::shared_ptr<Directory>> OpenDirectoryFromArchive(ArchiveHandle archive_handle,
-                                                                 const FileSys::Path& path) {
+                                                               const FileSys::Path& path) {
     ArchiveBackend* archive = GetArchive(archive_handle);
     if (archive == nullptr)
         return ERR_INVALID_ARCHIVE_HANDLE;
diff --git a/src/core/hle/service/fs/archive.h b/src/core/hle/service/fs/archive.h
index eb76706a1..82d591897 100644
--- a/src/core/hle/service/fs/archive.h
+++ b/src/core/hle/service/fs/archive.h
@@ -104,8 +104,8 @@ ResultCode RegisterArchiveType(std::unique_ptr<FileSys::ArchiveFactory>&& factor
  * @return The opened File object
  */
 ResultVal<std::shared_ptr<File>> OpenFileFromArchive(ArchiveHandle archive_handle,
-                                                       const FileSys::Path& path,
-                                                       const FileSys::Mode mode);
+                                                     const FileSys::Path& path,
+                                                     const FileSys::Mode mode);
 
 /**
  * Delete a File from an Archive
@@ -183,7 +183,7 @@ ResultCode RenameDirectoryBetweenArchives(ArchiveHandle src_archive_handle,
  * @return The opened Directory object
  */
 ResultVal<std::shared_ptr<Directory>> OpenDirectoryFromArchive(ArchiveHandle archive_handle,
-                                                                 const FileSys::Path& path);
+                                                               const FileSys::Path& path);
 
 /**
  * Get the free space in an Archive
diff --git a/src/core/hle/service/fs/fs_user.cpp b/src/core/hle/service/fs/fs_user.cpp
index ea1050fb6..0b03bea22 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -68,13 +68,16 @@ static void OpenFile(Service::Interface* self) {
     LOG_DEBUG(Service_FS, "path=%s, mode=%u attrs=%u", file_path.DebugStr().c_str(), mode.hex,
               attributes);
 
-    ResultVal<std::shared_ptr<File>> file_res = OpenFileFromArchive(archive_handle, file_path, mode);
+    ResultVal<std::shared_ptr<File>> file_res =
+        OpenFileFromArchive(archive_handle, file_path, mode);
     cmd_buff[1] = file_res.Code().raw;
     if (file_res.Succeeded()) {
         std::shared_ptr<File> file = *file_res;
         auto sessions = ServerSession::CreateSessionPair(file->GetName(), file);
         file->ClientConnected(std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions));
-        cmd_buff[3] = Kernel::g_handle_table.Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions)).MoveFrom();
+        cmd_buff[3] = Kernel::g_handle_table
+                          .Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions))
+                          .MoveFrom();
     } else {
         cmd_buff[3] = 0;
         LOG_ERROR(Service_FS, "failed to get a handle for file %s", file_path.DebugStr().c_str());
@@ -131,13 +134,16 @@ static void OpenFileDirectly(Service::Interface* self) {
     }
     SCOPE_EXIT({ CloseArchive(*archive_handle); });
 
-    ResultVal<std::shared_ptr<File>> file_res = OpenFileFromArchive(*archive_handle, file_path, mode);
+    ResultVal<std::shared_ptr<File>> file_res =
+        OpenFileFromArchive(*archive_handle, file_path, mode);
     cmd_buff[1] = file_res.Code().raw;
     if (file_res.Succeeded()) {
         std::shared_ptr<File> file = *file_res;
         auto sessions = ServerSession::CreateSessionPair(file->GetName(), file);
         file->ClientConnected(std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions));
-        cmd_buff[3] = Kernel::g_handle_table.Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions)).MoveFrom();
+        cmd_buff[3] = Kernel::g_handle_table
+                          .Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions))
+                          .MoveFrom();
     } else {
         cmd_buff[3] = 0;
         LOG_ERROR(Service_FS, "failed to get a handle for file %s mode=%u attributes=%u",
@@ -395,13 +401,16 @@ static void OpenDirectory(Service::Interface* self) {
     LOG_DEBUG(Service_FS, "type=%u size=%u data=%s", static_cast<u32>(dirname_type), dirname_size,
               dir_path.DebugStr().c_str());
 
-    ResultVal<std::shared_ptr<Directory>> dir_res = OpenDirectoryFromArchive(archive_handle, dir_path);
+    ResultVal<std::shared_ptr<Directory>> dir_res =
+        OpenDirectoryFromArchive(archive_handle, dir_path);
     cmd_buff[1] = dir_res.Code().raw;
     if (dir_res.Succeeded()) {
         std::shared_ptr<Directory> directory = *dir_res;
         auto sessions = ServerSession::CreateSessionPair(directory->GetName(), directory);
         directory->ClientConnected(std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions));
-        cmd_buff[3] = Kernel::g_handle_table.Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions)).MoveFrom();
+        cmd_buff[3] = Kernel::g_handle_table
+                          .Create(std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions))
+                          .MoveFrom();
     } else {
         LOG_ERROR(Service_FS, "failed to get a handle for directory type=%d size=%d data=%s",
                   dirname_type, dirname_size, dir_path.DebugStr().c_str());
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 418b128b1..9f68898db 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -8,7 +8,6 @@
 #include "common/string_util.h"
 
 #include "core/hle/kernel/server_port.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/ac_u.h"
 #include "core/hle/service/act_a.h"
 #include "core/hle/service/act_u.h"
@@ -66,11 +65,13 @@ static std::string MakeFunctionString(const char* name, const char* port_name,
     return function_string;
 }
 
-void SessionRequestHandler::ClientConnected(Kernel::SharedPtr<Kernel::ServerSession> server_session) {
+void SessionRequestHandler::ClientConnected(
+    Kernel::SharedPtr<Kernel::ServerSession> server_session) {
     connected_sessions.push_back(server_session);
 }
 
-void SessionRequestHandler::ClientDisconnected(Kernel::SharedPtr<Kernel::ServerSession> server_session) {
+void SessionRequestHandler::ClientDisconnected(
+    Kernel::SharedPtr<Kernel::ServerSession> server_session) {
     boost::range::remove_erase(connected_sessions, server_session);
 }
 
@@ -78,7 +79,8 @@ Interface::Interface(u32 max_sessions) : max_sessions(max_sessions) {}
 Interface::~Interface() = default;
 
 void Interface::HandleSyncRequest(Kernel::SharedPtr<Kernel::ServerSession> server_session) {
-    // TODO(Subv): Make use of the server_session in the HLE service handlers to distinguish which session triggered each command.
+    // TODO(Subv): Make use of the server_session in the HLE service handlers to distinguish which
+    // session triggered each command.
 
     u32* cmd_buff = Kernel::GetCommandBuffer();
     auto itr = m_functions.find(cmd_buff[0]);
@@ -113,15 +115,17 @@ void Interface::Register(const FunctionInfo* functions, size_t n) {
 // Module interface
 
 static void AddNamedPort(Interface* interface_) {
-    auto ports = Kernel::ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName(),
-                                                    std::shared_ptr<Interface>(interface_));
+    auto ports =
+        Kernel::ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName(),
+                                           std::shared_ptr<Interface>(interface_));
     auto client_port = std::get<Kernel::SharedPtr<Kernel::ClientPort>>(ports);
     g_kernel_named_ports.emplace(interface_->GetPortName(), std::move(client_port));
 }
 
 void AddService(Interface* interface_) {
-    auto ports = Kernel::ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName(),
-                                                    std::shared_ptr<Interface>(interface_));
+    auto ports =
+        Kernel::ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName(),
+                                           std::shared_ptr<Interface>(interface_));
     auto client_port = std::get<Kernel::SharedPtr<Kernel::ClientPort>>(ports);
     g_srv_services.emplace(interface_->GetPortName(), std::move(client_port));
 }
@@ -190,5 +194,4 @@ void Shutdown() {
     g_kernel_named_ports.clear();
     LOG_DEBUG(Service, "shutdown OK");
 }
-
 }
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index a3af48684..a7ba7688f 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -15,7 +15,6 @@
 #include "core/hle/result.h"
 #include "core/memory.h"
 
-
 namespace Kernel {
 class ServerSession;
 }
@@ -26,12 +25,13 @@ class ServerSession;
 namespace Service {
 
 static const int kMaxPortSize = 8; ///< Maximum size of a port name (8 characters)
-static const u32 DefaultMaxSessions = 10; ///< Arbitrary default number of maximum connections to an HLE service
+/// Arbitrary default number of maximum connections to an HLE service.
+static const u32 DefaultMaxSessions = 10;
 
 /**
  * Interface implemented by HLE Session handlers.
- * This can be provided to a ServerSession in order to hook into several relevant events (such as a new connection or a SyncRequest)
- * so they can be implemented in the emulator.
+ * This can be provided to a ServerSession in order to hook into several relevant events
+ * (such as a new connection or a SyncRequest) so they can be implemented in the emulator.
  */
 class SessionRequestHandler {
 public:
@@ -61,12 +61,14 @@ public:
 
 protected:
     /// List of sessions that are connected to this handler.
-    /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list for the duration of the connection.
+    /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list
+    // for the duration of the connection.
     std::vector<Kernel::SharedPtr<Kernel::ServerSession>> connected_sessions;
 };
 
 /**
- * Framework for implementing HLE service handlers which dispatch incoming SyncRequests based on a table mapping header ids to handler functions.
+ * Framework for implementing HLE service handlers which dispatch incoming SyncRequests based on a
+ * table mapping header ids to handler functions.
  */
 class Interface : public SessionRequestHandler {
 public:
@@ -88,10 +90,13 @@ public:
     }
 
     /**
-     * Gets the maximum allowed number of sessions that can be connected to this service at the same time.
+     * Gets the maximum allowed number of sessions that can be connected to this service
+     * at the same time.
      * @returns The maximum number of connections allowed.
      */
-    u32 GetMaxSessions() const { return max_sessions; }
+    u32 GetMaxSessions() const {
+        return max_sessions;
+    }
 
     typedef void (*Function)(Interface*);
 
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index 37420201b..18d0a699d 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -7,8 +7,8 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/event.h"
+#include "core/hle/kernel/server_session.h"
 #include "core/hle/service/srv.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////