misc: cleanups and minor fixes for webkitgtk

* cleanup: remove the unused flags argument in INode::open()
* cleanup: make `flags` on `FileHandle` private and use getter and
  setter functions to set the flags.
* feat: add initial netlink socket support
* feat(unix): implement get_{sockname, peername}
* fix: the ABI for `MessageHeader` was wrong, i.e, {name_len,
  control_len} are supposed to be a u32 instead of a usize.

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

patches/mlibc/mlibc.patch

@@ -330,11 +330,7 @@ impl devfs::Device for Ptmx {
 }
 
 impl INodeInterface for Ptmx {
-    fn open(
-        &self,
-        _flags: aero_syscall::OpenFlags,
-        _handle: Arc<fs::file_table::FileHandle>,
-    ) -> fs::Result<Option<DirCacheItem>> {
+    fn open(&self, _handle: Arc<fs::file_table::FileHandle>) -> fs::Result<Option<DirCacheItem>> {
         let master = Arc::new(Master::new());
         let slave = Slave::new(master.clone());
         let inode = DirEntry::from_inode(master, String::from("<pty>"));

src/Cargo.lock

@@ -229,7 +229,6 @@ impl Tty {
 impl INodeInterface for Tty {
     fn open(
         &self,
-        _flags: aero_syscall::OpenFlags,
         _handle: Arc<fs::file_table::FileHandle>,
     ) -> fs::Result<Option<fs::cache::DirCacheItem>> {
         let connected = self.connected.fetch_add(1, Ordering::SeqCst);

src/aero_kernel/src/drivers/pty.rs

@@ -129,12 +129,8 @@ impl INodeInterface for DevINode {
         self.0.inode().poll(table)
     }
 
-    fn open(
-        &self,
-        flags: aero_syscall::OpenFlags,
-        handle: Arc<super::file_table::FileHandle>,
-    ) -> Result<Option<DirCacheItem>> {
-        self.0.inode().open(flags, handle)
+    fn open(&self, handle: Arc<super::file_table::FileHandle>) -> Result<Option<DirCacheItem>> {
+        self.0.inode().open(handle)
     }
 }
 

src/aero_kernel/src/drivers/tty/vtty.rs

@@ -15,26 +15,45 @@
 // You should have received a copy of the GNU General Public License
 // along with Aero. If not, see <https://www.gnu.org/licenses/>.
 
+use aero_syscall::OpenFlags;
 use alloc::sync::Arc;
+use spin::Once;
 
+use super::file_table::FileHandle;
 use super::inode::{INodeInterface, PollFlags, PollTable};
+use crate::fs::FileSystemError;
 use crate::utils::sync::{Mutex, WaitQueue};
 
 pub struct EventFd {
     wq: WaitQueue,
+    /// Every write(2) on an eventfd, the value written is added to `count` and a wakeup
+    /// is performed on `wq`.
     count: Mutex<u64>,
+    // FIXME: https://github.com/Andy-Python-Programmer/aero/issues/113
+    handle: Once<Arc<FileHandle>>,
 }
 
 impl EventFd {
     pub fn new() -> Arc<Self> {
         Arc::new(Self {
             wq: WaitQueue::new(),
             count: Mutex::new(0),
+            handle: Once::new(),
         })
     }
+
+    fn is_nonblock(&self) -> bool {
+        let handle = self.handle.get().expect("file handle is not initialized");
+        handle.flags().contains(OpenFlags::O_NONBLOCK)
+    }
 }
 
 impl INodeInterface for EventFd {
+    fn open(&self, handle: Arc<FileHandle>) -> super::Result<Option<super::cache::DirCacheItem>> {
+        self.handle.call_once(|| handle);
+        Ok(None)
+    }
+
     fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> super::Result<usize> {
         let size = core::mem::size_of::<u64>();
         assert!(buffer.len() >= size);
@@ -52,16 +71,28 @@ impl INodeInterface for EventFd {
     }
 
     fn write_at(&self, _offset: usize, buffer: &[u8]) -> super::Result<usize> {
-        let size = core::mem::size_of::<u64>();
-        assert!(buffer.len() >= size);
+        let chunk_size = core::mem::size_of::<u64>();
+        assert!(buffer.len() >= chunk_size);
 
-        // SAFETY: We have above verified that it is safe to dereference
-        //         the value.
-        let value = unsafe { *(buffer.as_ptr() as *const u64) };
+        // TODO: use bytemuck to remove the unsafe.
+        let target = unsafe { *(buffer.as_ptr() as *const u64) };
+
+        if target == u64::MAX {
+            return Err(FileSystemError::NotSupported);
+        }
+
+        let mut count = self.count.lock();
+
+        if u64::MAX - *count > target {
+            *count += target;
+        } else if !self.is_nonblock() {
+            unimplemented!()
+        } else {
+            return Ok(0);
+        };
 
-        *self.count.lock_irq() += value;
         self.wq.notify_all();
-        Ok(size)
+        Ok(chunk_size)
     }
 
     fn poll(&self, table: Option<&mut PollTable>) -> super::Result<PollFlags> {
@@ -70,7 +101,7 @@ impl INodeInterface for EventFd {
 
         if let Some(e) = table {
             e.insert(&self.wq)
-        } // listen for changes
+        }
 
         if *count > 0 {
             events.insert(PollFlags::IN);