fix(tty): some abnormal behavior in tty job control ops.

Previous tty job control implementations are totally wrong. Rewrite
these parts and have some changes in `init_script` to correctly assign
a controlling terminal to the shell launched.

init_script.sh

@@ -25,6 +25,8 @@ do_or_freeze $BUSYBOX mknod -m 666 /dev/null c 1 3
 do_or_freeze $BUSYBOX mknod -m 666 /dev/zero c 1 5
 do_or_freeze $BUSYBOX mknod -m 666 /dev/sda b 8 0
 do_or_freeze $BUSYBOX mknod -m 666 /dev/sda1 b 8 1
+do_or_freeze $BUSYBOX mknod -m 666 /dev/ttyS0 c 4 64
+do_or_freeze $BUSYBOX mknod -m 666 /dev/ttyS1 c 4 65
 
 echo -n -e "deploying busybox... " >&2
 
@@ -57,5 +59,4 @@ alias ll="ls -l "
 alias la="ls -la "
 EOF
 
-exec /mnt/init /bin/sh -l \
-    < /dev/console > /dev/console 2> /dev/console
+exec /mnt/init /bin/sh -c 'exec sh -l < /dev/ttyS0 > /dev/ttyS0 2> /dev/ttyS0'

src/kernel/chardev.rs

@@ -9,6 +9,7 @@ use crate::{io::Buffer, kernel::console::CONSOLE, prelude::*};
 
 use super::{
     block::make_device,
+    task::Thread,
     terminal::Terminal,
     vfs::{
         file::{File, TerminalFile},
@@ -74,7 +75,16 @@ impl CharDevice {
 
     pub fn open(self: &Arc<Self>) -> KResult<Arc<File>> {
         Ok(match &self.device {
-            CharDeviceType::Terminal(terminal) => TerminalFile::new(terminal.clone()),
+            CharDeviceType::Terminal(terminal) => {
+                // We only set the control terminal if the process is the session leader.
+                if Thread::current().process.sid() == Thread::current().process.pid {
+                    let session = Thread::current().process.session();
+                    // Silently fail if we can't set the control terminal.
+                    dont_check!(session.set_control_terminal(&terminal, false));
+                }
+
+                TerminalFile::new(terminal.clone())
+            }
             CharDeviceType::Virtual(_) => Arc::new(File::CharDev(self.clone())),
         })
     }
@@ -107,22 +117,16 @@ impl VirtualCharDevice for ZeroDevice {
 struct ConsoleDevice;
 impl VirtualCharDevice for ConsoleDevice {
     fn read(&self, buffer: &mut dyn Buffer) -> KResult<usize> {
-        match CONSOLE.lock_irq().get_terminal() {
-            Some(console) => console.read(buffer),
-            None => Err(EIO),
-        }
+        let console_terminal = CONSOLE.lock_irq().get_terminal().ok_or(EIO)?;
+        console_terminal.read(buffer)
     }
 
     fn write(&self, data: &[u8]) -> KResult<usize> {
-        match CONSOLE.lock_irq().get_terminal() {
-            None => Err(EIO),
-            Some(console) => {
-                for &ch in data.iter() {
-                    console.show_char(ch);
-                }
-                Ok(data.len())
-            }
+        let console_terminal = CONSOLE.lock_irq().get_terminal().ok_or(EIO)?;
+        for &ch in data.iter() {
+            console_terminal.show_char(ch);
         }
+        Ok(data.len())
     }
 }
 

src/kernel/task/thread.rs

@@ -259,6 +259,36 @@ impl Session {
         }
     }
 
+    /// Only session leaders can set the control terminal.
+    /// Make sure we've checked that before calling this function.
+    pub fn set_control_terminal(
+        self: &Arc<Self>,
+        terminal: &Arc<Terminal>,
+        forced: bool,
+    ) -> KResult<()> {
+        let mut inner = self.inner.lock();
+        if let Some(_) = inner.control_terminal.as_ref() {
+            if let Some(session) = terminal.session().as_ref() {
+                if session.sid == self.sid {
+                    return Ok(());
+                }
+            }
+            return Err(EPERM);
+        }
+        terminal.set_session(self, forced)?;
+        inner.control_terminal = Some(terminal.clone());
+        inner.foreground = Arc::downgrade(&Thread::current().process.pgroup());
+        Ok(())
+    }
+
+    /// Drop the control terminal reference inside the session.
+    /// DO NOT TOUCH THE TERMINAL'S SESSION FIELD.
+    pub fn drop_control_terminal(&self) -> Option<Arc<Terminal>> {
+        let mut inner = self.inner.lock();
+        inner.foreground = Weak::new();
+        inner.control_terminal.take()
+    }
+
     pub fn raise_foreground(&self, signal: Signal) {
         if let Some(fg) = self.inner.lock().foreground.upgrade() {
             fg.raise(signal);
@@ -423,6 +453,13 @@ impl ProcessList {
             thread.files.close_all();
         }
 
+        // If we are the session leader, we should drop the control terminal.
+        if inner.session.sid == process.pid {
+            if let Some(terminal) = inner.session.drop_control_terminal() {
+                terminal.drop_session();
+            }
+        }
+
         // Unmap all user memory areas
         process.mm_list.clear_user();
 
@@ -463,15 +500,13 @@ impl ProcessList {
         }
 
         {
-            {
-                let parent_wait_list = &inner.parent.as_ref().unwrap().wait_list;
-                let mut parent_waits = parent_wait_list.wait_procs.lock();
-                parent_waits.push_back(WaitObject {
-                    pid: process.pid,
-                    code: status,
-                });
-                parent_wait_list.cv_wait_procs.notify_all();
-            }
+            let parent_wait_list = &inner.parent.as_ref().unwrap().wait_list;
+            let mut parent_waits = parent_wait_list.wait_procs.lock();
+            parent_waits.push_back(WaitObject {
+                pid: process.pid,
+                code: status,
+            });
+            parent_wait_list.cv_wait_procs.notify_all();
         }
 
         preempt::enable();
@@ -672,9 +707,6 @@ impl Process {
                 return Err(EPERM);
             }
 
-            inner.session = Session::new(self.pid, Arc::downgrade(self));
-            ProcessList::get().add_session(&inner.session);
-
             inner.pgroup.remove_member(self.pid);
             inner.pgroup = ProcessGroup::new(self, &inner.session);
             ProcessList::get().add_pgroup(&inner.pgroup);

src/kernel/terminal.rs

@@ -2,7 +2,7 @@ use alloc::{
     collections::vec_deque::VecDeque,
     sync::{Arc, Weak},
 };
-use bindings::{EINTR, ENOTTY};
+use bindings::{EINTR, ENOTTY, EPERM};
 use bitflags::bitflags;
 
 use crate::{io::Buffer, prelude::*, sync::CondVar};
@@ -587,8 +587,7 @@ impl Terminal {
     pub fn ioctl(&self, request: TerminalIORequest) -> KResult<()> {
         match request {
             TerminalIORequest::GetProcessGroup(pgid_pointer) => {
-                let inner = self.inner.lock();
-                let session = inner.session.upgrade();
+                let session = self.inner.lock().session.upgrade();
                 let pgid = session.map(|session| session.foreground_pgid()).flatten();
 
                 if let Some(pgid) = pgid {
@@ -640,4 +639,30 @@ impl Terminal {
             }
         }
     }
+
+    /// Assign the `session` to this terminal. Drop the previous session if `forced` is true.
+    pub fn set_session(&self, session: &Arc<Session>, forced: bool) -> KResult<()> {
+        let mut inner = self.inner.lock();
+        if let Some(session) = inner.session.upgrade() {
+            if !forced {
+                Err(EPERM)
+            } else {
+                session.drop_control_terminal();
+                inner.session = Arc::downgrade(&session);
+                Ok(())
+            }
+        } else {
+            // Sessions should set their `control_terminal` field.
+            inner.session = Arc::downgrade(&session);
+            Ok(())
+        }
+    }
+
+    pub fn drop_session(&self) {
+        self.inner.lock().session = Weak::new();
+    }
+
+    pub fn session(&self) -> Option<Arc<Session>> {
+        self.inner.lock().session.upgrade()
+    }
 }

src/kernel/vfs/filearray.rs

@@ -199,15 +199,10 @@ impl FileArray {
         let mut inner = self.inner.lock();
         let fd = inner.next_fd();
 
-        if s_ischr(filemode) && inode.devid()? == 0x0501 {
-            // TODO!!!: Get terminal from char device.
-            inner.do_insert(
-                fd,
-                fdflag as u64,
-                TerminalFile::new(CONSOLE.lock_irq().get_terminal().unwrap()),
-            );
-
+        if s_ischr(filemode) {
             let device = CharDevice::get(inode.devid()?).ok_or(ENXIO)?;
+            let file = device.open()?;
+            inner.do_insert(fd, fdflag as u64, file);
         } else {
             inner.do_insert(
                 fd,
@@ -248,21 +243,22 @@ impl FileArray {
     pub fn open_console(&self) {
         let mut inner = self.inner.lock();
         let (stdin, stdout, stderr) = (inner.next_fd(), inner.next_fd(), inner.next_fd());
+        let console_terminal = CONSOLE.lock_irq().get_terminal().unwrap();
 
         inner.do_insert(
             stdin,
             O_CLOEXEC as u64,
-            TerminalFile::new(CONSOLE.lock_irq().get_terminal().unwrap()),
+            TerminalFile::new(console_terminal.clone()),
         );
         inner.do_insert(
             stdout,
             O_CLOEXEC as u64,
-            TerminalFile::new(CONSOLE.lock_irq().get_terminal().unwrap()),
+            TerminalFile::new(console_terminal.clone()),
         );
         inner.do_insert(
             stderr,
             O_CLOEXEC as u64,
-            TerminalFile::new(CONSOLE.lock_irq().get_terminal().unwrap()),
+            TerminalFile::new(console_terminal.clone()),
         );
     }
 }