Changeset da68871a in mainline for uspace/srv

Timestamp:

2012-08-08T08:46:22Z (14 years ago)

Author:

Adam Hraska <adam.hraska+hos@…>

Branches:

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

Children:

30c0826

Parents:

bc216a0 (diff), 1d01cca (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:

Merged changes from mainline.

Location:

uspace/srv

Files:

• bd/sata_bd/Makefile (added)
• bd/sata_bd/sata_bd.c (added)
• bd/sata_bd/sata_bd.h (added)
• devman/main.c (modified) (1 diff)
• hid/console/console.c (modified) (3 diffs)
• hid/input/port/ns16550.c (modified) (1 diff)
• hid/input/port/pl050.c (modified) (1 diff)
• hw/bus/cuda_adb/cuda_adb.c (modified) (1 diff)
• loader/Makefile (modified) (1 diff)
• loader/interp.S (added)
• loader/interp.s (deleted)
• net/tcp/sock.c (modified) (4 diffs)

uspace/srv/devman/main.c

@@ -419 +419 @@
         
         /* Check that function with same name is not there already. */
-        if (find_fun_node_in_device(tree, pdev, fun_name) != NULL) {
+        fun_node_t *tfun = find_fun_node_in_device(tree, pdev, fun_name);
+        if (tfun) {
+                fun_del_ref(tfun);      /* drop the new unwanted reference */
                 fibril_rwlock_write_unlock(&tree->rwlock);
                 dev_del_ref(pdev);

uspace/srv/hid/console/console.c

@@ -76 +76 @@
 } console_state_t;
 
+#define UTF8_CHAR_BUFFER_SIZE (STR_BOUNDS(1) + 1)
+
 typedef struct {
         atomic_t refcnt;           /**< Connection reference count */
         prodcons_t input_pc;       /**< Incoming keyboard events */
+        char char_remains[UTF8_CHAR_BUFFER_SIZE]; /**< Not yet sent bytes of last char event. */
+        size_t char_remains_len;   /**< Number of not yet sent bytes. */
         
         fibril_mutex_t mtx;        /**< Lock protecting mutable fields */
@@ -613 +617 @@
         
         size_t pos = 0;
+        
+        /*
+         * Read input from keyboard and copy it to the buffer.
+         * We need to handle situation when wchar is split by 2 following
+         * reads.
+         */
         while (pos < size) {
-                link_t *link = prodcons_consume(&cons->input_pc);
-                kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
-                
-                if (event->type == KEY_PRESS) {
-                        buf[pos] = event->c;
+                /* Copy to the buffer remaining characters. */
+                while ((pos < size) && (cons->char_remains_len > 0)) {
+                        buf[pos] = cons->char_remains[0];
                         pos++;
-                }
-                
-                free(event);
+                        
+                        /* Unshift the array. */
+                        for (size_t i = 1; i < cons->char_remains_len; i++)
+                                cons->char_remains[i - 1] = cons->char_remains[i];
+                        
+                        cons->char_remains_len--;
+                }
+                
+                /* Still not enough? Then get another key from the queue. */
+                if (pos < size) {
+                        link_t *link = prodcons_consume(&cons->input_pc);
+                        kbd_event_t *event = list_get_instance(link, kbd_event_t, link);
+                        
+                        /* Accept key presses of printable chars only. */
+                        if ((event->type == KEY_PRESS) && (event->c != 0)) {
+                                wchar_t tmp[2] = { event->c, 0 };
+                                wstr_to_str(cons->char_remains, UTF8_CHAR_BUFFER_SIZE, tmp);
+                                cons->char_remains_len = str_size(cons->char_remains);
+                        }
+                        
+                        free(event);
+                }
         }
         
@@ -930 +957 @@
                 fibril_mutex_initialize(&consoles[i].mtx);
                 prodcons_initialize(&consoles[i].input_pc);
+                consoles[i].char_remains_len = 0;
                 
                 if (graphics_state == GRAPHICS_FULL) {

uspace/srv/hid/input/port/ns16550.c

@@ -84 +84 @@
         },
         {
-                .cmd = CMD_BTEST,
+                .cmd = CMD_AND,
                 .value = LSR_DATA_READY,
                 .srcarg = 1,

uspace/srv/hid/input/port/pl050.c

@@ -80 +80 @@
         },
         {
-                .cmd = CMD_BTEST,
+                .cmd = CMD_AND,
                 .value = PL050_STAT_RXFULL,
                 .srcarg = 1,

uspace/srv/hw/bus/cuda_adb/cuda_adb.c

@@ -116 +116 @@
         {
                 .cmd = CMD_PIO_READ_8,
-                .addr = NULL,   /* will be patched in run-time */
+                .addr = NULL,
                 .dstarg = 1
         },
         {
-                .cmd = CMD_BTEST,
+                .cmd = CMD_AND,
                 .value = SR_INT,
                 .srcarg = 1,

uspace/srv/loader/Makefile

@@ -44 +44 @@
 GENERIC_SOURCES = \
         main.c \
-        interp.s
+        interp.S
 
 SOURCES = \

uspace/srv/net/tcp/sock.c

@@ -779 +779 @@
         }
 
+        /* Grab recv_buffer_lock because of CV wait in tcp_sock_recv_fibril() */
+        fibril_mutex_lock(&socket->recv_buffer_lock);
+        socket->sock_core = NULL;
+        fibril_mutex_unlock(&socket->recv_buffer_lock);
+
         rc = socket_destroy(NULL, socket_id, &client->sockets, &gsock,
             tcp_free_sock_data);
@@ -839 +844 @@
         log_msg(LVL_DEBUG, "tcp_sock_recv_fibril()");
 
+        fibril_mutex_lock(&sock->recv_buffer_lock);
+
         while (true) {
                 log_msg(LVL_DEBUG, "call tcp_uc_receive()");
-                fibril_mutex_lock(&sock->recv_buffer_lock);
-                while (sock->recv_buffer_used != 0)
+                while (sock->recv_buffer_used != 0 && sock->sock_core != NULL)
                         fibril_condvar_wait(&sock->recv_buffer_cv,
                             &sock->recv_buffer_lock);
@@ -852 +858 @@
                         sock->recv_error = trc;
                         fibril_condvar_broadcast(&sock->recv_buffer_cv);
-                        fibril_mutex_unlock(&sock->recv_buffer_lock);
-                        tcp_sock_notify_data(sock->sock_core);
+                        if (sock->sock_core != NULL)
+                                tcp_sock_notify_data(sock->sock_core);
                         break;
                 }
@@ -861 +867 @@
                 sock->recv_buffer_used = data_len;
                 fibril_condvar_broadcast(&sock->recv_buffer_cv);
-                fibril_mutex_unlock(&sock->recv_buffer_lock);
-                tcp_sock_notify_data(sock->sock_core);
-        }
+                if (sock->sock_core != NULL)
+                        tcp_sock_notify_data(sock->sock_core);
+        }
+
+        fibril_mutex_unlock(&sock->recv_buffer_lock);
 
         tcp_uc_delete(sock->conn);