chore: address checkbuild

- add missing safety blocks
- add missing lisence for the seqpacket c server
- collapse if statement in vsock.rs

Signed-off-by: aerosouund <aerosound161@gmail.com>

Author: aerosouund

src/vmm/src/devices/virtio/vsock/csm/connection.rs

@@ -1462,6 +1462,7 @@ mod tests {
     impl SeqpacketTestStream {
         fn new() -> Self {
             let mut fds = [0i32; 2];
+            // SAFETY: valid AF_UNIX socketpair call; fds is a valid 2-element array.
             let ret = unsafe {
                 libc::socketpair(
                     libc::AF_UNIX,
@@ -1479,19 +1480,21 @@ mod tests {
 
         // Write one seqpacket message into the remote end.
         fn push_message(&self, data: &[u8]) {
+            // SAFETY: `remote_fd` is valid; `data` is a valid slice for the duration of the call.
             let ret = unsafe {
                 libc::write(
                     self.remote_fd,
-                    data.as_ptr() as *const libc::c_void,
+                    data.as_ptr().cast::<libc::c_void>(),
                     data.len(),
                 )
             };
-            assert_eq!(ret as usize, data.len(), "push_message write failed");
+            assert_eq!(ret.cast_unsigned(), data.len(), "push_message write failed");
         }
     }
 
     impl Drop for SeqpacketTestStream {
         fn drop(&mut self) {
+            // SAFETY: Both fds are valid and owned by this struct; closing them on drop.
             unsafe {
                 libc::close(self.local_fd);
                 libc::close(self.remote_fd);
@@ -1511,36 +1514,40 @@ mod tests {
             buf: &mut VolatileSlice<B>,
         ) -> Result<usize, VolatileMemoryError> {
             let mut tmp = vec![0u8; buf.len()];
+            // SAFETY: `local_fd` is valid; `tmp` is a valid writable buffer for the duration of
+            // the call.
             let ret = unsafe {
                 libc::recv(
                     self.local_fd,
-                    tmp.as_mut_ptr() as *mut libc::c_void,
+                    tmp.as_mut_ptr().cast::<libc::c_void>(),
                     tmp.len(),
                     0,
                 )
             };
             if ret < 0 {
                 return Err(VolatileMemoryError::IOError(IoError::last_os_error()));
             }
-            let n = ret as usize;
+            let n = ret.cast_unsigned();
             buf.copy_from(&tmp[..n]);
             Ok(n)
         }
     }
 
     impl Write for SeqpacketTestStream {
         fn write(&mut self, data: &[u8]) -> Result<usize, IoError> {
+            // SAFETY: `local_fd` is valid; `data` is a valid readable slice for the duration of
+            // the call.
             let ret = unsafe {
                 libc::write(
                     self.local_fd,
-                    data.as_ptr() as *const libc::c_void,
+                    data.as_ptr().cast::<libc::c_void>(),
                     data.len(),
                 )
             };
             if ret < 0 {
                 Err(IoError::last_os_error())
             } else {
-                Ok(ret as usize)
+                Ok(ret.cast_unsigned())
             }
         }
 
@@ -1556,17 +1563,19 @@ mod tests {
         ) -> Result<usize, VolatileMemoryError> {
             let mut tmp = vec![0u8; buf.len()];
             buf.copy_to(&mut tmp);
+            // SAFETY: `local_fd` is valid; `tmp` is a valid readable buffer for the duration of
+            // the call.
             let ret = unsafe {
                 libc::write(
                     self.local_fd,
-                    tmp.as_ptr() as *const libc::c_void,
+                    tmp.as_ptr().cast::<libc::c_void>(),
                     tmp.len(),
                 )
             };
             if ret < 0 {
                 Err(VolatileMemoryError::IOError(IoError::last_os_error()))
             } else {
-                Ok(ret as usize)
+                Ok(ret.cast_unsigned())
             }
         }
     }
@@ -1657,7 +1666,7 @@ mod tests {
         // First call: fills the descriptor (4096 bytes), does not set EOM.
         let res1 = conn.recv_pkt(&mut rx_pkt).unwrap();
         assert_eq!(rx_pkt.hdr.op(), uapi::VSOCK_OP_RW);
-        assert_eq!(res1.bytes_read, BUF_SIZE as u32);
+        assert_eq!(res1.bytes_read, u32::try_from(BUF_SIZE).unwrap());
         assert!(res1.should_retrigger);
         assert_eq!(rx_pkt.hdr.flags() & VIRTIO_VSOCK_SEQ_EOM, 0);
         // Connection must still have pending RX for the remainder.
@@ -1687,7 +1696,7 @@ mod tests {
         let res = conn.recv_pkt(&mut rx_pkt).unwrap();
 
         assert_eq!(rx_pkt.hdr.op(), uapi::VSOCK_OP_RW);
-        assert_eq!(res.bytes_read, BUF_SIZE as u32);
+        assert_eq!(res.bytes_read, u32::try_from(BUF_SIZE).unwrap());
         assert!(!res.should_retrigger);
         assert_ne!(rx_pkt.hdr.flags() & VIRTIO_VSOCK_SEQ_EOM, 0);
         assert!(!conn.has_pending_rx());
@@ -1704,8 +1713,7 @@ mod tests {
 
         let stream = SeqpacketTestStream::new();
         stream.push_message(&vec![0u8; MSG_LEN]);
-        let (mut conn, mut rx_pkt, _ctx) =
-            make_established_seqpacket(stream, Some(SMALL_BUF));
+        let (mut conn, mut rx_pkt, _ctx) = make_established_seqpacket(stream, Some(SMALL_BUF));
 
         conn.notify(EventSet::IN);
 

src/vmm/src/devices/virtio/vsock/unix/seqpacket.rs

@@ -28,11 +28,11 @@ impl SeqpacketConn {
         }
 
         // Set non-blocking via FIONBIO ioctl (already allowed by seccomp filter)
-        // SAFETY: Valid fd, errors checked.
         let mut nonblocking: libc::c_int = 1;
+        // SAFETY: `fd` is valid (checked above); `nonblocking` is a valid int pointer.
         let ret = unsafe { libc::ioctl(fd, libc::FIONBIO, &mut nonblocking) };
         if ret < 0 {
-            // Close fd before returning error to avoid fd leak
+            // SAFETY: `fd` is a valid open fd; closing it to avoid a leak.
             unsafe { libc::close(fd) };
             return Err(io::Error::last_os_error());
         }
@@ -41,7 +41,7 @@ impl SeqpacketConn {
         unsafe {
             if libc::connect(
                 fd,
-                &addr as *const libc::sockaddr_un as *const libc::sockaddr,
+                (&addr as *const libc::sockaddr_un).cast::<libc::sockaddr>(),
                 addr_len,
             ) == -1
             {
@@ -171,7 +171,7 @@ impl SeqpacketListener {
         unsafe {
             if libc::bind(
                 fd,
-                &addr as *const libc::sockaddr_un as *const libc::sockaddr,
+                (&addr as *const libc::sockaddr_un).cast::<libc::sockaddr>(),
                 addr_len,
             ) == -1
             {
@@ -226,11 +226,11 @@ impl Socket for SeqpacketListener {
         }
 
         // Set non-blocking via FIONBIO ioctl (already allowed by seccomp filter)
-        // SAFETY: Valid fd, errors checked.
         let mut nonblocking: libc::c_int = 1;
+        // SAFETY: `fd` is valid (checked above); `nonblocking` is a valid int pointer.
         let ret = unsafe { libc::ioctl(fd, libc::FIONBIO, &mut nonblocking) };
         if ret < 0 {
-            // Close fd before returning error to avoid fd leak
+            // SAFETY: `fd` is a valid open fd; closing it to avoid a leak.
             unsafe { libc::close(fd) };
             return Err(io::Error::last_os_error());
         }

src/vmm/src/vmm_config/vsock.rs

@@ -38,13 +38,13 @@ where
 {
     let v = Option::<usize>::deserialize(deserializer)?;
 
-    if let Some(n) = v {
-        if n > MAX_CONN_BUF {
-            return Err(serde::de::Error::custom(format!(
-                "conn_buffer_size too large (max {})",
-                MAX_CONN_BUF
-            )));
-        }
+    if let Some(n) = v
+        && n > MAX_CONN_BUF
+    {
+        return Err(serde::de::Error::custom(format!(
+            "conn_buffer_size too large (max {})",
+            MAX_CONN_BUF
+        )));
     }
 
     Ok(v)

tests/host_tools/vsock_seq_server.c

@@ -1,3 +1,6 @@
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>