Changeset 085bd54 in mainline

Timestamp:

2006-06-06T15:16:08Z (18 years ago)

Author:

Ondrej Palkovsky <ondrap@…>

Branches:

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

Children:

63bb83e

Parents:

d7eafd8

Message:

Revised ipc. Now it is preferrable to use only functions from async.h, they
take care of correct buffering, waiting for answers etc.

Files:

• console/console.c (modified) (17 diffs)
• console/gcons.c (modified) (8 diffs)
• fb/fb.c (modified) (1 diff)
• fb/helenos.xbm (deleted)
• kbd/generic/kbd.c (modified) (3 diffs)
• klog/klog.c (modified) (1 diff)
• libc/generic/async.c (modified) (15 diffs)
• libc/generic/io/stream.c (modified) (4 diffs)
• libc/generic/ipc.c (modified) (1 diff)
• libc/generic/psthread.c (modified) (11 diffs)
• libc/include/async.h (modified) (4 diffs)
• libc/include/ipc/ipc.h (modified) (1 diff)
• libc/include/psthread.h (modified) (2 diffs)
• tetris/screen.c (modified) (6 diffs)

console/console.c

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+/* TODO: remove */
+#include <stdio.h>
 
 
@@ -92 +94 @@
 static void clrscr(void)
 {
-        nsend_call(fb_info.phone, FB_CLEAR, 0);
+        async_msg(fb_info.phone, FB_CLEAR, 0);
 }
 
 static void curs_visibility(int v)
 {
-        send_call(fb_info.phone, FB_CURSOR_VISIBILITY, v); 
+        async_msg(fb_info.phone, FB_CURSOR_VISIBILITY, v); 
 }
 
 static void curs_goto(int row, int col)
 {
-        nsend_call_2(fb_info.phone, FB_CURSOR_GOTO, row, col); 
+        async_msg_2(fb_info.phone, FB_CURSOR_GOTO, row, col); 
         
 }
@@ -108 +110 @@
 static void set_style(style_t *style)
 {
-        nsend_call_2(fb_info.phone, FB_SET_STYLE, style->fg_color, style->bg_color); 
+        async_msg_2(fb_info.phone, FB_SET_STYLE, style->fg_color, style->bg_color); 
 }
 
 static void set_style_col(int fgcolor, int bgcolor)
 {
-        nsend_call_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor); 
+        async_msg_2(fb_info.phone, FB_SET_STYLE, fgcolor, bgcolor); 
 }
 
 static void prtchr(char c, int row, int col)
 {
-        nsend_call_3(fb_info.phone, FB_PUTCHAR, c, row, col);
+        async_msg_3(fb_info.phone, FB_PUTCHAR, c, row, col);
         
 }
@@ -166 +168 @@
                 screenbuffer_clear_line(scr, scr->top_line++);
                 if (console == active_console)
-                        nsend_call(fb_info.phone, FB_SCROLL, 1);
+                        async_msg(fb_info.phone, FB_SCROLL, 1);
         }
         
@@ -186 +188 @@
        
         /* Save screen */
-        newpmap = sync_send(fb_info.phone, FB_VP2PIXMAP, 0, NULL);
+        newpmap = async_req(fb_info.phone, FB_VP2PIXMAP, 0, NULL);
         if (newpmap < 0)
                 return -1;
@@ -192 +194 @@
         if (oldpixmap != -1) {
                 /* Show old screen */
-                nsend_call_2(fb_info.phone, FB_VP_DRAW_PIXMAP, 0, oldpixmap);
+                async_msg_2(fb_info.phone, FB_VP_DRAW_PIXMAP, 0, oldpixmap);
                 /* Drop old pixmap */
-                nsend_call(fb_info.phone, FB_DROP_PIXMAP, oldpixmap);
+                async_msg(fb_info.phone, FB_DROP_PIXMAP, oldpixmap);
         }
         
@@ -237 +239 @@
                 console_pixmap = -1;
         }
-        
         active_console = newcons;
         gcons_change_console(newcons);
@@ -245 +246 @@
         curs_goto(conn->screenbuffer.position_y, conn->screenbuffer.position_x);
         curs_visibility(0);
-        
         if (interbuffer) {
                 for (i = 0; i < conn->screenbuffer.size_x; i++)
@@ -251 +251 @@
                                 interbuffer[i + j*conn->screenbuffer.size_x] = *get_field_at(&(conn->screenbuffer),i, j);
                 /* This call can preempt, but we are already at the end */
-                j = sync_send_2(fb_info.phone, FB_DRAW_TEXT_DATA, 0, 0, NULL, NULL);            
+                j = async_req_2(fb_info.phone, FB_DRAW_TEXT_DATA, 0, 0, NULL, NULL);            
         };
         
@@ -302 +302 @@
 //                      if ((c >= KBD_KEY_F1) && (c < KBD_KEY_F1 + CONSOLE_COUNT)) {
                         if ((c >= 0x101) && (c < 0x101 + CONSOLE_COUNT)) {
+                                async_serialize_start();
                                 if (c == 0x112)
                                         change_console(KERNEL_CONSOLE);
                                 else
                                         change_console(c - 0x101);
+                                async_serialize_end();
                                 break;
                         }
@@ -322 +324 @@
                 default:
                         retval = ENOENT;
-                }               
+                }
                 ipc_answer_fast(callid, retval, 0, 0);
         }
@@ -341 +343 @@
         }
         conn = &connections[consnum];
-        
+        conn->used = 1;
+        
+        async_serialize_start();
         gcons_notify_connect(consnum);
-        conn->used = 1;
         conn->client_phone = IPC_GET_ARG3(call);
         screenbuffer_clear(&conn->screenbuffer);
@@ -349 +352 @@
         /* Accept the connection */
         ipc_answer_fast(iid,0,0,0);
-        
+
         while (1) {
+                async_serialize_end();
                 callid = async_get_call(&call);
+                async_serialize_start();
+
                 arg1 = arg2 = 0;
                 switch (IPC_GET_METHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         gcons_notify_disconnect(consnum);
+                        
                         /* Answer all pending requests */
                         while (conn->keyrequest_counter > 0) {          
@@ -365 +372 @@
                         /* Commit hangup */
                         ipc_answer_fast(callid, 0,0,0);
+                        async_serialize_end();
                         return;
                 case CONSOLE_PUTCHAR:
@@ -373 +381 @@
                         /* Send message to fb */
                         if (consnum == active_console) {
-                                send_call(fb_info.phone, FB_CLEAR, 0); 
+                                async_msg(fb_info.phone, FB_CLEAR, 0); 
                         }
                         
@@ -392 +400 @@
                         break;
                 case CONSOLE_FLUSH:
-                        sync_send_2(fb_info.phone, FB_FLUSH, 0, 0, NULL, NULL);         
+                        async_req_2(fb_info.phone, FB_FLUSH, 0, 0, NULL, NULL);         
                         break;
                 case CONSOLE_SET_STYLE:
@@ -460 +468 @@
         gcons_init(fb_info.phone);
         /* Synchronize, the gcons can have something in queue */
-        sync_send(fb_info.phone, FB_FLUSH, 0, NULL);
+        async_req(fb_info.phone, FB_FLUSH, 0, NULL);
 
         

console/gcons.c

@@ -76 +76 @@
 static void vp_switch(int vp)
 {
-        nsend_call(fbphone,FB_VIEWPORT_SWITCH, vp);
+        async_msg(fbphone,FB_VIEWPORT_SWITCH, vp);
 }
 
@@ -91 +91 @@
 static void clear(void)
 {
-        nsend_call(fbphone, FB_CLEAR, 0);
+        async_msg(fbphone, FB_CLEAR, 0);
         
 }
@@ -97 +97 @@
 static void set_style(int fgcolor, int bgcolor)
 {
-        nsend_call_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
+        async_msg_2(fbphone, FB_SET_STYLE, fgcolor, bgcolor);
 }
 
@@ -103 +103 @@
 static void tran_putch(char c, int row, int col)
 {
-        nsend_call_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
+        async_msg_3(fbphone, FB_TRANS_PUTCHAR, c, row, col);
 }
 
@@ -115 +115 @@
         vp_switch(cstatus_vp[consnum]);
         if (ic_pixmaps[state] != -1)
-                nsend_call_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);
+                async_msg_2(fbphone, FB_VP_DRAW_PIXMAP, cstatus_vp[consnum], ic_pixmaps[state]);
 
         if (state != CONS_DISCONNECTED && state != CONS_KERNEL && state != CONS_DISCONNECTED_SEL) {
@@ -239 +239 @@
         memcpy(shm, logo, size);
         /* Send area */
-        rc = sync_send_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
+        rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
         if (rc)
                 goto exit;
-        rc = sync_send_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
+        rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
         if (rc)
                 goto drop;
         /* Draw logo */
-        nsend_call_2(fbphone, FB_DRAW_PPM, x, y);
+        async_msg_2(fbphone, FB_DRAW_PPM, x, y);
 drop:
         /* Drop area */
-        nsend_call(fbphone, FB_DROP_SHM, 0);
+        async_msg(fbphone, FB_DROP_SHM, 0);
 exit:       
         /* Remove area */
@@ -298 +298 @@
         memcpy(shm, data, size);
         /* Send area */
-        rc = sync_send_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
+        rc = async_req_2(fbphone, FB_PREPARE_SHM, (ipcarg_t)shm, 0, NULL, NULL);
         if (rc)
                 goto exit;
-        rc = sync_send_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
+        rc = async_req_3(fbphone, IPC_M_AS_AREA_SEND, (ipcarg_t)shm, 0, PROTO_READ, NULL, NULL, NULL);
         if (rc)
                 goto drop;
 
         /* Obtain pixmap */
-        rc = sync_send(fbphone, FB_SHM2PIXMAP, 0, NULL);
+        rc = async_req(fbphone, FB_SHM2PIXMAP, 0, NULL);
         if (rc < 0)
                 goto drop;
@@ -312 +312 @@
 drop:
         /* Drop area */
-        nsend_call(fbphone, FB_DROP_SHM, 0);
+        async_msg(fbphone, FB_DROP_SHM, 0);
 exit:       
         /* Remove area */

fb/fb.c

@@ -43 +43 @@
 
 #include "font-8x16.h"
-#include "helenos.xbm"
 #include "fb.h"
 #include "main.h"

kbd/generic/kbd.c

@@ -39 +39 @@
 #include <libadt/fifo.h>
 #include <key_buffer.h>
+#include <async.h>
 
 #define NAME "KBD"
+
+int cons_connected = 0;
+int phone2cons = -1;
+keybuffer_t keybuffer;  
+
+static void irq_handler(ipc_callid_t iid, ipc_call_t *call)
+{
+        int chr;
+        
+        if (cons_connected && phone2cons != -1) {
+                /* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */
+                kbd_arch_process(&keybuffer, IPC_GET_ARG2(*call));
+                
+                while (!keybuffer_empty(&keybuffer)) {
+                        if (!keybuffer_pop(&keybuffer, (int *)&chr))
+                                break;
+
+                        async_msg(phone2cons, KBD_PUSHCHAR, chr);
+                }
+        }
+}
+
+static void console_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        ipc_call_t call;
+        int retval;
+
+        if (cons_connected) {
+                ipc_answer_fast(iid, ELIMIT, 0, 0);
+                return;
+        }
+        cons_connected = 1;
+        ipc_answer_fast(iid, 0, 0, 0);
+
+        while (1) {
+                callid = async_get_call(&call);
+                switch (IPC_GET_METHOD(call)) {
+                case IPC_M_PHONE_HUNGUP:
+                        cons_connected = 0;
+                        ipc_hangup(phone2cons);
+                        phone2cons = -1;
+                        ipc_answer_fast(callid, 0,0,0);
+                        return;
+                case IPC_M_CONNECT_TO_ME:
+                        if (phone2cons != -1) {
+                                retval = ELIMIT;
+                                break;
+                        }
+                        phone2cons = IPC_GET_ARG3(call);
+                        retval = 0;
+                        break;
+                }
+                ipc_answer_fast(callid, retval, 0, 0);
+        }       
+}
+
 
 int main(int argc, char **argv)
@@ -50 +108 @@
         ipcarg_t phoneid;
         char connected = 0;
-        keybuffer_t keybuffer;  
         ipcarg_t retval, arg1, arg2;
-        
-        //open("null",0);
-        //open("stdout",0);
         
         /* Initialize arch dependent parts */
@@ -68 +122 @@
         if ((res = ipc_connect_to_me(PHONE_NS, SERVICE_KEYBOARD, 0, &phonead)) != 0) {
                 return -1;
-        };
-        while (1) {
-                callid = ipc_wait_for_call(&call);
-                switch (IPC_GET_METHOD(call)) {
-                        case IPC_M_PHONE_HUNGUP:
-                                connected = 0;
-                                retval = 0;
-                                break;
-                        case IPC_M_CONNECT_ME_TO:
-                                /* Only one connected client allowed */
-                                if (connected) {
-                                        retval = ELIMIT;
-                                } else {
-                                        retval = 0;
-                                        connected = 1;
-                                }
-                                break;
-                        case IPC_M_CONNECT_TO_ME:
-                                phoneid = IPC_GET_ARG3(call);
-                                retval = 0;
-                                break;
+        }
 
-                        case IPC_M_INTERRUPT:
-                                if (connected) {
-                                        int chr;
-                                        /* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */
-                                        kbd_arch_process(&keybuffer, IPC_GET_ARG2(call));
+        async_set_client_connection(console_connection);
+        async_set_interrupt_received(irq_handler);
+        async_manager();
 
-                                        retval = 0;
-                                        
-
-                                        while (!keybuffer_empty(&keybuffer)) {
-                                                if (!keybuffer_pop(&keybuffer, (int *)&chr)) {
-                                                        break;
-                                                }
-                                                {
-                                                        arg1=chr;
-                                                        send_call(phoneid, KBD_PUSHCHAR, arg1);
-                                                }    
-                                        }
-
-                                }
-                                break;
-                        default:
-                                retval = ENOENT;
-                                break;
-                }
-
-                if (! (callid & IPC_CALLID_NOTIFICATION)) {
-                        ipc_answer_fast(callid, retval, arg1, arg2);
-                }
-        }
 }
-

klog/klog.c

@@ -41 +41 @@
         int i;
         
-//      psthread_serialize_start();
+        async_serialize_start();
         /* TODO: remove workaround around non-functional vsnprintf */
         for (i=0; klog[i + IPC_GET_ARG2(*call)] && i < IPC_GET_ARG3(*call); i++)
                 putchar(klog[i + IPC_GET_ARG2(*call)]);
         putchar('\n');
-//      psthread_serialize_done();
+        async_serialize_end();
 }
 

libc/generic/async.c

@@ -135 +135 @@
 } connection_t;
 
-
+/** Identifier of incoming connection handled by current thread */
 __thread connection_t *PS_connection;
+/** If true, it is forbidden to use async_req functions and
+ *  all preemption is disabled */
+__thread int in_interrupt_handler;
 
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
@@ -226 +229 @@
 
         wd->timedout = 0;
+        wd->inlist = 1;
 
         tmp = timeout_list.next;
@@ -295 +299 @@
         conn = PS_connection; 
 
-        if (usecs < 0) /* TODO: let it get through the ipc_call once */
-                return 0;
-
         futex_down(&async_futex);
 
@@ -308 +309 @@
         /* If nothing in queue, wait until something appears */
         while (list_empty(&conn->msg_queue)) {
-                if (usecs) {
-                        conn->wdata.inlist = 1;
+                if (usecs)
                         insert_timeout(&conn->wdata);
-                }
+
                 conn->wdata.active = 0;
                 psthread_schedule_next_adv(PS_TO_MANAGER);
@@ -363 +363 @@
         PS_connection = (connection_t *)arg;
         PS_connection->cthread(PS_connection->callid, &PS_connection->call);
-
         /* Remove myself from connection hash table */
         futex_down(&async_futex);
@@ -436 +435 @@
         switch (IPC_GET_METHOD(*call)) {
         case IPC_M_INTERRUPT:
+                in_interrupt_handler = 1;
                 (*interrupt_received)(callid,call);
+                in_interrupt_handler = 0;
                 return;
         case IPC_M_CONNECT_ME_TO:
@@ -486 +487 @@
 
 /** Endless loop dispatching incoming calls and answers */
-int async_manager(void)
+static int async_manager_worker(void)
 {
         ipc_call_t call;
@@ -522 +523 @@
                 }
 
-                if (callid & IPC_CALLID_ANSWERED)
+                if (callid & IPC_CALLID_ANSWERED) {
                         continue;
+                }
 
                 handle_call(callid, &call);
@@ -538 +540 @@
 static int async_manager_thread(void *arg)
 {
+        in_interrupt_handler = 0; // TODO: Handle TLS better
         futex_up(&async_futex); /* async_futex is always locked when entering
                                 * manager */
-        async_manager();
+        async_manager_worker();
 }
 
@@ -608 +611 @@
         amsg_t *msg;
 
+        if (in_interrupt_handler) {
+                printf("Cannot send asynchronou request in interrupt handler.\n");
+                _exit(1);
+        }
+
         msg = malloc(sizeof(*msg));
         msg->done = 0;
@@ -628 +636 @@
 {
         amsg_t *msg;
+
+        if (in_interrupt_handler) {
+                printf("Cannot send asynchronou request in interrupt handler.\n");
+                _exit(1);
+        }
 
         msg = malloc(sizeof(*msg));
@@ -699 +712 @@
         msg->wdata.ptid = psthread_get_id();
         msg->wdata.active = 0;
-        msg->wdata.inlist = 1;
-
         insert_timeout(&msg->wdata);
 
@@ -726 +737 @@
         amsg_t *msg;
         
+        if (in_interrupt_handler) {
+                printf("Cannot call async_usleep in interrupt handler.\n");
+                _exit(1);
+        }
+
         msg = malloc(sizeof(*msg));
         if (!msg)
@@ -731 +747 @@
 
         msg->wdata.ptid = psthread_get_id();
-        msg->wdata.inlist = 1;
         msg->wdata.active = 0;
 
@@ -757 +772 @@
         interrupt_received = conn;
 }
+
+/* Primitive functions for simple communication */
+void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
+                 ipcarg_t arg2, ipcarg_t arg3)
+{
+        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, !in_interrupt_handler);
+}
+
+void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
+{
+        ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, !in_interrupt_handler);
+}

libc/generic/io/stream.c

@@ -65 +65 @@
 
         while (i < count) {
-                if (sync_send_2(streams[0].phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {
+                if (async_req_2(streams[0].phone, CONSOLE_GETCHAR, 0, 0, &r0, &r1) < 0) {
                         return -1;
                 }
@@ -79 +79 @@
 
         for (i = 0; i < count; i++)
-                send_call(streams[1].phone, CONSOLE_PUTCHAR, ((const char *)buf)[i]);
+                async_msg(streams[1].phone, CONSOLE_PUTCHAR, ((const char *)buf)[i]);
         
         return count;
@@ -131 +131 @@
 {
         int c = 0;
-        
+
         while (((streams[c].w) || (streams[c].r)) && (c < FDS))
                 c++;
@@ -160 +160 @@
 ssize_t write(int fd, const void *buf, size_t count)
 {
+//      __SYSCALL3(SYS_IO, 1, (sysarg_t)buf, (sysarg_t) count);
+//      return count;
         if (fd < FDS)
                 return streams[fd].w(streams[fd].param, buf, count);

libc/generic/ipc.c

@@ -438 +438 @@
 }
 
-/* Primitive functions for simple communication */
-void send_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
-                 ipcarg_t arg2, ipcarg_t arg3)
-{
-        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, 1);
-}
-
-void send_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
-{
-        ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, 1);
-}
-
-void nsend_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
-                  ipcarg_t arg2, ipcarg_t arg3)
-{
-        ipc_call_async_3(phoneid, method, arg1, arg2, arg3, NULL, NULL, 0);
-}
-
-void nsend_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2)
-{
-        ipc_call_async_2(phoneid, method, arg1, arg2, NULL, NULL, 0);
-}
-

libc/generic/psthread.c

@@ -43 +43 @@
 
 static LIST_INITIALIZE(ready_list);
+static LIST_INITIALIZE(serialized_list);
 static LIST_INITIALIZE(manager_list);
 
@@ -49 +50 @@
 
 static atomic_t psthread_futex = FUTEX_INITIALIZER;
+/** Count of real threads that are in async_serialized mode */
+static int serialized_threads; /* Protected by async_futex */
+/** Thread-local count of serialization. If >0, we must not preempt */
+static __thread serialization_count;
+/** Counter of threads residing in async_manager */
+static int threads_in_manager;
 
 /** Setup PSthread information into TCB structure */
@@ -78 +85 @@
 }
 
-/** Function to preempt to other pseudo thread without adding
- * currently running pseudo thread to ready_list.
- */
-void psthread_exit(void)
-{
-        psthread_data_t *pt;
-
-        futex_down(&psthread_futex);
-
-        if (!list_empty(&ready_list))
-                pt = list_get_instance(ready_list.next, psthread_data_t, link);
-        else if (!list_empty(&manager_list)) 
-                pt = list_get_instance(manager_list.next, psthread_data_t, link);
-        else {
-                printf("Cannot find suitable psthread to run.\n");
-                _exit(0);
-        }
-        list_remove(&pt->link);
-        futex_up(&psthread_futex);
-
-        context_restore(&pt->ctx);
-        /* Never reached */
-}
-
 /** Function that is called on entry to new uspace thread */
 void psthread_main(void)
@@ -107 +90 @@
         psthread_data_t *pt = __tcb_get()->pst_data;
 
+        serialization_count = 0; // TODO: WHY HERE?
         pt->retval = pt->func(pt->arg);
 
@@ -113 +97 @@
                 list_append(&pt->waiter->link, &ready_list);
 
-        psthread_exit();
+        psthread_schedule_next_adv(PS_FROM_DEAD);
 }
 
@@ -128 +112 @@
 int psthread_schedule_next_adv(pschange_type ctype)
 {
-        psthread_data_t *pt;
+        psthread_data_t *srcpt, *dstpt;
         int retval = 0;
         
@@ -136 +120 @@
                 goto ret_0;
 
-        if (ctype == PS_FROM_MANAGER && list_empty(&ready_list)) {
-                goto ret_0;
+        if (ctype == PS_FROM_MANAGER) {
+                if (list_empty(&ready_list) && list_empty(&serialized_list))
+                        goto ret_0;
+                /* Do not preempt if there is not sufficient count of thread managers */
+                if (list_empty(&serialized_list) && threads_in_manager <= serialized_threads) {
+                        goto ret_0;
+                }
         }
         /* If we are going to manager and none exists, create it */
-        while (ctype == PS_TO_MANAGER && list_empty(&manager_list)) {
-                futex_up(&psthread_futex);
-                async_create_manager();
-                futex_down(&psthread_futex);
-        }
-
-        pt = __tcb_get()->pst_data;
-        if (!context_save(&pt->ctx)) 
-                return 1; // futex_up already done here
-
-        if (ctype == PS_PREEMPT)
-                list_append(&pt->link, &ready_list);
-        else if (ctype == PS_FROM_MANAGER)
-                list_append(&pt->link, &manager_list);
+        if (ctype == PS_TO_MANAGER || ctype == PS_FROM_DEAD) {
+                while (list_empty(&manager_list)) {
+                        futex_up(&psthread_futex);
+                        async_create_manager();
+                        futex_down(&psthread_futex);
+                }
+        }
         
-        if (ctype == PS_TO_MANAGER)
-                pt = list_get_instance(manager_list.next,psthread_data_t, link);
-        else
-                pt = list_get_instance(ready_list.next, psthread_data_t, link);
-        list_remove(&pt->link);
-
-        futex_up(&psthread_futex);
-        context_restore(&pt->ctx);
+        if (ctype != PS_FROM_DEAD) {
+                /* Save current state */
+                srcpt = __tcb_get()->pst_data;
+                if (!context_save(&srcpt->ctx)) {
+                        if (serialization_count)
+                                srcpt->flags &= ~PSTHREAD_SERIALIZED;
+                        return 1; // futex_up already done here
+                }
+
+                /* Save myself to correct run list */
+                if (ctype == PS_PREEMPT)
+                        list_append(&srcpt->link, &ready_list);
+                else if (ctype == PS_FROM_MANAGER) {
+                        list_append(&srcpt->link, &manager_list);
+                        threads_in_manager--;
+                } /* If ctype == PS_TO_MANAGER, don't save ourselves to any list, we should
+                   * already be somewhere, or we will be lost */
+        }
+
+        /* Choose new thread to run */
+        if (ctype == PS_TO_MANAGER || ctype == PS_FROM_DEAD) {
+                dstpt = list_get_instance(manager_list.next,psthread_data_t, link);
+                if (serialization_count && ctype == PS_TO_MANAGER) {
+                        serialized_threads++;
+                        srcpt->flags |= PSTHREAD_SERIALIZED;
+                }
+                threads_in_manager++;
+        } else {
+                if (!list_empty(&serialized_list)) {
+                        dstpt = list_get_instance(serialized_list.next, psthread_data_t, link);
+                        serialized_threads--;
+                } else
+                        dstpt = list_get_instance(ready_list.next, psthread_data_t, link);
+        }
+        list_remove(&dstpt->link);
+
+        futex_up(&psthread_futex);
+        context_restore(&dstpt->ctx);
 
 ret_0:
@@ -183 +195 @@
         pt = (psthread_data_t *) psthrid;
 
-        if (!pt->finished) {
-                mypt = __tcb_get()->pst_data;
-                if (context_save(&((psthread_data_t *) mypt)->ctx)) {
-                        pt->waiter = (psthread_data_t *) mypt;
-                        psthread_exit();
-                }
-        }
+        /* TODO */
+        printf("join unsupported\n");
+        _exit(1);
+
         retval = pt->retval;
 
@@ -224 +233 @@
         pt->finished = 0;
         pt->waiter = NULL;
+        pt->flags = 0;
 
         context_save(&pt->ctx);
@@ -239 +249 @@
         pt = (psthread_data_t *) psthrid;
         futex_down(&psthread_futex);
-        list_append(&pt->link, &ready_list);
+        if ((pt->flags & PSTHREAD_SERIALIZED))
+                list_append(&pt->link, &serialized_list);
+        else
+                list_append(&pt->link, &ready_list);
         futex_up(&psthread_futex);
 }
@@ -272 +285 @@
         return (pstid_t)__tcb_get()->pst_data;
 }
+
+/** Disable preemption 
+ *
+ * If the thread wants to send several message in row and does not want
+ * to be preempted, it should start async_serialize_start() in the beginning
+ * of communication and async_serialize_end() in the end. If it is a
+ * true multithreaded application, it should protect the communication channel
+ * by a futex as well. Interrupt messages will can still be preempted.
+ */
+void psthread_inc_sercount(void)
+{
+        serialization_count++;
+}
+
+void psthread_dec_sercount(void)
+{
+        serialization_count--;
+}

libc/include/async.h

@@ -38 +38 @@
 typedef void (*async_client_conn_t)(ipc_callid_t callid, ipc_call_t *call);
 
-int async_manager(void);
+static inline void async_manager(void)
+{
+        psthread_schedule_next_adv(PS_TO_MANAGER);
+}
+
 ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs);
 static inline ipc_callid_t async_get_call(ipc_call_t *data)
@@ -58 +62 @@
  * @return Return code of message
  */
-static inline ipcarg_t sync_send_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t *r1, ipcarg_t *r2)
+static inline ipcarg_t async_req_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t *r1, ipcarg_t *r2)
 {
         ipc_call_t result;
@@ -71 +75 @@
         return rc;
 }
-#define sync_send(phoneid, method, arg1, r1) sync_send_2(phoneid, method, arg1, 0, r1, 0)
+#define async_req(phoneid, method, arg1, r1) async_req_2(phoneid, method, arg1, 0, r1, 0)
 
-static inline ipcarg_t sync_send_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
+static inline ipcarg_t async_req_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
                                    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *r1, 
                                    ipcarg_t *r2, ipcarg_t *r3)
@@ -103 +107 @@
 
 
+/* Primitve functions for IPC communication */
+void async_msg_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, 
+                 ipcarg_t arg3);
+void async_msg_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2);
+#define async_msg(ph,m,a1) async_msg_2(ph,m,a1,0)
+
+static inline void async_serialize_start(void)
+{
+        psthread_inc_sercount();
+}
+static inline void async_serialize_end(void)
+{
+        psthread_dec_sercount();
+}
+
 extern atomic_t async_futex;
-
 #endif

libc/include/ipc/ipc.h

@@ -82 +82 @@
 extern int ipc_forward_fast(ipc_callid_t callid, int phoneid, int method, ipcarg_t arg1);
 
-
-/* Primitve functions for IPC communication */
-void send_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, 
-                 ipcarg_t arg3);
-void send_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2);
-#define send_call(ph,m,a1) send_call_2(ph,m,a1,0)
-/* These functions never preempt */
-void nsend_call_3(int phoneid, ipcarg_t method, ipcarg_t arg1,
-                  ipcarg_t arg2, ipcarg_t arg3);
-void nsend_call_2(int phoneid, ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2);
-#define nsend_call(ph,m,a1) nsend_call_2(ph,m,a1,0)
-
 #endif

libc/include/psthread.h

@@ -41 +41 @@
 #endif /* context_set */
 
+#define PSTHREAD_SERIALIZED   1
+
 typedef enum {
         PS_TO_MANAGER,
         PS_FROM_MANAGER,
-        PS_PREEMPT
+        PS_PREEMPT,
+        PS_FROM_DEAD
 } pschange_type;
 
@@ -76 +79 @@
 void psthread_remove_manager(void);
 pstid_t psthread_get_id(void);
+void psthread_inc_sercount(void);
+void psthread_dec_sercount(void);
 
 static inline int psthread_schedule_next() {

tetris/screen.c

@@ -81 +81 @@
 static void set_style(int fgcolor, int bgcolor)
 {
-        send_call_2(con_phone, CONSOLE_SET_STYLE, fgcolor, bgcolor);
+        async_msg_2(con_phone, CONSOLE_SET_STYLE, fgcolor, bgcolor);
 }
 
@@ -97 +97 @@
 void clear_screen(void)
 {
-        send_call(con_phone, CONSOLE_CLEAR, 0);
+        async_msg(con_phone, CONSOLE_CLEAR, 0);
         moveto(0,0);
 }
@@ -109 +109 @@
 
         resume_normal();
-        send_call(con_phone, CONSOLE_CLEAR, 0);
+        async_msg(con_phone, CONSOLE_CLEAR, 0);
         curscore = -1;
         memset((char *)curscreen, 0, sizeof(curscreen));
@@ -121 +121 @@
 {
         con_phone = get_fd_phone(1);
-        send_call(con_phone, CONSOLE_CURSOR_VISIBILITY, 0);
+        async_msg(con_phone, CONSOLE_CURSOR_VISIBILITY, 0);
         resume_normal();
         scr_clear();
@@ -128 +128 @@
 void moveto(int r, int c)
 {
-        send_call_2(con_phone, CONSOLE_GOTO, r, c);
+        async_msg_2(con_phone, CONSOLE_GOTO, r, c);
 }
 
 static void fflush(void)
 {
-        send_call(con_phone, CONSOLE_FLUSH, 0);
+        async_msg(con_phone, CONSOLE_FLUSH, 0);
 }
 
@@ -140 +140 @@
 static int get_display_size(winsize_t *ws)
 {
-        return sync_send_2(con_phone, CONSOLE_GETSIZE, 0, 0, &ws->ws_row, &ws->ws_col);
+        return async_req_2(con_phone, CONSOLE_GETSIZE, 0, 0, &ws->ws_row, &ws->ws_col);
 }