Changes in uspace/srv/net/nil/nildummy/nildummy.c [6b82009:49bd793b] in mainline

File:

• uspace/srv/net/nil/nildummy/nildummy.c (modified) (22 diffs)

uspace/srv/net/nil/nildummy/nildummy.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Radim Vansa
  * All rights reserved.
  *
@@ -36 +37 @@
  */
 
+#include <assert.h>
 #include <async.h>
 #include <malloc.h>
@@ -50 +52 @@
 #include <net/packet.h>
 #include <packet_remote.h>
-#include <netif_remote.h>
+#include <packet_client.h>
+#include <devman.h>
+#include <device/nic.h>
 #include <nil_skel.h>
 #include "nildummy.h"
@@ -65 +69 @@
 DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
 
-int nil_device_state_msg_local(device_id_t device_id, sysarg_t state)
+int nil_device_state_msg_local(nic_device_id_t device_id, sysarg_t state)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
@@ -91 +95 @@
         
         return rc;
-}
-
-/** Process IPC messages from the registered device driver modules
- *
- * @param[in]     iid   Message identifier.
- * @param[in,out] icall Message parameters.
- * @param[in]     arg    Local argument.
- *
- */
-static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-        packet_t *packet;
-        int rc;
-        
-        while (true) {
-                switch (IPC_GET_IMETHOD(*icall)) {
-                case NET_NIL_DEVICE_STATE:
-                        rc = nil_device_state_msg_local(IPC_GET_DEVICE(*icall),
-                            IPC_GET_STATE(*icall));
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                
-                case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(nildummy_globals.net_sess,
-                            &packet, IPC_GET_PACKET(*icall));
-                        if (rc == EOK)
-                                rc = nil_received_msg_local(IPC_GET_DEVICE(*icall),
-                                    packet, 0);
-                        
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                
-                default:
-                        async_answer_0(iid, (sysarg_t) ENOTSUP);
-                }
-                
-                iid = async_get_call(icall);
-        }
 }
 
@@ -148 +114 @@
  *
  */
-static int nildummy_device_message(device_id_t device_id, services_t service,
-    size_t mtu)
+static int nildummy_device_message(nic_device_id_t device_id,
+    devman_handle_t handle, size_t mtu)
 {
         fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
@@ -157 +123 @@
             nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (device) {
-                if (device->service != service) {
-                        printf("Device %d already exists\n", device->device_id);
-                        fibril_rwlock_write_unlock(
-                            &nildummy_globals.devices_lock);
+                if (device->handle != handle) {
+                        printf("Device %d exists, handles do not match\n",
+                            device->device_id);
+                        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                         return EEXIST;
                 }
@@ -170 +136 @@
                         device->mtu = NET_DEFAULT_MTU;
                 
-                printf("Device %d already exists:\tMTU\t= %zu\n",
-                    device->device_id, device->mtu);
+                printf("Device %d already exists (mtu: %zu)\n", device->device_id,
+                    device->mtu);
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                 
@@ -192 +158 @@
         
         device->device_id = device_id;
-        device->service = service;
+        device->handle = handle;
         if (mtu > 0)
                 device->mtu = mtu;
         else
                 device->mtu = NET_DEFAULT_MTU;
-
+        
         /* Bind the device driver */
-        device->sess = netif_bind_service(device->service, device->device_id,
-            SERVICE_ETHERNET, nildummy_receiver);
+        device->sess = devman_device_connect(EXCHANGE_SERIALIZE, handle,
+            IPC_FLAG_BLOCKING);
         if (device->sess == NULL) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
@@ -207 +173 @@
         }
         
+        nic_connect_to_nil(device->sess, SERVICE_NILDUMMY, device_id);
+        
         /* Get hardware address */
-        int rc = netif_get_addr_req(device->sess, device->device_id,
-            &device->addr, &device->addr_data);
+        int rc = nic_get_address(device->sess, &device->addr);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
@@ -215 +182 @@
                 return rc;
         }
+        
+        device->addr_len = ETH_ADDR;
         
         /* Add to the cache */
@@ -221 +190 @@
         if (index < 0) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
-                free(device->addr);
-                free(device->addr_data);
                 free(device);
                 return index;
         }
         
-        printf("%s: Device registered (id: %d, service: %d, mtu: %zu)\n",
-            NAME, device->device_id, device->service, device->mtu);
+        printf("%s: Device registered (id: %d, mtu: %zu)\n", NAME,
+            device->device_id, device->mtu);
         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
         return EOK;
@@ -243 +210 @@
  *
  */
-static int nildummy_addr_message(device_id_t device_id,
-    measured_string_t **address)
-{
-        if (!address)
+static int nildummy_addr_message(nic_device_id_t device_id, size_t *addrlen)
+{
+        if (!addrlen)
                 return EBADMEM;
         
@@ -258 +224 @@
         }
         
-        *address = device->addr;
+        ipc_callid_t callid;
+        size_t max_len;
+        if (!async_data_read_receive(&callid, &max_len)) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                return EREFUSED;
+        }
+        
+        if (max_len < device->addr_len) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                async_data_read_finalize(callid, NULL, 0);
+                return ELIMIT;
+        }
+        
+        int rc = async_data_read_finalize(callid,
+            (uint8_t *) &device->addr.address, device->addr_len);
+        if (rc != EOK) {
+                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+                return rc;
+        }
+        
+        *addrlen = device->addr_len;
         
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
-        
-        return (*address) ? EOK : ENOENT;
+        return EOK;
 }
 
@@ -278 +263 @@
  *
  */
-static int nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
-    size_t *prefix, size_t *content, size_t *suffix)
+static int nildummy_packet_space_message(nic_device_id_t device_id,
+    size_t *addr_len, size_t *prefix, size_t *content, size_t *suffix)
 {
         if ((!addr_len) || (!prefix) || (!content) || (!suffix))
@@ -303 +288 @@
 }
 
-int nil_received_msg_local(device_id_t device_id, packet_t *packet,
-    services_t target)
+int nil_received_msg_local(nic_device_id_t device_id, packet_t *packet)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
@@ -340 +324 @@
         nildummy_globals.proto.sess = sess;
         
-        printf("%s: Protocol registered (service: %d)\n",
+        printf("%s: Protocol registered (service: %#x)\n",
             NAME, nildummy_globals.proto.service);
         
@@ -358 +342 @@
  *
  */
-static int nildummy_send_message(device_id_t device_id, packet_t *packet,
+static int nildummy_send_message(nic_device_id_t device_id, packet_t *packet,
     services_t sender)
 {
@@ -372 +356 @@
         /* Send packet queue */
         if (packet)
-                netif_send_msg(device->sess, device_id, packet,
-                    SERVICE_NILDUMMY);
+                nic_send_message(device->sess, packet_get_id(packet));
         
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
@@ -383 +366 @@
     ipc_call_t *answer, size_t *answer_count)
 {
-        measured_string_t *address;
         packet_t *packet;
         size_t addrlen;
@@ -404 +386 @@
         case NET_NIL_DEVICE:
                 return nildummy_device_message(IPC_GET_DEVICE(*call),
-                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
+                    IPC_GET_DEVICE_HANDLE(*call), IPC_GET_MTU(*call));
         
         case NET_NIL_SEND:
@@ -427 +409 @@
         
         case NET_NIL_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
+        case NET_NIL_BROADCAST_ADDR:
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &addrlen);
                 if (rc != EOK)
                         return rc;
-                return measured_strings_reply(address, 1);
-        
-        case NET_NIL_BROADCAST_ADDR:
-                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
-                if (rc != EOK)
-                        return rc;
-                return measured_strings_reply(address, 1);
+                
+                IPC_SET_ADDR(*answer, addrlen);
+                *answer_count = 1;
+                return rc;
+        case NET_NIL_DEVICE_STATE:
+                rc = nil_device_state_msg_local(IPC_GET_DEVICE(*call),
+                    IPC_GET_STATE(*call));
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
+        
+        case NET_NIL_RECEIVED:
+                rc = packet_translate_remote(nildummy_globals.net_sess, &packet,
+                    IPC_GET_ARG2(*call));
+                if (rc == EOK)
+                        rc = nil_received_msg_local(IPC_GET_ARG1(*call), packet);
+                
+                async_answer_0(callid, (sysarg_t) rc);
+                return rc;
         }