!557 tty内添加一个存放lwp的链表，用于前后台切换

Merge pull request !557 from linzhenxing/rt-smart

components/drivers/tty/console.c

@@ -295,7 +295,14 @@ rt_err_t console_register(const char *name, struct rt_device *iodev)
     console->type = TTY_DRIVER_TYPE_CONSOLE;
     console->subtype = SERIAL_TYPE_NORMAL;
     console->driver = iodev;
+    console->head = rt_calloc(1, sizeof(struct tty_node));
+    if (!console->head)
+    {
+        return -RT_ENOMEM;
+    }
+    tty_initstack(console->head);
 
+    rt_spin_lock_init(&console->spinlock);
     console->pgrp = -1;
     console->session = -1;
     console->foreground = RT_NULL;

components/drivers/tty/include/tty.h

@@ -23,6 +23,15 @@
 #define current lwp_self()
 #define __DISABLED_CHAR '\0'
 
+struct tty_node
+{
+    struct rt_lwp *lwp;
+    struct tty_node *next;
+};
+
+void tty_initstack(struct tty_node *node);
+int tty_push(struct tty_node **head, struct rt_lwp *lwp);
+struct rt_lwp *tty_pop(struct tty_node **head, struct rt_lwp *target_lwp);
 /*
  * When a break, frame error, or parity error happens, these codes are
  * stuffed into the flags buffer.
@@ -139,11 +148,15 @@ struct tty_struct
 
     struct winsize winsize;
     struct termios init_termios;
-    struct rt_mutex mutex;
-
+#ifdef RT_USING_SMP
+    struct rt_spinlock spinlock;
+#else
+    rt_spinlock_t spinlock;
+#endif
     pid_t pgrp;
     pid_t session;
     struct rt_lwp *foreground;
+    struct tty_node *head;
 
     struct tty_ldisc *ldisc;
     void *disc_data;

components/drivers/tty/n_tty.c

@@ -534,6 +534,8 @@ static void __isig(int sig, struct tty_struct *tty)
     {
         if (sig == SIGTSTP)
         {
+            struct rt_lwp *old_lwp;
+            
             rt_memcpy(&old_termios, &(tty->init_termios), sizeof(struct termios));
             tty->init_termios = *new_termios;
             ld = tty->ldisc;
@@ -545,7 +547,8 @@ static void __isig(int sig, struct tty_struct *tty)
                 }
             }
             tty_sigaddset(&lwp->signal_mask, SIGTTOU);
-            tty->foreground = RT_NULL;  
+            old_lwp = tty_pop(&tty->head, RT_NULL);
+            tty->foreground = old_lwp;  
         }
         else
         {

components/drivers/tty/pty.c

@@ -341,7 +341,14 @@ static int ptmx_register(void)
 
     ptm_drv->type = TTY_DRIVER_TYPE_PTY;
     ptm_drv->subtype = PTY_TYPE_MASTER;
+    ptm_drv->head = rt_calloc(1, sizeof(struct tty_node));
+    if (!ptm_drv->head)
+    {
+        return -RT_ENOMEM;
+    }
+    tty_initstack(ptm_drv->head);
 
+    rt_spin_lock_init(&ptm_drv->spinlock);
     ptm_drv->pgrp = -1;
     ptm_drv->session = -1;
     ptm_drv->foreground = RT_NULL;

components/drivers/tty/tty.c

@@ -38,6 +38,93 @@ struct termios tty_std_termios = {  /* for the benefit of tty drivers  */
     .__c_ospeed = 38400
 };
 
+void tty_initstack(struct tty_node *node)
+{
+    node->lwp = RT_NULL;
+    node->next = node;
+}
+
+static struct tty_node tty_node_cache = { RT_NULL, RT_NULL };
+
+static struct tty_node *_tty_node_alloc(void)
+{
+    struct tty_node *node = tty_node_cache.next;
+
+    if (node == RT_NULL)
+    {
+        node = rt_calloc(1, sizeof(struct tty_node));
+    }
+    else
+    {
+        tty_node_cache.next = node->next;
+    }
+
+    return node;
+}
+
+static void _tty_node_free(struct tty_node *node)
+{
+    node->next = tty_node_cache.next;
+    tty_node_cache.next = node;
+}
+
+int tty_push(struct tty_node **head, struct rt_lwp *lwp)
+{
+    struct tty_node *node = _tty_node_alloc();
+
+    if (!node)
+    {
+        return -1;
+    }
+
+    node->lwp = lwp;
+    node->next = *head;
+    *head = node;
+
+    return 0;
+}
+
+struct rt_lwp *tty_pop(struct tty_node **head, struct rt_lwp *target_lwp)
+{
+    struct tty_node *node;
+    struct rt_lwp *lwp = RT_NULL;
+
+    if (!head || !*head)
+    {
+        return RT_NULL;
+    }
+
+    node = *head;
+
+    if (target_lwp != RT_NULL && node->lwp != target_lwp)
+    {
+        struct tty_node *prev = RT_NULL;
+
+        while (node != RT_NULL && node->lwp != target_lwp)
+        {
+            prev = node;
+            node = node->next;
+        }
+
+        if (node != RT_NULL)
+        {
+            /* prev is impossible equ RT_NULL */
+            prev->next = node->next;
+            lwp = target_lwp;
+            _tty_node_free(node);
+        }
+    }
+    else
+    {
+        lwp = (*head)->lwp;
+        *head = (*head)->next;
+        node->lwp = RT_NULL;
+        _tty_node_free(node);
+    }
+
+    return lwp;
+}
+
 rt_inline int tty_sigismember(lwp_sigset_t *set, int _sig)
 {
     unsigned long sig = _sig - 1;

components/lwp/lwp.c

@@ -1008,6 +1008,7 @@ void lwp_cleanup(struct rt_thread *tid)
 {
     rt_base_t level;
     struct rt_lwp *lwp;
+    struct tty_node *tty_head = RT_NULL;
 
     if (tid == NULL)
     {
@@ -1022,8 +1023,18 @@ void lwp_cleanup(struct rt_thread *tid)
     lwp_tid_put(tid->tid);
     rt_list_remove(&tid->sibling);
     rt_hw_interrupt_enable(level);
-    lwp_ref_dec(lwp);
-
+    if (lwp->tty != RT_NULL)
+    {
+        tty_head = lwp->tty->head;
+    }
+    if (!lwp_ref_dec(lwp))
+    {
+        if (tty_head)
+        {
+            tty_pop(&tty_head, lwp);
+        }
+    }
+    
     return;
 }
 
@@ -1097,6 +1108,7 @@ pid_t lwp_execve(char *filename, int debug, int argc, char **argv, char **envp)
     int bg = 0;
     struct process_aux *aux;
     int tid = 0;
+    int ret;
 
     if (filename == RT_NULL)
     {
@@ -1201,7 +1213,20 @@ pid_t lwp_execve(char *filename, int debug, int argc, char **argv, char **envp)
                 if (lwp->session == -1)
                 {
                     struct tty_struct *tty = RT_NULL;
+                    struct rt_lwp *old_lwp;
                     tty = (struct tty_struct *)console_tty_get();
+                    old_lwp = tty->foreground;
+                    rt_spin_lock(&tty->spinlock);
+                    ret = tty_push(&tty->head, old_lwp);
+                    rt_spin_unlock(&tty->spinlock);
+                    if (ret < 0)
+                    {
+                        lwp_tid_put(tid);
+                        lwp_ref_dec(lwp);
+                        LOG_E("malloc fail!\n");
+                        return -ENOMEM;
+                    }
+                    
                     lwp->tty = tty;
                     lwp->tty->pgrp = lwp->__pgrp;
                     lwp->tty->session = lwp->session;
@@ -1215,6 +1240,17 @@ pid_t lwp_execve(char *filename, int debug, int argc, char **argv, char **envp)
                 {
                     if (self_lwp != RT_NULL)
                     {
+                        rt_spin_lock(&self_lwp->tty->spinlock);
+                        ret = tty_push(&self_lwp->tty->head, self_lwp);
+                        rt_spin_unlock(&self_lwp->tty->spinlock);
+                        if (ret < 0)
+                        {
+                            lwp_tid_put(tid);
+                            lwp_ref_dec(lwp);
+                            LOG_E("malloc fail!\n");
+                            return -ENOMEM;
+                        }
+                        
                         lwp->tty = self_lwp->tty;
                         lwp->tty->pgrp = lwp->__pgrp;
                         lwp->tty->session = lwp->session;

components/lwp/lwp_pid.c

@@ -438,6 +438,8 @@ void lwp_free(struct rt_lwp* lwp)
     {
         struct termios *old_stdin_termios = get_old_termios();
         struct rt_lwp *self_lwp = (struct rt_lwp *)lwp_self();
+        struct rt_lwp *old_lwp = NULL;
+
         if (lwp->session == -1)
         {
             tcsetattr(1, 0, old_stdin_termios);
@@ -445,9 +447,12 @@ void lwp_free(struct rt_lwp* lwp)
         level = rt_hw_interrupt_disable();
         if (lwp->tty != RT_NULL)
         {
+            rt_spin_lock(&lwp->tty->spinlock);
+            old_lwp = tty_pop(&lwp->tty->head, RT_NULL);
+            rt_spin_unlock(&lwp->tty->spinlock);
             if (lwp->tty->foreground == lwp)
             {
-                lwp->tty->foreground = self_lwp;
+                lwp->tty->foreground = old_lwp;
                 lwp->tty = RT_NULL;
             }
         }
@@ -481,16 +486,18 @@ void lwp_free(struct rt_lwp* lwp)
     }
 }
 
-void lwp_ref_inc(struct rt_lwp *lwp)
+int lwp_ref_inc(struct rt_lwp *lwp)
 {
     rt_base_t level;
 
     level = rt_hw_interrupt_disable();
     lwp->ref++;
     rt_hw_interrupt_enable(level);
+
+    return 0;
 }
 
-void lwp_ref_dec(struct rt_lwp *lwp)
+int lwp_ref_dec(struct rt_lwp *lwp)
 {
     rt_base_t level;
     int ref = -1;
@@ -518,7 +525,11 @@ void lwp_ref_dec(struct rt_lwp *lwp)
 #endif /* RT_LWP_USING_SHM */
 #endif /* not defined ARCH_MM_MMU */
         lwp_free(lwp);
+
+        return 0;
     }
+
+    return -1;
 }
 
 struct rt_lwp* lwp_from_pid(pid_t pid)

components/lwp/lwp_pid.h

@@ -22,8 +22,8 @@ struct lwp_avl_struct *lwp_get_pid_ary(void);
 struct rt_lwp* lwp_new(void);
 void lwp_free(struct rt_lwp* lwp);
 
-void lwp_ref_inc(struct rt_lwp *lwp);
-void lwp_ref_dec(struct rt_lwp *lwp);
+int lwp_ref_inc(struct rt_lwp *lwp);
+int lwp_ref_dec(struct rt_lwp *lwp);
 
 struct rt_lwp* lwp_from_pid(pid_t pid);
 pid_t lwp_to_pid(struct rt_lwp* lwp);

components/lwp/lwp_syscall.c

@@ -1725,6 +1725,19 @@ int _sys_fork(void)
     level = rt_hw_interrupt_disable();
     if (lwp->tty != RT_NULL)
     {
+        int ret;
+        struct rt_lwp *old_lwp;
+
+        old_lwp = lwp->tty->foreground;
+        rt_spin_lock(&lwp->tty->spinlock);
+        ret = tty_push(&lwp->tty->head, old_lwp);
+        rt_spin_unlock(&lwp->tty->spinlock);
+        if (ret < 0)
+        {
+            LOG_E("malloc fail!\n");
+            goto fail;
+        }
+        
         lwp->tty->foreground = lwp;
     }
     rt_hw_interrupt_enable(level);