Changeset 192565b in mainline for uspace/lib/c/generic

Timestamp:

2013-05-27T13:18:13Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

f2c19b0

Parents:

d120133 (diff), c90aed4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

uspace/lib/c/generic

Files:

• adt/hash_table.c (modified) (1 diff)
• async.c (modified) (2 diffs)
• device/hw_res_parsed.c (modified) (1 diff)
• dnsr.c (added)
• inet/addr.c (added)
• io/con_srv.c (modified) (4 diffs)
• io/console.c (modified) (5 diffs)
• mem.c (modified) (1 diff)
• net/inet.c (modified) (2 diffs)
• net/socket_client.c (modified) (2 diffs)

uspace/lib/c/generic/adt/hash_table.c

@@ -81 +81 @@
  * @param init_size Initial desired number of hash table buckets. Pass zero
  *                 if you want the default initial size. 
- * @param max_keys Maximal number of keys needed to identify an item.
+ * @param max_load The table is resized when the average load per bucket
+ *                 exceeds this number. Pass zero if you want the default.
  * @param op       Hash table operations structure. remove_callback()
  *                 is optional and can be NULL if no action is to be taken

uspace/lib/c/generic/async.c

@@ -2090 +2090 @@
  * @param arg   User defined argument.
  * @param flags Storage for the received flags. Can be NULL.
- * @param dst   Destination address space area base. Cannot be NULL.
+ * @param dst   Address of the storage for the destination address space area
+ *              base address. Cannot be NULL.
  *
  * @return Zero on success or a negative error code from errno.h.
@@ -2218 +2219 @@
  *
  * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Destination address space area base address.
+ * @param dst    Address of the storage for the destination address space area
+ *               base address.
  *
  * @return Zero on success or a value from @ref errno.h on failure.

uspace/lib/c/generic/device/hw_res_parsed.c

@@ -221 +221 @@
         hw_resource_list_t hw_resources;
         hw_res_list_parsed_clean(hw_res_parsed);
-        bzero(&hw_resources, sizeof(hw_resource_list_t));
+        memset(&hw_resources, 0, sizeof(hw_resource_list_t));
         
         int rc = hw_res_get_resource_list(sess, &hw_resources);

uspace/lib/c/generic/io/con_srv.c

@@ -35 +35 @@
  */
 #include <errno.h>
+#include <io/cons_event.h>
 #include <ipc/console.h>
 #include <stdlib.h>
@@ -40 +41 @@
 
 #include <io/con_srv.h>
+
+static int console_ev_encode(cons_event_t *event, ipc_call_t *call)
+{
+        IPC_SET_ARG1(*call, event->type);
+
+        switch (event->type) {
+        case CEV_KEY:
+                IPC_SET_ARG2(*call, event->ev.key.type);
+                IPC_SET_ARG3(*call, event->ev.key.key);
+                IPC_SET_ARG4(*call, event->ev.key.mods);
+                IPC_SET_ARG5(*call, event->ev.key.c);
+                break;
+        case CEV_POS:
+                IPC_SET_ARG2(*call, (event->ev.pos.pos_id << 16) | (event->ev.pos.type & 0xffff));
+                IPC_SET_ARG3(*call, event->ev.pos.btn_num);
+                IPC_SET_ARG4(*call, event->ev.pos.hpos);
+                IPC_SET_ARG5(*call, event->ev.pos.vpos);
+                break;
+        default:
+                return EIO;
+        }
+
+        return EOK;
+}
 
 static void con_read_srv(con_srv_t *srv, ipc_callid_t callid,
@@ -273 +298 @@
 {
         int rc;
-        kbd_event_t event;
+        cons_event_t event;
+        ipc_call_t result;
 
         if (srv->srvs->ops->get_event == NULL) {
@@ -281 +307 @@
 
         rc = srv->srvs->ops->get_event(srv, &event);
-        async_answer_4(callid, rc, event.type, event.key, event.mods, event.c);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        rc = console_ev_encode(&event, &result);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+
+        async_answer_5(callid, rc, IPC_GET_ARG1(result), IPC_GET_ARG2(result),
+            IPC_GET_ARG3(result), IPC_GET_ARG4(result), IPC_GET_ARG5(result));
 }
 

uspace/lib/c/generic/io/console.c

@@ -154 +154 @@
 }
 
-bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
+static int console_ev_decode(ipc_call_t *call, cons_event_t *event)
+{
+        event->type = IPC_GET_ARG1(*call);
+
+        switch (event->type) {
+        case CEV_KEY:
+                event->ev.key.type = IPC_GET_ARG2(*call);
+                event->ev.key.key = IPC_GET_ARG3(*call);
+                event->ev.key.mods = IPC_GET_ARG4(*call);
+                event->ev.key.c = IPC_GET_ARG5(*call);
+                break;
+        case CEV_POS:
+                event->ev.pos.pos_id = IPC_GET_ARG2(*call) >> 16;
+                event->ev.pos.type = IPC_GET_ARG2(*call) & 0xffff;
+                event->ev.pos.btn_num = IPC_GET_ARG3(*call);
+                event->ev.pos.hpos = IPC_GET_ARG4(*call);
+                event->ev.pos.vpos = IPC_GET_ARG5(*call);
+                break;
+        default:
+                return EIO;
+        }
+
+        return EOK;
+}
+
+bool console_get_event(console_ctrl_t *ctrl, cons_event_t *event)
 {
         if (ctrl->input_aid == 0) {
-                sysarg_t type;
-                sysarg_t key;
-                sysarg_t mods;
-                sysarg_t c;
+                ipc_call_t result;
                 
                 async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
-                int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
+                aid_t aid = async_send_0(exch, CONSOLE_GET_EVENT, &result);
                 async_exchange_end(exch);
+                
+                sysarg_t rc;
+                async_wait_for(aid, &rc);
                 
                 if (rc != EOK) {
@@ -171 +196 @@
                 }
                 
-                event->type = type;
-                event->key = key;
-                event->mods = mods;
-                event->c = c;
+                rc = console_ev_decode(&result, event);
+                if (rc != EOK) {
+                        errno = rc;
+                        return false;
+                }
         } else {
                 sysarg_t retval;
@@ -186 +212 @@
                 }
                 
-                event->type = IPC_GET_ARG1(ctrl->input_call);
-                event->key = IPC_GET_ARG2(ctrl->input_call);
-                event->mods = IPC_GET_ARG3(ctrl->input_call);
-                event->c = IPC_GET_ARG4(ctrl->input_call);
+                int rc = console_ev_decode(&ctrl->input_call, event);
+                if (rc != EOK) {
+                        errno = rc;
+                        return false;
+                }
         }
         
@@ -195 +222 @@
 }
 
-bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
+bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
     suseconds_t *timeout)
 {
@@ -223 +250 @@
         }
         
-        event->type = IPC_GET_ARG1(ctrl->input_call);
-        event->key = IPC_GET_ARG2(ctrl->input_call);
-        event->mods = IPC_GET_ARG3(ctrl->input_call);
-        event->c = IPC_GET_ARG4(ctrl->input_call);
+        rc = console_ev_decode(&ctrl->input_call, event);
+        if (rc != EOK) {
+                errno = rc;
+                return false;
+        }
         
         /* Update timeout */

uspace/lib/c/generic/mem.c

@@ -224 +224 @@
  * @param s1  Pointer to the first area to compare.
  * @param s2  Pointer to the second area to compare.
- * @param len Size of the first area in bytes. Both areas must have
- *            the same length.
- *
- * @return If len is 0, return zero. If the areas match, return
- *         zero. Otherwise return non-zero.
- *
- */
-int bcmp(const void *s1, const void *s2, size_t len)
+ * @param len Size of the areas in bytes.
+ *
+ * @return Zero if areas have the same contents. If they differ,
+ *         the sign of the result is the same as the sign of the
+ *         difference of the first pair of different bytes.
+ *
+ */
+int memcmp(const void *s1, const void *s2, size_t len)
 {
         uint8_t *u1 = (uint8_t *) s1;
         uint8_t *u2 = (uint8_t *) s2;
-        
-        for (; (len != 0) && (*u1++ == *u2++); len--);
-        
-        return len;
+        size_t i;
+
+        for (i = 0; i < len; i++) {
+                if (*u1 != *u2)
+                        return (int)(*u1) - (int)(*u2);
+                ++u1;
+                ++u2;
+        }
+
+        return 0;
 }
 

uspace/lib/c/generic/net/inet.c

@@ -144 +144 @@
         /* Erase if no address */
         if (!address) {
-                bzero(data, count);
+                memset(data, 0, count);
                 return ENOENT;
         }
@@ -181 +181 @@
                 } else {
                         /* Erase the rest of the address */
-                        bzero(data + index, count - index);
+                        memset(data + index, 0, count - index);
                         return EOK;
                 }

uspace/lib/c/generic/net/socket_client.c

@@ -446 +446 @@
                 return ENOMEM;
 
-        bzero(socket, sizeof(*socket));
+        memset(socket, 0, sizeof(*socket));
         fibril_rwlock_write_lock(&socket_globals.lock);
 
@@ -657 +657 @@
                 return ENOMEM;
         }
-        bzero(new_socket, sizeof(*new_socket));
+        memset(new_socket, 0, sizeof(*new_socket));
         socket_id = socket_generate_new_id();
         if (socket_id <= 0) {