Merge branch 'threading'

1 files changed, 26 insertions, 46 deletions

diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index b260a290..716669be 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -4,22 +4,22 @@
 
 #pragma once
 
+#include <algorithm>
 #include <vector>
 #include <map>
 #include <string>
 
 #include "common/common.h"
-#include "common/common_types.h"
 #include "core/mem_map.h"
-#include "core/hle/syscall.h"
+
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/svc.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace Service
 
 namespace Service {
 
-typedef s32 NativeUID;                          ///< Native handle for a service
-
 static const int kMaxPortSize           = 0x08; ///< Maximum size of a port name (8 characters)
 static const int kCommandHeaderOffset   = 0x80; ///< Offset into command buffer of header
 
@@ -35,15 +35,15 @@ inline static u32* GetCommandBuffer(const int offset=0) {
 class Manager;
 
 /// Interface to a CTROS service
-class Interface : NonCopyable {
+class Interface  : public Kernel::Object {
     friend class Manager;
 public:
+    
+    const char *GetName() { return GetPortName(); }
+    const char *GetTypeName() { return GetPortName(); }
 
-    Interface() {
-    }
-
-    virtual ~Interface() {
-    }
+    static Kernel::HandleType GetStaticHandleType() { return Kernel::HandleType::Service; }
+    Kernel::HandleType GetHandleType() const { return Kernel::HandleType::Service; }
 
     typedef void (*Function)(Interface*);
 
@@ -54,54 +54,43 @@ public:
     };
 
     /**
-     * Gets the UID for the serice
-     * @return UID of service in native format
-     */
-    NativeUID GetUID() const {
-        return (NativeUID)m_uid;
-    }
-
-    /**
      * Gets the string name used by CTROS for a service
      * @return Port name of service
      */
-    virtual std::string GetPortName() const {
+    virtual const char *GetPortName() const {
         return "[UNKNOWN SERVICE PORT]";
     }
 
     /// Allocates a new handle for the service
-    Syscall::Handle NewHandle() {
-        Syscall::Handle handle = (m_handles.size() << 16) | m_uid;
+    Handle CreateHandle(Kernel::Object *obj) {
+        Handle handle = Kernel::g_object_pool.Create(obj);
         m_handles.push_back(handle);
         return handle;
     }
 
     /// Frees a handle from the service
-    void DeleteHandle(Syscall::Handle handle) {
-        for(auto iter = m_handles.begin(); iter != m_handles.end(); ++iter) {
-            if(*iter == handle) {
-                m_handles.erase(iter);
-                break;
-            }
-        }
+    template <class T>
+    void DeleteHandle(const Handle handle) {
+        g_object_pool.Destroy<T>(handle);
+        m_handles.erase(std::remove(m_handles.begin(), m_handles.end(), handle), m_handles.end());
     }
 
     /**
      * Called when svcSendSyncRequest is called, loads command buffer and executes comand
      * @return Return result of svcSendSyncRequest passed back to user app
      */
-    Syscall::Result Sync() {
+    Result Sync() {
         u32* cmd_buff = GetCommandBuffer();
         auto itr = m_functions.find(cmd_buff[0]);
 
         if (itr == m_functions.end()) {
             ERROR_LOG(OSHLE, "Unknown/unimplemented function: port = %s, command = 0x%08X!", 
-                GetPortName().c_str(), cmd_buff[0]);
+                GetPortName(), cmd_buff[0]);
             return -1;
         }
         if (itr->second.func == NULL) {
             ERROR_LOG(OSHLE, "Unimplemented function: port = %s, name = %s!", 
-                GetPortName().c_str(), itr->second.name.c_str());
+                GetPortName(), itr->second.name.c_str());
             return -1;
         } 
 
@@ -122,10 +111,10 @@ protected:
     }
 
 private:
-    u32 m_uid;
-    
-    std::vector<Syscall::Handle>    m_handles;
-    std::map<u32, FunctionInfo>     m_functions;
+
+    std::vector<Handle>         m_handles;
+    std::map<u32, FunctionInfo> m_functions;
+
 };
 
 /// Simple class to manage accessing services from ports and UID handles
@@ -143,25 +132,16 @@ public:
     void DeleteService(std::string port_name);
 
     /// Get a Service Interface from its UID
-    Interface* FetchFromUID(u32 uid);
+    Interface* FetchFromHandle(u32 uid);
 
     /// Get a Service Interface from its port
     Interface* FetchFromPortName(std::string port_name);
 
 private:
 
-    /// Convert an index into m_services vector into a UID
-    static u32 GetUIDFromIndex(const int index) {
-        return index | 0x10000000;
-    }
-
-    /// Convert a UID into an index into m_services
-    static int GetIndexFromUID(const u32 uid) {
-        return uid & 0x0FFFFFFF;
-    }
-
     std::vector<Interface*>     m_services;
     std::map<std::string, u32>  m_port_map;
+
 };
 
 /// Initialize ServiceManager