Changes in uspace/app/trace/ipcp.c [eed4139:a35b458] in mainline

File:

• uspace/app/trace/ipcp.c (modified) (15 diffs)

uspace/app/trace/ipcp.c

@@ -46 +46 @@
 
 typedef struct {
-        cap_phone_handle_t phone_handle;
+        sysarg_t phone_hash;
         ipc_call_t question;
         oper_t *oper;
 
-        cap_call_handle_t call_handle;
+        ipc_callid_t call_hash;
 
         ht_link_t link;
@@ -75 +75 @@
 static size_t pending_call_key_hash(void *key)
 {
-        cap_call_handle_t *chandle = (cap_call_handle_t *) key;
-        return CAP_HANDLE_RAW(*chandle);
+        ipc_callid_t *call_id = (ipc_callid_t *)key;
+        return *call_id;
 }
 
@@ -82 +82 @@
 {
         pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
-        return CAP_HANDLE_RAW(hs->call_handle);
+        return hs->call_hash;
 }
 
 static bool pending_call_key_equal(void *key, const ht_link_t *item)
 {
-        cap_call_handle_t *chandle = (cap_call_handle_t *) key;
+        ipc_callid_t *call_id = (ipc_callid_t *)key;
         pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
 
-        return *chandle == hs->call_handle;
+        return *call_id == hs->call_hash;
 }
 
@@ -102 +102 @@
 
 
-void ipcp_connection_set(cap_phone_handle_t phone, int server, proto_t *proto)
-{
-        // XXX: there is no longer a limit on the number of phones as phones are
-        // now handled using capabilities
-        if (CAP_HANDLE_RAW(phone) < 0 || CAP_HANDLE_RAW(phone) >= MAX_PHONE)
-            return;
-        connections[CAP_HANDLE_RAW(phone)].server = server;
-        connections[CAP_HANDLE_RAW(phone)].proto = proto;
-        have_conn[CAP_HANDLE_RAW(phone)] = 1;
-}
-
-void ipcp_connection_clear(cap_phone_handle_t phone)
-{
-        have_conn[CAP_HANDLE_RAW(phone)] = 0;
-        connections[CAP_HANDLE_RAW(phone)].server = 0;
-        connections[CAP_HANDLE_RAW(phone)].proto = NULL;
+void ipcp_connection_set(int phone, int server, proto_t *proto)
+{
+        if (phone <0 || phone >= MAX_PHONE) return;
+        connections[phone].server = server;
+        connections[phone].proto = proto;
+        have_conn[phone] = 1;
+}
+
+void ipcp_connection_clear(int phone)
+{
+        have_conn[phone] = 0;
+        connections[phone].server = 0;
+        connections[phone].proto = NULL;
 }
 
@@ -177 +174 @@
 }
 
-void ipcp_call_out(cap_phone_handle_t phandle, ipc_call_t *call,
-    cap_call_handle_t chandle)
+void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)
 {
         pending_call_t *pcall;
@@ -186 +182 @@
         int i;
 
-        if (have_conn[CAP_HANDLE_RAW(phandle)])
-                proto = connections[CAP_HANDLE_RAW(phandle)].proto;
-        else
-                proto = NULL;
+        if (have_conn[phone]) proto = connections[phone].proto;
+        else proto = NULL;
 
         args = call->args;
 
         if ((display_mask & DM_IPC) != 0) {
-                printf("Call handle: %p, phone: %p, proto: %s, method: ",
-                    chandle, phandle, (proto ? proto->name : "n/a"));
+                printf("Call ID: %d, phone: %d, proto: %s, method: ",
+                    hash, phone,
+                    (proto ? proto->name : "n/a"));
                 ipc_m_print(proto, IPC_GET_IMETHOD(*call));
                 printf(" args: (%" PRIun ", %" PRIun ", %" PRIun ", "
@@ -213 +208 @@
                 if (oper != NULL) {
 
-                        printf("%s(%p).%s", (proto ? proto->name : "n/a"),
-                            phandle, (oper ? oper->name : "unknown"));
+                        printf("%s(%d).%s", (proto ? proto->name : "n/a"),
+                            phone, (oper ? oper->name : "unknown"));
 
                         putchar('(');
@@ -241 +236 @@
 
         pcall = malloc(sizeof(pending_call_t));
-        pcall->phone_handle = phandle;
+        pcall->phone_hash = phone;
         pcall->question = *call;
-        pcall->call_handle = chandle;
+        pcall->call_hash = hash;
         pcall->oper = oper;
 
@@ -249 +244 @@
 }
 
-static void parse_answer(cap_call_handle_t call_handle, pending_call_t *pcall,
+static void parse_answer(ipc_callid_t hash, pending_call_t *pcall,
     ipc_call_t *answer)
 {
-        cap_phone_handle_t phone;
+        sysarg_t phone;
         sysarg_t method;
         sysarg_t service;
         errno_t retval;
         proto_t *proto;
-        cap_phone_handle_t cphone;
+        int cphone;
 
         sysarg_t *resp;
@@ -263 +258 @@
         int i;
 
-        phone = pcall->phone_handle;
+        phone = pcall->phone_hash;
         method = IPC_GET_IMETHOD(pcall->question);
         retval = IPC_GET_RETVAL(*answer);
@@ -270 +265 @@
 
         if ((display_mask & DM_IPC) != 0) {
-                printf("Response to %p: retval=%s, args = (%" PRIun ", "
+                printf("Response to %d: retval=%s, args = (%" PRIun ", "
                     "%" PRIun ", %" PRIun ", %" PRIun ", %" PRIun ")\n",
-                    call_handle, str_error_name(retval), IPC_GET_ARG1(*answer),
+                    hash, str_error_name(retval), IPC_GET_ARG1(*answer),
                     IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer),
                     IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
@@ -312 +307 @@
                         proto = proto_unknown;
 
-                cphone = (cap_phone_handle_t) IPC_GET_ARG5(*answer);
+                cphone = IPC_GET_ARG5(*answer);
                 if ((display_mask & DM_SYSTEM) != 0) {
-                        printf("Registering connection (phone %p, protocol: %s)\n", cphone,
+                        printf("Registering connection (phone %d, protocol: %s)\n", cphone,
                     proto->name);
                 }
@@ -322 +317 @@
 }
 
-void ipcp_call_in(ipc_call_t *call, cap_call_handle_t chandle)
+void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
 {
         ht_link_t *item;
@@ -330 +325 @@
                 /* Not a response */
                 if ((display_mask & DM_IPC) != 0) {
-                        printf("Not a response (handle %p)\n", chandle);
+                        printf("Not a response (hash %d)\n", hash);
                 }
                 return;
         }
 
-        item = hash_table_find(&pending_calls, &chandle);
+        item = hash_table_find(&pending_calls, &hash);
         if (item == NULL)
                 return; /* No matching question found */
@@ -344 +339 @@
 
         pcall = hash_table_get_inst(item, pending_call_t, link);
-        hash_table_remove(&pending_calls, &chandle);
-
-        parse_answer(chandle, pcall, call);
+        hash_table_remove(&pending_calls, &hash);
+
+        parse_answer(hash, pcall, call);
         free(pcall);
 }
 
-void ipcp_hangup(cap_phone_handle_t phone, errno_t rc)
+void ipcp_hangup(int phone, errno_t rc)
 {
         if ((display_mask & DM_SYSTEM) != 0) {
-                printf("Hang up phone %p -> %s\n", phone, str_error_name(rc));
+                printf("Hang phone %d up -> %s\n", phone, str_error_name(rc));
                 ipcp_connection_clear(phone);
         }