Changeset 984a9ba in mainline for uspace/lib/drv/generic/remote_ahci.c

Timestamp:

2018-07-05T09:34:09Z (6 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

63d46341

Parents:

76f566d

Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:

• uspace/lib/drv/generic/remote_ahci.c (modified) (8 diffs)

uspace/lib/drv/generic/remote_ahci.c

@@ -182 +182 @@
 }
 
-static void remote_ahci_get_sata_device_name(ddf_fun_t *, void *, cap_call_handle_t,
-    ipc_call_t *);
-static void remote_ahci_get_num_blocks(ddf_fun_t *, void *, cap_call_handle_t,
-    ipc_call_t *);
-static void remote_ahci_get_block_size(ddf_fun_t *, void *, cap_call_handle_t,
-    ipc_call_t *);
-static void remote_ahci_read_blocks(ddf_fun_t *, void *, cap_call_handle_t,
-    ipc_call_t *);
-static void remote_ahci_write_blocks(ddf_fun_t *, void *, cap_call_handle_t,
-    ipc_call_t *);
+static void remote_ahci_get_sata_device_name(ddf_fun_t *, void *, ipc_call_t *);
+static void remote_ahci_get_num_blocks(ddf_fun_t *, void *, ipc_call_t *);
+static void remote_ahci_get_block_size(ddf_fun_t *, void *, ipc_call_t *);
+static void remote_ahci_read_blocks(ddf_fun_t *, void *, ipc_call_t *);
+static void remote_ahci_write_blocks(ddf_fun_t *, void *, ipc_call_t *);
 
 /** Remote AHCI interface operations. */
@@ -210 +205 @@
 
 void remote_ahci_get_sata_device_name(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
         const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
         if (ahci_iface->get_sata_device_name == NULL) {
-                async_answer_0(chandle, ENOTSUP);
+                async_answer_0(call, ENOTSUP);
                 return;
         }
@@ -224 +219 @@
         char *sata_dev_name = malloc(sata_dev_name_length);
         if (sata_dev_name == NULL) {
-                async_answer_0(chandle, ENOMEM);
+                async_answer_0(call, ENOMEM);
                 return;
         }
@@ -231 +226 @@
             sata_dev_name_length, sata_dev_name);
 
+        ipc_call_t data;
         size_t real_size;
-        cap_call_handle_t call_handle;
-        if ((async_data_read_receive(&call_handle, &real_size)) &&
+        if ((async_data_read_receive(&data, &real_size)) &&
             (real_size == sata_dev_name_length))
-                async_data_read_finalize(call_handle, sata_dev_name,
+                async_data_read_finalize(&data, sata_dev_name,
                     sata_dev_name_length);
 
         free(sata_dev_name);
-        async_answer_0(chandle, ret);
+        async_answer_0(call, ret);
 }
 
 static void remote_ahci_get_num_blocks(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
         const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
         if (ahci_iface->get_num_blocks == NULL) {
-                async_answer_0(chandle, ENOTSUP);
+                async_answer_0(call, ENOTSUP);
                 return;
         }
@@ -256 +251 @@
 
         if (ret != EOK)
-                async_answer_0(chandle, ret);
+                async_answer_0(call, ret);
         else
-                async_answer_2(chandle, EOK, HI(blocks), LO(blocks));
+                async_answer_2(call, EOK, HI(blocks), LO(blocks));
 }
 
 static void remote_ahci_get_block_size(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+    ipc_call_t *call)
 {
         const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
         if (ahci_iface->get_block_size == NULL) {
-                async_answer_0(chandle, ENOTSUP);
+                async_answer_0(call, ENOTSUP);
                 return;
         }
@@ -275 +270 @@
 
         if (ret != EOK)
-                async_answer_0(chandle, ret);
+                async_answer_0(call, ret);
         else
-                async_answer_1(chandle, EOK, blocks);
-}
-
-void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t chandle, ipc_call_t *call)
+                async_answer_1(call, EOK, blocks);
+}
+
+void remote_ahci_read_blocks(ddf_fun_t *fun, void *iface, ipc_call_t *call)
 {
         const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
         if (ahci_iface->read_blocks == NULL) {
-                async_answer_0(chandle, ENOTSUP);
-                return;
-        }
-
+                async_answer_0(call, ENOTSUP);
+                return;
+        }
+
+        ipc_call_t data;
         size_t maxblock_size;
         unsigned int flags;
-
-        cap_call_handle_t call_handle;
-        async_share_out_receive(&call_handle, &maxblock_size, &flags);
+        async_share_out_receive(&data, &maxblock_size, &flags);
 
         void *buf;
-        async_share_out_finalize(call_handle, &buf);
+        async_share_out_finalize(&data, &buf);
 
         const uint64_t blocknum =
@@ -306 +299 @@
         const errno_t ret = ahci_iface->read_blocks(fun, blocknum, cnt, buf);
 
-        async_answer_0(chandle, ret);
-}
-
-void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle,
-    ipc_call_t *call)
+        async_answer_0(call, ret);
+}
+
+void remote_ahci_write_blocks(ddf_fun_t *fun, void *iface, ipc_call_t *call)
 {
         const ahci_iface_t *ahci_iface = (ahci_iface_t *) iface;
 
         if (ahci_iface->read_blocks == NULL) {
-                async_answer_0(chandle, ENOTSUP);
-                return;
-        }
-
+                async_answer_0(call, ENOTSUP);
+                return;
+        }
+
+        ipc_call_t data;
         size_t maxblock_size;
         unsigned int flags;
-
-        cap_call_handle_t call_handle;
-        async_share_out_receive(&call_handle, &maxblock_size, &flags);
+        async_share_out_receive(&data, &maxblock_size, &flags);
 
         void *buf;
-        async_share_out_finalize(call_handle, &buf);
+        async_share_out_finalize(&data, &buf);
 
         const uint64_t blocknum =
@@ -335 +326 @@
         const errno_t ret = ahci_iface->write_blocks(fun, blocknum, cnt, buf);
 
-        async_answer_0(chandle, ret);
+        async_answer_0(call, ret);
 }