add nginx app

Cargo.toml

@@ -61,6 +61,7 @@ members = [
     "apps/display/draw_map",
     "apps/exception",
     "apps/helloworld",
+    "apps/systime",
     "apps/memtest",
     "apps/fs/shell",
     "apps/net/echoserver",

Makefile

@@ -240,4 +240,4 @@ clean_musl:
 	rm -rf ulib/axmusl/build_*
 	rm -rf ulib/axmusl/install
 
-.PHONY: all build disasm run justrun debug clippy fmt fmt_c test test_no_fail_fast clean clean_c clean_musl doc disk_image
+.PHONY: all build disasm run justrun debug clippy fmt fmt_c test test_no_fail_fast clean clean_c clean_musl doc disk_image

api/arceos_posix_api/build.rs

@@ -117,6 +117,7 @@ typedef struct {{
             "RLIMIT_.*",
             "EAI_.*",
             "MAXADDRS",
+            "FIO.*",
             "ITIMER_.*",
             "SIG.*",
             "EINVAL",

api/arceos_posix_api/ctypes.h

@@ -28,3 +28,4 @@
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
+#include <sys/ioctl.h>

api/arceos_posix_api/src/imp/fd_ops.rs

@@ -28,6 +28,7 @@ pub trait FileLike: Send + Sync {
     fn into_any(self: Arc<Self>) -> Arc<dyn core::any::Any + Send + Sync>;
     fn poll(&self) -> LinuxResult<PollState>;
     fn set_nonblocking(&self, nonblocking: bool) -> LinuxResult;
+    fn set_closeonexec(&self, closeonexec: bool) -> LinuxResult;
 }
 
 lazy_static::lazy_static! {
@@ -100,6 +101,8 @@ pub fn sys_dup2(old_fd: c_int, new_fd: c_int) -> c_int {
             return Err(LinuxError::EBADF);
         }
 
+        close_file_like(new_fd).map(|_| 0);
+
         let f = get_file_like(old_fd)?;
         FD_TABLE
             .write()
@@ -145,6 +148,10 @@ pub fn sys_fcntl(fd: c_int, cmd: c_int, arg: usize) -> c_int {
                 // TODO: Change fd flags
                 dup_fd(fd)
             }
+            ctypes::F_SETFD => {
+                get_file_like(fd)?.set_closeonexec(arg & (ctypes::O_CLOEXEC as usize) > 0)?;
+                Ok(0)
+            }
             ctypes::F_SETFL => {
                 if fd == 0 || fd == 1 || fd == 2 {
                     return Ok(0);

api/arceos_posix_api/src/imp/fs.rs

@@ -6,9 +6,9 @@
  *   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
  *   See the Mulan PSL v2 for more details.
  */
-
+use crate::ctypes::off_t;
 use alloc::sync::Arc;
-use core::ffi::{c_char, c_int};
+use core::ffi::{c_char, c_int, c_size_t, c_ssize_t, c_void};
 
 use axerrno::{LinuxError, LinuxResult};
 use axfs::fops::OpenOptions;
@@ -43,7 +43,8 @@ impl File {
 
 impl FileLike for File {
     fn read(&self, buf: &mut [u8]) -> LinuxResult<usize> {
-        Ok(self.inner.lock().read(buf)?)
+        let read_len = self.inner.lock().read(buf)?;
+        Ok(read_len)
     }
 
     fn write(&self, buf: &[u8]) -> LinuxResult<usize> {
@@ -82,6 +83,10 @@ impl FileLike for File {
     fn set_nonblocking(&self, _nonblocking: bool) -> LinuxResult {
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }
 
 /// Convert open flags to [`OpenOptions`].
@@ -120,8 +125,25 @@ pub fn sys_open(filename: *const c_char, flags: c_int, mode: ctypes::mode_t) ->
     debug!("sys_open <= {:?} {:#o} {:#o}", filename, flags, mode);
     syscall_body!(sys_open, {
         let options = flags_to_options(flags, mode);
-        let file = axfs::fops::File::open(filename?, &options)?;
-        File::new(file).add_to_fd_table()
+        /*let file = axfs::fops::File::open(filename?, &options)?;
+        File::new(file).add_to_fd_table()*/
+        let res = axfs::fops::File::open(filename?, &options);
+        match res {
+            Ok(file) => {
+                let add_res = File::new(file).add_to_fd_table();
+                match add_res {
+                    Ok(num) => Ok(num),
+                    Err(e) => {
+                        error!("sys_open failed in add {}", e);
+                        Err(e.into())
+                    }
+                }
+            }
+            Err(e) => {
+                error!("sys_open failed {}", e);
+                Err(e.into())
+            }
+        }
     })
 }
 
@@ -133,8 +155,25 @@ pub fn sys_openat(_fd: usize, path: *const c_char, flags: c_int, mode: ctypes::m
     debug!("sys_openat <= {:?}, {:#o} {:#o}", path, flags, mode);
     syscall_body!(sys_openat, {
         let options = flags_to_options(flags, mode);
-        let file = axfs::fops::File::open(path?, &options)?;
-        File::new(file).add_to_fd_table()
+        //let file = axfs::fops::File::open(path?, &options)?;
+        let res = axfs::fops::File::open(path?, &options);
+        match res {
+            Ok(file) => {
+                let add_res = File::new(file).add_to_fd_table();
+                match add_res {
+                    Ok(num) => Ok(num),
+                    Err(e) => {
+                        error!("sys_open failed in add {}", e);
+                        Err(e.into())
+                    }
+                }
+            }
+            Err(e) => {
+                error!("sys_open failed {}", e);
+                Err(e.into())
+            }
+        }
+        //File::new(file).add_to_fd_table()
     })
 }
 

api/arceos_posix_api/src/imp/io_mpx/epoll.rs

@@ -46,20 +46,23 @@ impl EpollInstance {
     }
 
     fn control(&self, op: usize, fd: usize, event: &ctypes::epoll_event) -> LinuxResult<usize> {
+        info!("lhw debug EpollInstance control");
         match get_file_like(fd as c_int) {
             Ok(_) => {}
             Err(e) => return Err(e),
         }
 
         match op as u32 {
             ctypes::EPOLL_CTL_ADD => {
+                info!("lhw debug EpollInstance control add");
                 if let Entry::Vacant(e) = self.events.lock().entry(fd) {
                     e.insert(*event);
                 } else {
                     return Err(LinuxError::EEXIST);
                 }
             }
             ctypes::EPOLL_CTL_MOD => {
+                info!("lhw debug EpollInstance control mod");
                 let mut events = self.events.lock();
                 if let Entry::Occupied(mut ocp) = events.entry(fd) {
                     ocp.insert(*event);
@@ -68,6 +71,7 @@ impl EpollInstance {
                 }
             }
             ctypes::EPOLL_CTL_DEL => {
+                info!("lhw debug EpollInstance control del");
                 let mut events = self.events.lock();
                 if let Entry::Occupied(ocp) = events.entry(fd) {
                     ocp.remove_entry();
@@ -85,17 +89,19 @@ impl EpollInstance {
     fn poll_all(&self, events: &mut [ctypes::epoll_event]) -> LinuxResult<usize> {
         let ready_list = self.events.lock();
         let mut events_num = 0;
-
         for (infd, ev) in ready_list.iter() {
+            //info!("lhw debug EpollInstance ready list loop {}",*infd);
             match get_file_like(*infd as c_int)?.poll() {
                 Err(_) => {
+                    info!("lhw debug err in poll all");
                     if (ev.events & ctypes::EPOLLERR) != 0 {
                         events[events_num].events = ctypes::EPOLLERR;
                         events[events_num].data = ev.data;
                         events_num += 1;
                     }
                 }
                 Ok(state) => {
+                    //info!("lhw debug EpollInstance poll all ok {} {} {} {}",state.readable , (ev.events & ctypes::EPOLLIN), state.readable ,(ev.events & ctypes::EPOLLIN));
                     if state.readable && (ev.events & ctypes::EPOLLIN != 0) {
                         events[events_num].events = ctypes::EPOLLIN;
                         events[events_num].data = ev.data;
@@ -109,7 +115,9 @@ impl EpollInstance {
                     }
                 }
             }
+            //info!("lhw debug EpollInstance ready list loop {} end",*infd);
         }
+        //info!("lhw debug EpollInstance poll all normal return");
         Ok(events_num)
     }
 }
@@ -144,6 +152,10 @@ impl FileLike for EpollInstance {
     fn set_nonblocking(&self, _nonblocking: bool) -> LinuxResult {
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }
 
 /// Creates a new epoll instance.
@@ -215,7 +227,37 @@ pub unsafe fn sys_epoll_wait(
         loop {
             #[cfg(feature = "net")]
             axnet::poll_interfaces();
-            let events_num = epoll_instance.poll_all(events)?;
+            let poll_all_res = epoll_instance.poll_all(events);
+            let mut events_num = 0;
+            match poll_all_res {
+                Ok(num) => events_num = num,
+                Err(e) => {
+                    error!("sys epoll events err {:?}", e);
+                    if e == LinuxError::EBADF {
+                        let mut deleted_fd: usize = 0;
+                        {
+                            let mut ready_list = epoll_instance.events.lock();
+                            for (infd, ev) in ready_list.iter() {
+                                match get_file_like(*infd as c_int) {
+                                    Ok(_) => {}
+                                    Err(_) => {
+                                        error!("sys epoll deleted fd err {}", *infd);
+                                        deleted_fd = *infd;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        {
+                            let mut events = epoll_instance.events.lock();
+                            if let Entry::Occupied(ocp) = events.entry(deleted_fd) {
+                                ocp.remove_entry();
+                            }
+                        }
+                        return Ok(0);
+                    }
+                }
+            }
             if events_num > 0 {
                 return Ok(events_num as c_int);
             }

api/arceos_posix_api/src/imp/ioctl.rs

@@ -7,6 +7,8 @@
  *   See the Mulan PSL v2 for more details.
  */
 
+#[cfg(feature = "fd")]
+use crate::imp::fd_ops::get_file_like;
 use axerrno::LinuxError;
 use core::ffi::c_int;
 
@@ -15,6 +17,7 @@ pub const TCGETS: usize = 0x5401;
 pub const TIOCGPGRP: usize = 0x540F;
 pub const TIOCSPGRP: usize = 0x5410;
 pub const TIOCGWINSZ: usize = 0x5413;
+pub const FIONBIO: usize = 21537;
 
 #[derive(Clone, Copy, Default)]
 pub struct ConsoleWinSize {
@@ -28,12 +31,14 @@ pub struct ConsoleWinSize {
 /// currently only support fd = 1
 pub fn sys_ioctl(fd: c_int, request: usize, data: usize) -> c_int {
     debug!("sys_ioctl <= fd: {}, request: {}", fd, request);
-    if fd != 1 {
-        debug!("Only support fd = 1");
-        return -1;
-    }
     syscall_body!(sys_ioctl, {
         match request {
+            FIONBIO => {
+                unsafe {
+                    get_file_like(fd)?.set_nonblocking(*(data as *const i32) > 0)?;
+                }
+                Ok(0)
+            }
             TIOCGWINSZ => {
                 let winsize = data as *mut ConsoleWinSize;
                 unsafe {

api/arceos_posix_api/src/imp/net.rs

@@ -177,6 +177,10 @@ impl FileLike for Socket {
         }
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }
 
 impl From<SocketAddrV4> for ctypes::sockaddr_in {
@@ -412,6 +416,7 @@ pub fn sys_recv(
         socket_fd, buf_ptr as usize, len, flag
     );
     syscall_body!(sys_recv, {
+        info!("lhw debug in sys_recv");
         if buf_ptr.is_null() {
             return Err(LinuxError::EFAULT);
         }

api/arceos_posix_api/src/imp/pipe.rs

@@ -197,6 +197,10 @@ impl FileLike for Pipe {
     fn set_nonblocking(&self, _nonblocking: bool) -> LinuxResult {
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }
 
 /// Create a pipe

api/arceos_posix_api/src/imp/stdio.rs

@@ -140,6 +140,10 @@ impl super::fd_ops::FileLike for Stdin {
     fn set_nonblocking(&self, _nonblocking: bool) -> LinuxResult {
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }
 
 #[cfg(feature = "fd")]
@@ -176,4 +180,8 @@ impl super::fd_ops::FileLike for Stdout {
     fn set_nonblocking(&self, _nonblocking: bool) -> LinuxResult {
         Ok(())
     }
+
+    fn set_closeonexec(&self, _closeonexec: bool) -> LinuxResult {
+        Ok(())
+    }
 }

api/arceos_posix_api/src/lib.rs

@@ -17,6 +17,7 @@
 #![feature(doc_cfg)]
 #![feature(doc_auto_cfg)]
 #![allow(clippy::missing_safety_doc)]
+#![feature(c_size_t)]
 
 #[macro_use]
 extern crate axlog;

apps/c/nginx/.gitignore

@@ -0,0 +1,2 @@
+nginx-app
+*.img