WebSVN – HelenOS – Diff – /trunk/uspace/app/trace/ipcp.c

 /*
  * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * - Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in the
  *   documentation and/or other materials provided with the distribution.
  * - The name of the author may not be used to endorse or promote products
  *   derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup trace
  * @{
  */
 /** @file
  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <libadt/hash_table.h>
 #include "ipc_desc.h"
 #include "proto.h"
+#include "trace.h"
 #include "ipcp.h"
 #define IPCP_CALLID_SYNC 0
 typedef struct {
     int phone_hash;
     ipc_call_t question;
     int call_hash;
     link_t link;
 } pending_call_t;
 typedef struct {
     int server;
     proto_t *proto;
 } connection_t;
 #define MAX_PHONE 64
 connection_t connections[MAX_PHONE];
 int have_conn[MAX_PHONE];
 #define PCALL_TABLE_CHAINS 32
 hash_table_t pending_calls;
 /*
  * Pseudo-protocols
  */
 proto_t *proto_system;      /**< Protocol describing system IPC methods. */
 proto_t *proto_unknown;     /**< Protocol with no known methods. */
 static hash_index_t pending_call_hash(unsigned long key[]);
 static int pending_call_compare(unsigned long key[], hash_count_t keys,
     link_t *item);
 static void pending_call_remove_callback(link_t *item);
 hash_table_operations_t pending_call_ops = {
     .hash = pending_call_hash,
     .compare = pending_call_compare,
     .remove_callback = pending_call_remove_callback
 };
 static hash_index_t pending_call_hash(unsigned long key[])
+{
 //  printf("pending_call_hash\n");
     return key[0] % PCALL_TABLE_CHAINS;
+}
 static int pending_call_compare(unsigned long key[], hash_count_t keys,
     link_t *item)
+{
     pending_call_t *hs;
 //  printf("pending_call_compare\n");
     hs = hash_table_get_instance(item, pending_call_t, link);
     return key[0] == hs->call_hash;
+}
 static void pending_call_remove_callback(link_t *item)
+{
 //  printf("pending_call_remove_callback\n");
+}
 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;
+}
 static void ipc_m_print(proto_t *proto, ipcarg_t method)
+{
     oper_t *oper;
     /* Try system methods first */
     oper = proto_get_oper(proto_system, method);
     if (oper == NULL && proto != NULL) {
         /* Not a system method, try the user protocol. */
         oper = proto_get_oper(proto, method);
+    }
     if (oper != NULL) {
         printf("%s (%d)", oper->name, method);
         return;
+    }
     printf("%d", method);
+}
 void ipcp_init(void)
+{
     ipc_m_desc_t *desc;
     oper_t *oper;
     /*
      * Create a pseudo-protocol 'unknown' that has no known methods.
      */
     proto_unknown = proto_new("unknown");
     /*
      * Create a pseudo-protocol 'system' defining names of system IPC
      * methods.
      */
     proto_system = proto_new("system");
     desc = ipc_methods;
     while (desc->number != 0) {
         oper = oper_new(desc->name);
         proto_add_oper(proto_system, desc->number, oper);
         ++desc;
+    }
     hash_table_create(&pending_calls, PCALL_TABLE_CHAINS, 1, &pending_call_ops);
+}
 void ipcp_cleanup(void)
+{
     proto_delete(proto_system);
     hash_table_destroy(&pending_calls);
+}
 void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)
+{
     pending_call_t *pcall;
     proto_t *proto;
     unsigned long key[1];
+    oper_t *oper;
     if (have_conn[phone]) proto = connections[phone].proto;
     else proto = NULL;
-//  printf("ipcp_call_out()\n");
+    if ((display_mask & DM_IPC) != 0) {
-    printf("call id: 0x%x, phone: %d, proto: %s, method: ", hash, phone,
+        printf("Call ID: 0x%x, phone: %d, proto: %s, method: ", hash,
-        (proto ? proto->name : "n/a"));
+            phone, (proto ? proto->name : "n/a"));
-    ipc_m_print(proto, IPC_GET_METHOD(*call));
+        ipc_m_print(proto, IPC_GET_METHOD(*call));
-    printf(" args: (%u, %u, %u, %u, %u)\n",
+        printf(" args: (%u, %u, %u, %u, %u)\n",
-        IPC_GET_ARG1(*call),
+            IPC_GET_ARG1(*call),
-        IPC_GET_ARG2(*call),
+            IPC_GET_ARG2(*call),
-        IPC_GET_ARG3(*call),
+            IPC_GET_ARG3(*call),
-        IPC_GET_ARG4(*call),
+            IPC_GET_ARG4(*call),
-        IPC_GET_ARG5(*call)
+            IPC_GET_ARG5(*call)
-    );
+        );
+    }
+    if ((display_mask & DM_USER) != 0) {
+        if (proto != NULL) {
+            oper = proto_get_oper(proto, IPC_GET_METHOD(*call));
+        } else {
+            oper = NULL;
+        }
+        if (oper != NULL) {
+            printf("%s(%d).%s", (proto ? proto->name : "n/a"),
+                phone, (oper ? oper->name : "unknown"));
+            printf("(%u, %u, %u, %u, %u)\n",
+                IPC_GET_ARG1(*call),
+                IPC_GET_ARG2(*call),
+                IPC_GET_ARG3(*call),
+                IPC_GET_ARG4(*call),
+                IPC_GET_ARG5(*call)
+            );
+        }
+    }
     /* Store call in hash table for response matching */
     pcall = malloc(sizeof(pending_call_t));
     pcall->phone_hash = phone;
     pcall->question = *call;
     pcall->call_hash = hash;
     key[0] = hash;
     hash_table_insert(&pending_calls, key, &pcall->link);
+}
-static void parse_answer(pending_call_t *pcall, ipc_call_t *answer)
+static void parse_answer(ipc_callid_t hash, pending_call_t *pcall,
+    ipc_call_t *answer)
+{
     int phone;
     ipcarg_t method;
     ipcarg_t service;
     int retval;
     proto_t *proto;
     int cphone;
 //  printf("parse_answer\n");
     phone = pcall->phone_hash;
     method = IPC_GET_METHOD(pcall->question);
     retval = IPC_GET_RETVAL(*answer);
+    if ((display_mask & DM_IPC) != 0) {
-    printf("phone=%d, method=%d, retval=%d\n",
+        printf("Response to 0x%x: retval=%d, args = (%u, %u, %u, %u, %u)\n",
+            hash, retval, IPC_GET_ARG1(*answer),
+            IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer),
+            IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
+    }
+    if ((display_mask & DM_USER) != 0) {
-        phone, method, retval);
+        printf("-> %d\n", retval);
+    }
     if (phone == 0 && method == IPC_M_CONNECT_ME_TO && retval == 0) {
         /* Connected to a service (through NS) */
         service = IPC_GET_ARG1(pcall->question);
         proto = proto_get_by_srv(service);
         if (proto == NULL) proto = proto_unknown;
         cphone = IPC_GET_ARG5(*answer);
+        if ((display_mask & DM_SYSTEM) != 0) {
-        printf("registering connection (phone %d, protocol: %s)\n", cphone,
+            printf("Registering connection (phone %d, protocol: %s)\n", cphone,
-            proto->name);
+                    proto->name);
+        }
         ipcp_connection_set(cphone, 0, proto);
+    }
+}
 void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
+{
     link_t *item;
     pending_call_t *pcall;
     unsigned long key[1];
 //  printf("ipcp_call_in()\n");
 /*  printf("phone: %d, method: ", call->in_phone_hash);
     ipc_m_print(IPC_GET_METHOD(*call));
     printf(" args: (%u, %u, %u, %u, %u)\n",
         IPC_GET_ARG1(*call),
         IPC_GET_ARG2(*call),
         IPC_GET_ARG3(*call),
         IPC_GET_ARG4(*call),
         IPC_GET_ARG5(*call)
     );*/
     if ((hash & IPC_CALLID_ANSWERED) == 0 && hash != IPCP_CALLID_SYNC) {
         /* Not a response */
+        if ((display_mask & DM_IPC) != 0) {
-        printf("Not a response (hash %d)\n", hash);
+            printf("Not a response (hash %d)\n", hash);
+        }
         return;
+    }
     hash = hash & ~IPC_CALLID_ANSWERED;
     key[0] = hash;
     item = hash_table_find(&pending_calls, key);
     if (item == NULL) return; // No matching question found
+    /*
+     * Response matched to question.
+     */
     pcall = hash_table_get_instance(item, pending_call_t, link);
-    printf("response matched to question\n");
     hash_table_remove(&pending_calls, key, 1);
-    parse_answer(pcall, call);
+    parse_answer(hash, pcall, call);
     free(pcall);
+}
 void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer)
+{
     ipcp_call_out(phone, call, IPCP_CALLID_SYNC);
     ipcp_call_in(answer, IPCP_CALLID_SYNC);
+}
 void ipcp_hangup(int phone, int rc)
+{
+    if ((display_mask & DM_SYSTEM) != 0) {
-    printf("hangup phone %d -> %d\n", phone, rc);
+        printf("Hang phone %d up -> %d\n", phone, rc);
-    ipcp_connection_clear(phone);
+        ipcp_connection_clear(phone);
+    }
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)/trunk/uspace/app/trace/ipcp.c – Rev 3443 → 3444