src/tools/miri/tests/pass-dep/libc/libc-eventfd.rs - rust-lang/rust - Git at Google

 //@only-target: linux android illumos
 // test_race, test_blocking_read and test_blocking_write depend on a deterministic schedule.
 //@compile-flags: -Zmiri-deterministic-concurrency

 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]

 use std::thread;

 fn main() {
     test_read_write();
     test_race();

     #[cfg(not(target_os = "illumos"))]
     test_syscall();

     test_blocking_read();
     test_blocking_write();
     test_two_threads_blocked_on_eventfd();
 }

 fn read_bytes<const N: usize>(fd: i32, buf: &mut [u8; N]) -> i32 {
     let res: i32 = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), N).try_into().unwrap() };
     return res;
 }

 fn write_bytes<const N: usize>(fd: i32, data: [u8; N]) -> i32 {
     let res: i32 =
         unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, N).try_into().unwrap() };
     return res;
 }

 fn test_read_write() {
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
     // Write 1 to the counter.
     let res = write_bytes(fd, sized_8_data);
     assert_eq!(res, 8);

     // Read 1 from the counter.
     let mut buf: [u8; 8] = [0; 8];
     let res = read_bytes(fd, &mut buf);
     // Read returns number of bytes has been read, which is always 8.
     assert_eq!(res, 8);
     // Check the value of counter read.
     let counter = u64::from_ne_bytes(buf);
     assert_eq!(counter, 1);

     // After read, the counter is currently 0, read counter 0 should fail with return
     // value -1.
     let mut buf: [u8; 8] = [0; 8];
     let res = read_bytes(fd, &mut buf);
     let e = std::io::Error::last_os_error();
     assert_eq!(e.raw_os_error(), Some(libc::EAGAIN));
     assert_eq!(res, -1);

     // Write with supplied buffer bigger than 8 bytes should be allowed.
     let sized_9_data: [u8; 9];
     if cfg!(target_endian = "big") {
         // Adjust the data based on the endianness of host system.
         sized_9_data = [0, 0, 0, 0, 0, 0, 0, 1, 0];
     } else {
         sized_9_data = [1, 0, 0, 0, 0, 0, 0, 0, 0];
     }
     let res = write_bytes(fd, sized_9_data);
     assert_eq!(res, 8);

     // Read with supplied buffer smaller than 8 bytes should fail with return
     // value -1.
     let mut buf: [u8; 7] = [1; 7];
     let res = read_bytes(fd, &mut buf);
     let e = std::io::Error::last_os_error();
     assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
     assert_eq!(res, -1);

     // Write with supplied buffer smaller than 8 bytes should fail with return
     // value -1.
     let size_7_data: [u8; 7] = [1; 7];
     let res = write_bytes(fd, size_7_data);
     let e = std::io::Error::last_os_error();
     assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
     assert_eq!(res, -1);

     // Read with supplied buffer bigger than 8 bytes should be allowed.
     let mut buf: [u8; 9] = [1; 9];
     let res = read_bytes(fd, &mut buf);
     assert_eq!(res, 8);

     // Write u64::MAX should fail.
     let u64_max_bytes: [u8; 8] = [255; 8];
     let res = write_bytes(fd, u64_max_bytes);
     let e = std::io::Error::last_os_error();
     assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
     assert_eq!(res, -1);
 }

 fn test_race() {
     static mut VAL: u8 = 0;
     let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 8] = [0; 8];
         let res = read_bytes(fd, &mut buf);
         // read returns number of bytes has been read, which is always 8.
         assert_eq!(res, 8);
         let counter = u64::from_ne_bytes(buf);
         assert_eq!(counter, 1);
         unsafe { assert_eq!(VAL, 1) };
     });
     unsafe { VAL = 1 };
     let data: [u8; 8] = 1_u64.to_ne_bytes();
     let res = write_bytes(fd, data);
     // write returns number of bytes written, which is always 8.
     assert_eq!(res, 8);
     thread::yield_now();
     thread1.join().unwrap();
 }

 // This is a test for calling eventfd2 through a syscall.
 // Illumos supports eventfd, but it has no entry to call it through syscall.
 #[cfg(not(target_os = "illumos"))]
 fn test_syscall() {
     let initval = 0 as libc::c_uint;
     let flags = (libc::EFD_CLOEXEC | libc::EFD_NONBLOCK) as libc::c_int;
     let fd = unsafe { libc::syscall(libc::SYS_eventfd2, initval, flags) };
     assert_ne!(fd, -1);
 }

 // This test will block on eventfd read then get unblocked by `write`.
 fn test_blocking_read() {
     // eventfd read will block when EFD_NONBLOCK flag is clear and counter = 0.
     let flags = libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 8] = [0; 8];
         // This will block.
         let res = read_bytes(fd, &mut buf);
         // read returns number of bytes has been read, which is always 8.
         assert_eq!(res, 8);
         let counter = u64::from_ne_bytes(buf);
         assert_eq!(counter, 1);
     });
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
     // Pass control to thread1 so it can block on eventfd `read`.
     thread::yield_now();
     // Write 1 to the counter to unblock thread1.
     let res = write_bytes(fd, sized_8_data);
     assert_eq!(res, 8);
     thread1.join().unwrap();
 }

 /// This test will block on eventfd `write` then get unblocked by `read`.
 fn test_blocking_write() {
     // eventfd write will block when EFD_NONBLOCK flag is clear
     // and the addition caused counter to exceed u64::MAX - 1.
     let flags = libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     // Write u64 - 1, so the all subsequent write will block.
     let sized_8_data: [u8; 8] = (u64::MAX - 1).to_ne_bytes();
     let res: i64 = unsafe {
         libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
     };
     assert_eq!(res, 8);

     let thread1 = thread::spawn(move || {
         let sized_8_data = 1_u64.to_ne_bytes();
         // Write 1 to the counter, this will block.
         let res: i64 = unsafe {
             libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
         };
         // Make sure that write is successful.
         assert_eq!(res, 8);
     });
     let mut buf: [u8; 8] = [0; 8];
     // Pass control to thread1 so it can block on eventfd `write`.
     thread::yield_now();
     // This will unblock previously blocked eventfd read.
     let res = read_bytes(fd, &mut buf);
     // read returns number of bytes has been read, which is always 8.
     assert_eq!(res, 8);
     let counter = u64::from_ne_bytes(buf);
     assert_eq!(counter, (u64::MAX - 1));
     thread1.join().unwrap();
 }

 // Test two threads blocked on eventfd.
 // Expected behaviour:
 // 1. thread1 and thread2 both blocked on `write`.
 // 2. thread3 unblocks both thread1 and thread2
 // 3. The write in thread1 and thread2 return successfully.
 fn test_two_threads_blocked_on_eventfd() {
     // eventfd write will block when EFD_NONBLOCK flag is clear
     // and the addition caused counter to exceed u64::MAX - 1.
     let flags = libc::EFD_CLOEXEC;
     let fd = unsafe { libc::eventfd(0, flags) };
     // Write u64 - 1, so the all subsequent write will block.
     let sized_8_data: [u8; 8] = (u64::MAX - 1).to_ne_bytes();
     let res: i64 = unsafe {
         libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
     };
     assert_eq!(res, 8);

     let thread1 = thread::spawn(move || {
         let sized_8_data = 1_u64.to_ne_bytes();
         let res: i64 = unsafe {
             libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
         };
         // Make sure that write is successful.
         assert_eq!(res, 8);
     });

     let thread2 = thread::spawn(move || {
         let sized_8_data = 1_u64.to_ne_bytes();
         let res: i64 = unsafe {
             libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
         };
         // Make sure that write is successful.
         assert_eq!(res, 8);
     });

     let thread3 = thread::spawn(move || {
         let mut buf: [u8; 8] = [0; 8];
         // This will unblock previously blocked eventfd read.
         let res = read_bytes(fd, &mut buf);
         // read returns number of bytes has been read, which is always 8.
         assert_eq!(res, 8);
         let counter = u64::from_ne_bytes(buf);
         assert_eq!(counter, (u64::MAX - 1));
     });

     thread1.join().unwrap();
     thread2.join().unwrap();
     thread3.join().unwrap();
 }
	//@only-target: linux android illumos
	// test_race, test_blocking_read and test_blocking_write depend on a deterministic schedule.
	//@compile-flags: -Zmiri-deterministic-concurrency

	// FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
	#![allow(static_mut_refs)]

	use std::thread;

	fn main() {
	test_read_write();
	test_race();

	#[cfg(not(target_os = "illumos"))]
	test_syscall();

	test_blocking_read();
	test_blocking_write();
	test_two_threads_blocked_on_eventfd();
	}

	fn read_bytes<const N: usize>(fd: i32, buf: &mut [u8; N]) -> i32 {
	let res: i32 = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), N).try_into().unwrap() };
	return res;
	}

	fn write_bytes<const N: usize>(fd: i32, data: [u8; N]) -> i32 {
	let res: i32 =
	unsafe { libc::write(fd, data.as_ptr() as *const libc::c_void, N).try_into().unwrap() };
	return res;
	}

	fn test_read_write() {
	let flags = libc::EFD_NONBLOCK \| libc::EFD_CLOEXEC;
	let fd = unsafe { libc::eventfd(0, flags) };
	let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
	// Write 1 to the counter.
	let res = write_bytes(fd, sized_8_data);
	assert_eq!(res, 8);

	// Read 1 from the counter.
	let mut buf: [u8; 8] = [0; 8];
	let res = read_bytes(fd, &mut buf);
	// Read returns number of bytes has been read, which is always 8.
	assert_eq!(res, 8);
	// Check the value of counter read.
	let counter = u64::from_ne_bytes(buf);
	assert_eq!(counter, 1);

	// After read, the counter is currently 0, read counter 0 should fail with return
	// value -1.
	let mut buf: [u8; 8] = [0; 8];
	let res = read_bytes(fd, &mut buf);
	let e = std::io::Error::last_os_error();
	assert_eq!(e.raw_os_error(), Some(libc::EAGAIN));
	assert_eq!(res, -1);

	// Write with supplied buffer bigger than 8 bytes should be allowed.
	let sized_9_data: [u8; 9];
	if cfg!(target_endian = "big") {
	// Adjust the data based on the endianness of host system.
	sized_9_data = [0, 0, 0, 0, 0, 0, 0, 1, 0];
	} else {
	sized_9_data = [1, 0, 0, 0, 0, 0, 0, 0, 0];
	}
	let res = write_bytes(fd, sized_9_data);
	assert_eq!(res, 8);

	// Read with supplied buffer smaller than 8 bytes should fail with return
	// value -1.
	let mut buf: [u8; 7] = [1; 7];
	let res = read_bytes(fd, &mut buf);
	let e = std::io::Error::last_os_error();
	assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
	assert_eq!(res, -1);

	// Write with supplied buffer smaller than 8 bytes should fail with return
	// value -1.
	let size_7_data: [u8; 7] = [1; 7];
	let res = write_bytes(fd, size_7_data);
	let e = std::io::Error::last_os_error();
	assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
	assert_eq!(res, -1);

	// Read with supplied buffer bigger than 8 bytes should be allowed.
	let mut buf: [u8; 9] = [1; 9];
	let res = read_bytes(fd, &mut buf);
	assert_eq!(res, 8);

	// Write u64::MAX should fail.
	let u64_max_bytes: [u8; 8] = [255; 8];
	let res = write_bytes(fd, u64_max_bytes);
	let e = std::io::Error::last_os_error();
	assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
	assert_eq!(res, -1);
	}

	fn test_race() {
	static mut VAL: u8 = 0;
	let flags = libc::EFD_NONBLOCK \| libc::EFD_CLOEXEC;
	let fd = unsafe { libc::eventfd(0, flags) };
	let thread1 = thread::spawn(move \|\| {
	let mut buf: [u8; 8] = [0; 8];
	let res = read_bytes(fd, &mut buf);
	// read returns number of bytes has been read, which is always 8.
	assert_eq!(res, 8);
	let counter = u64::from_ne_bytes(buf);
	assert_eq!(counter, 1);
	unsafe { assert_eq!(VAL, 1) };
	});
	unsafe { VAL = 1 };
	let data: [u8; 8] = 1_u64.to_ne_bytes();
	let res = write_bytes(fd, data);
	// write returns number of bytes written, which is always 8.
	assert_eq!(res, 8);
	thread::yield_now();
	thread1.join().unwrap();
	}

	// This is a test for calling eventfd2 through a syscall.
	// Illumos supports eventfd, but it has no entry to call it through syscall.
	#[cfg(not(target_os = "illumos"))]
	fn test_syscall() {
	let initval = 0 as libc::c_uint;
	let flags = (libc::EFD_CLOEXEC \| libc::EFD_NONBLOCK) as libc::c_int;
	let fd = unsafe { libc::syscall(libc::SYS_eventfd2, initval, flags) };
	assert_ne!(fd, -1);
	}

	// This test will block on eventfd read then get unblocked by `write`.
	fn test_blocking_read() {
	// eventfd read will block when EFD_NONBLOCK flag is clear and counter = 0.
	let flags = libc::EFD_CLOEXEC;
	let fd = unsafe { libc::eventfd(0, flags) };
	let thread1 = thread::spawn(move \|\| {
	let mut buf: [u8; 8] = [0; 8];
	// This will block.
	let res = read_bytes(fd, &mut buf);
	// read returns number of bytes has been read, which is always 8.
	assert_eq!(res, 8);
	let counter = u64::from_ne_bytes(buf);
	assert_eq!(counter, 1);
	});
	let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
	// Pass control to thread1 so it can block on eventfd `read`.
	thread::yield_now();
	// Write 1 to the counter to unblock thread1.
	let res = write_bytes(fd, sized_8_data);
	assert_eq!(res, 8);
	thread1.join().unwrap();
	}

	/// This test will block on eventfd `write` then get unblocked by `read`.
	fn test_blocking_write() {
	// eventfd write will block when EFD_NONBLOCK flag is clear
	// and the addition caused counter to exceed u64::MAX - 1.
	let flags = libc::EFD_CLOEXEC;
	let fd = unsafe { libc::eventfd(0, flags) };
	// Write u64 - 1, so the all subsequent write will block.
	let sized_8_data: [u8; 8] = (u64::MAX - 1).to_ne_bytes();
	let res: i64 = unsafe {
	libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
	};
	assert_eq!(res, 8);

	let thread1 = thread::spawn(move \|\| {
	let sized_8_data = 1_u64.to_ne_bytes();
	// Write 1 to the counter, this will block.
	let res: i64 = unsafe {
	libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
	};
	// Make sure that write is successful.
	assert_eq!(res, 8);
	});
	let mut buf: [u8; 8] = [0; 8];
	// Pass control to thread1 so it can block on eventfd `write`.
	thread::yield_now();
	// This will unblock previously blocked eventfd read.
	let res = read_bytes(fd, &mut buf);
	// read returns number of bytes has been read, which is always 8.
	assert_eq!(res, 8);
	let counter = u64::from_ne_bytes(buf);
	assert_eq!(counter, (u64::MAX - 1));
	thread1.join().unwrap();
	}

	// Test two threads blocked on eventfd.
	// Expected behaviour:
	// 1. thread1 and thread2 both blocked on `write`.
	// 2. thread3 unblocks both thread1 and thread2
	// 3. The write in thread1 and thread2 return successfully.
	fn test_two_threads_blocked_on_eventfd() {
	// eventfd write will block when EFD_NONBLOCK flag is clear
	// and the addition caused counter to exceed u64::MAX - 1.
	let flags = libc::EFD_CLOEXEC;
	let fd = unsafe { libc::eventfd(0, flags) };
	// Write u64 - 1, so the all subsequent write will block.
	let sized_8_data: [u8; 8] = (u64::MAX - 1).to_ne_bytes();
	let res: i64 = unsafe {
	libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
	};
	assert_eq!(res, 8);

	let thread1 = thread::spawn(move \|\| {
	let sized_8_data = 1_u64.to_ne_bytes();
	let res: i64 = unsafe {
	libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
	};
	// Make sure that write is successful.
	assert_eq!(res, 8);
	});

	let thread2 = thread::spawn(move \|\| {
	let sized_8_data = 1_u64.to_ne_bytes();
	let res: i64 = unsafe {
	libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
	};
	// Make sure that write is successful.
	assert_eq!(res, 8);
	});

	let thread3 = thread::spawn(move \|\| {
	let mut buf: [u8; 8] = [0; 8];
	// This will unblock previously blocked eventfd read.
	let res = read_bytes(fd, &mut buf);
	// read returns number of bytes has been read, which is always 8.
	assert_eq!(res, 8);
	let counter = u64::from_ne_bytes(buf);
	assert_eq!(counter, (u64::MAX - 1));
	});

	thread1.join().unwrap();
	thread2.join().unwrap();
	thread3.join().unwrap();
	}