Changeset 06b0211b in mainline for uspace/lib/c/generic

Timestamp:

2013-04-29T11:29:45Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

aa2b32c

Parents:

ba4799a (diff), df956b9b (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) (6 diffs)
• fibril.c (modified) (5 diffs)
• net/socket_client.c (modified) (1 diff)
• tls.c (modified) (3 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

@@ -350 +350 @@
 static async_client_conn_t client_connection = default_client_connection;
 static async_interrupt_handler_t interrupt_received = default_interrupt_received;
+static size_t interrupt_handler_stksz = FIBRIL_DFLT_STK_SIZE;
 
 /** Setter for client_connection function pointer.
@@ -370 +371 @@
 {
         interrupt_received = intr;
+}
+
+/** Set the stack size for the interrupt handler notification fibrils.
+ *
+ * @param size Stack size in bytes.
+ */
+void async_set_interrupt_handler_stack_size(size_t size)
+{
+        interrupt_handler_stksz = size;
 }
 
@@ -587 +597 @@
         msg->call = *call;
         
-        fid_t fid = fibril_create(notification_fibril, msg);
+        fid_t fid = fibril_create_generic(notification_fibril, msg,
+            interrupt_handler_stksz);
         if (fid == 0) {
                 free(msg);
@@ -2057 +2068 @@
         
         async_sess_t *sess = exch->sess;
+        assert(sess != NULL);
         
         atomic_dec(&sess->refcnt);
@@ -2078 +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.
@@ -2206 +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/fibril.c

@@ -95 +95 @@
 fibril_t *fibril_setup(void)
 {
-        tcb_t *tcb = __make_tls();
+        tcb_t *tcb = tls_make();
         if (!tcb)
                 return NULL;
@@ -101 +101 @@
         fibril_t *fibril = malloc(sizeof(fibril_t));
         if (!fibril) {
-                __free_tls(tcb);
+                tls_free(tcb);
                 return NULL;
         }
@@ -122 +122 @@
 void fibril_teardown(fibril_t *fibril)
 {
-        __free_tls(fibril->tcb);
+        tls_free(fibril->tcb);
         free(fibril);
 }
@@ -256 +256 @@
  * @param func Implementing function of the new fibril.
  * @param arg Argument to pass to func.
+ * @param stksz Stack size in bytes.
  *
  * @return 0 on failure or TLS of the new fibril.
  *
  */
-fid_t fibril_create(int (*func)(void *), void *arg)
+fid_t fibril_create_generic(int (*func)(void *), void *arg, size_t stksz)
 {
         fibril_t *fibril;
@@ -268 +269 @@
                 return 0;
         
-        size_t stack_size = stack_size_get();
+        size_t stack_size = (stksz == FIBRIL_DFLT_STK_SIZE) ?
+            stack_size_get() : stksz;
         fibril->stack = as_area_create((void *) -1, stack_size,
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |

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

@@ -192 +192 @@
 /** Default thread for new connections.
  *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- * @param[in] arg       Local argument.
+ * @param[in] iid   The initial message identifier.
+ * @param[in] icall The initial message call structure.
+ * @param[in] arg   Local argument.
+ *
  */
 static void socket_connection(ipc_callid_t iid, ipc_call_t * icall, void *arg)
 {
-        ipc_callid_t callid;
-        ipc_call_t call;
-        socket_t *socket;
-        int rc;
-
-loop:
-        callid = async_get_call(&call);
-
-        switch (IPC_GET_IMETHOD(call)) {
-        case NET_SOCKET_RECEIVED:
-        case NET_SOCKET_ACCEPTED:
-        case NET_SOCKET_DATA_FRAGMENT_SIZE:
-                fibril_rwlock_read_lock(&socket_globals.lock);
-
-                /* Find the socket */
-                socket = sockets_find(socket_get_sockets(),
-                    SOCKET_GET_SOCKET_ID(call));
-                if (!socket) {
-                        rc = ENOTSOCK;
-                        fibril_rwlock_read_unlock(&socket_globals.lock);
-                        break;
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                
+                if (!IPC_GET_IMETHOD(call)) {
+                        async_answer_0(callid, 0);
+                        return;
                 }
+                
+                int rc;
                 
                 switch (IPC_GET_IMETHOD(call)) {
                 case NET_SOCKET_RECEIVED:
-                        fibril_mutex_lock(&socket->receive_lock);
-                        /* Push the number of received packet fragments */
-                        rc = dyn_fifo_push(&socket->received,
-                            SOCKET_GET_DATA_FRAGMENTS(call),
-                            SOCKET_MAX_RECEIVED_SIZE);
-                        if (rc == EOK) {
-                                /* Signal the received packet */
-                                fibril_condvar_signal(&socket->receive_signal);
+                case NET_SOCKET_ACCEPTED:
+                case NET_SOCKET_DATA_FRAGMENT_SIZE:
+                        fibril_rwlock_read_lock(&socket_globals.lock);
+                        
+                        /* Find the socket */
+                        socket_t *socket = sockets_find(socket_get_sockets(),
+                            SOCKET_GET_SOCKET_ID(call));
+                        if (!socket) {
+                                rc = ENOTSOCK;
+                                fibril_rwlock_read_unlock(&socket_globals.lock);
+                                break;
                         }
-                        fibril_mutex_unlock(&socket->receive_lock);
+                        
+                        switch (IPC_GET_IMETHOD(call)) {
+                        case NET_SOCKET_RECEIVED:
+                                fibril_mutex_lock(&socket->receive_lock);
+                                /* Push the number of received packet fragments */
+                                rc = dyn_fifo_push(&socket->received,
+                                    SOCKET_GET_DATA_FRAGMENTS(call),
+                                    SOCKET_MAX_RECEIVED_SIZE);
+                                if (rc == EOK) {
+                                        /* Signal the received packet */
+                                        fibril_condvar_signal(&socket->receive_signal);
+                                }
+                                fibril_mutex_unlock(&socket->receive_lock);
+                                break;
+                                
+                        case NET_SOCKET_ACCEPTED:
+                                /* Push the new socket identifier */
+                                fibril_mutex_lock(&socket->accept_lock);
+                                rc = dyn_fifo_push(&socket->accepted, 1,
+                                    SOCKET_MAX_ACCEPTED_SIZE);
+                                if (rc == EOK) {
+                                        /* Signal the accepted socket */
+                                        fibril_condvar_signal(&socket->accept_signal);
+                                }
+                                fibril_mutex_unlock(&socket->accept_lock);
+                                break;
+                        
+                        default:
+                                rc = ENOTSUP;
+                        }
+                        
+                        if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
+                            (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
+                            socket->data_fragment_size)) {
+                                fibril_rwlock_write_lock(&socket->sending_lock);
+                                
+                                /* Set the data fragment size */
+                                socket->data_fragment_size =
+                                    SOCKET_GET_DATA_FRAGMENT_SIZE(call);
+                                
+                                fibril_rwlock_write_unlock(&socket->sending_lock);
+                        }
+                        
+                        fibril_rwlock_read_unlock(&socket_globals.lock);
                         break;
-
-                case NET_SOCKET_ACCEPTED:
-                        /* Push the new socket identifier */
-                        fibril_mutex_lock(&socket->accept_lock);
-                        rc = dyn_fifo_push(&socket->accepted, 1,
-                            SOCKET_MAX_ACCEPTED_SIZE);
-                        if (rc == EOK) {
-                                /* Signal the accepted socket */
-                                fibril_condvar_signal(&socket->accept_signal);
-                        }
-                        fibril_mutex_unlock(&socket->accept_lock);
-                        break;
-
+                        
                 default:
                         rc = ENOTSUP;
                 }
-
-                if ((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0) &&
-                    (SOCKET_GET_DATA_FRAGMENT_SIZE(call) !=
-                    socket->data_fragment_size)) {
-                        fibril_rwlock_write_lock(&socket->sending_lock);
-
-                        /* Set the data fragment size */
-                        socket->data_fragment_size =
-                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
-
-                        fibril_rwlock_write_unlock(&socket->sending_lock);
-                }
-
-                fibril_rwlock_read_unlock(&socket_globals.lock);
-                break;
-
-        default:
-                rc = ENOTSUP;
-        }
-
-        async_answer_0(callid, (sysarg_t) rc);
-        goto loop;
+                
+                async_answer_0(callid, (sysarg_t) rc);
+        }
 }
 

uspace/lib/c/generic/tls.c

@@ -51 +51 @@
  * @return Pointer to TCB.
  */
-tcb_t *__make_tls(void)
+tcb_t *tls_make(void)
 {
         void *data;
@@ -57 +57 @@
         size_t tls_size = &_tbss_end - &_tdata_start;
         
-        tcb = __alloc_tls(&data, tls_size);
+        tcb = tls_alloc_arch(&data, tls_size);
         if (!tcb)
                 return NULL;
@@ -74 +74 @@
 }
 
-void __free_tls(tcb_t *tcb)
+void tls_free(tcb_t *tcb)
 {
         size_t tls_size = &_tbss_end - &_tdata_start;
-        __free_tls_arch(tcb, tls_size);
+        tls_free_arch(tcb, tls_size);
 }