mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #124879 - workingjubilee:rollup-1k77hyz, r=workingjubilee

Browse Source 
Rollup of 4 pull requests

Successful merges:

 - #124470 (std::net: Socket::new_raw now set to SO_NOSIGPIPE on freebsd.)
 - #124782 (add note about `AlreadyExists` to `create_new`)
 - #124788 (Convert instances of `target_os = "macos"` to `target_vendor = "apple"`)
 - #124838 (next_power_of_two: add a doctest to show what happens on 0)

r? `@ghost`
`@rustbot` modify labels: rollup
This commit is contained in:
bors 2024-05-08 09:29:57 +00:00
commit 1fef1524f2
8 changed files with 50 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
library/core/src/num/uint_macros.rs
View File

@ -2764,6 +2764,7 @@ const fn one_less_than_next_power_of_two(self) -> Self {
/// ```
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".next_power_of_two(), 2);")]
#[doc = concat!("assert_eq!(3", stringify!($SelfT), ".next_power_of_two(), 4);")]
#[doc = concat!("assert_eq!(0", stringify!($SelfT), ".next_power_of_two(), 1);")]
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_stable(feature = "const_int_pow", since = "1.50.0")]

9
library/std/src/fs.rs
View File

@ -408,6 +408,9 @@ pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File> {
///
/// This function will create a file if it does not exist, or return an error if it does. This
/// way, if the call succeeds, the file returned is guaranteed to be new.
/// If a file exists at the target location, creating a new file will fail with [`AlreadyExists`]
/// or another error based on the situation. See [`OpenOptions::open`] for a
/// non-exhaustive list of likely errors.
///
/// This option is useful because it is atomic. Otherwise between checking whether a file
/// exists and creating a new one, the file may have been created by another process (a TOCTOU
@ -416,6 +419,8 @@ pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File> {
/// This can also be written using
/// `File::options().read(true).write(true).create_new(true).open(...)`.
///
/// [`AlreadyExists`]: crate::io::ErrorKind::AlreadyExists
///
/// # Examples
///
/// ```no_run
@ -1071,6 +1076,9 @@ pub fn create(&mut self, create: bool) -> &mut Self {
///
/// No file is allowed to exist at the target location, also no (dangling) symlink. In this
/// way, if the call succeeds, the file returned is guaranteed to be new.
/// If a file exists at the target location, creating a new file will fail with [`AlreadyExists`]
/// or another error based on the situation. See [`OpenOptions::open`] for a
/// non-exhaustive list of likely errors.
///
/// This option is useful because it is atomic. Otherwise between checking
/// whether a file exists and creating a new one, the file may have been
@ -1084,6 +1092,7 @@ pub fn create(&mut self, create: bool) -> &mut Self {
///
/// [`.create()`]: OpenOptions::create
/// [`.truncate()`]: OpenOptions::truncate
/// [`AlreadyExists`]: io::ErrorKind::AlreadyExists
///
/// # Examples
///

12
library/std/src/os/unix/net/listener.rs
View File

@ -81,21 +81,25 @@ pub fn bind<P: AsRef<Path>>(path: P) -> io::Result<UnixListener> {
))]
const backlog: core::ffi::c_int = 128;
#[cfg(any(
// Silently capped to `/proc/sys/net/core/somaxconn`.
target_os = "linux",
// Silently capped to `kern.ipc.soacceptqueue`.
target_os = "freebsd",
// Silently capped to `kern.somaxconn sysctl`.
target_os = "openbsd",
target_os = "macos"
// Silently capped to the default 128.
target_vendor = "apple",
))]
const backlog: core::ffi::c_int = -1;
#[cfg(not(any(
target_os = "windows",
target_os = "redox",
target_os = "espidf",
target_os = "horizon",
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd",
target_os = "macos",
target_os = "espidf",
target_os = "horizon"
target_vendor = "apple",
)))]
const backlog: libc::c_int = libc::SOMAXCONN;

8
library/std/src/sys/pal/unix/alloc.rs
View File

@ -13,7 +13,13 @@ unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
libc::malloc(layout.size()) as *mut u8
} else {
#[cfg(target_os = "macos")]
// `posix_memalign` returns a non-aligned value if supplied a very
// large alignment on older versions of Apple's platforms (unknown
// exactly which version range, but the issue is definitely
// present in macOS 10.14 and iOS 13.3).
//
// <https://github.com/rust-lang/rust/issues/30170>
#[cfg(target_vendor = "apple")]
{
if layout.align() > (1 << 31) {
return ptr::null_mut();

11
library/std/src/sys/pal/unix/fd.rs
View File

@ -33,14 +33,15 @@
// with the man page quoting that if the count of bytes to read is
// greater than `SSIZE_MAX` the result is "unspecified".
//
// On macOS, however, apparently the 64-bit libc is either buggy or
// On Apple targets however, apparently the 64-bit libc is either buggy or
// intentionally showing odd behavior by rejecting any read with a size
// larger than or equal to INT_MAX. To handle both of these the read
// size is capped on both platforms.
#[cfg(target_os = "macos")]
const READ_LIMIT: usize = libc::c_int::MAX as usize - 1;
#[cfg(not(target_os = "macos"))]
const READ_LIMIT: usize = libc::ssize_t::MAX as usize;
const READ_LIMIT: usize = if cfg!(target_vendor = "apple") {
libc::c_int::MAX as usize - 1
} else {
libc::ssize_t::MAX as usize
};
#[cfg(any(
target_os = "dragonfly",

18
library/std/src/sys/pal/unix/fs.rs
View File

@ -1493,11 +1493,11 @@ fn get_path(fd: c_int) -> Option<PathBuf> {
readlink(&p).ok()
}
#[cfg(target_os = "macos")]
#[cfg(target_vendor = "apple")]
fn get_path(fd: c_int) -> Option<PathBuf> {
// FIXME: The use of PATH_MAX is generally not encouraged, but it
// is inevitable in this case because macOS defines `fcntl` with
// `F_GETPATH` in terms of `MAXPATHLEN`, and there are no
// is inevitable in this case because Apple targets define `fcntl`
// with `F_GETPATH` in terms of `MAXPATHLEN`, and there are no
// alternatives. If a better method is invented, it should be used
// instead.
let mut buf = vec![0; libc::PATH_MAX as usize];
@ -1538,12 +1538,12 @@ fn get_path(fd: c_int) -> Option<PathBuf> {
#[cfg(not(any(
target_os = "linux",
target_os = "macos",
target_os = "vxworks",
all(target_os = "freebsd", target_arch = "x86_64"),
target_os = "netbsd",
target_os = "illumos",
target_os = "solaris"
target_os = "solaris",
target_vendor = "apple",
)))]
fn get_path(_fd: c_int) -> Option<PathBuf> {
// FIXME(#24570): implement this for other Unix platforms
@ -1552,12 +1552,12 @@ fn get_path(_fd: c_int) -> Option<PathBuf> {
#[cfg(any(
target_os = "linux",
target_os = "macos",
target_os = "freebsd",
target_os = "hurd",
target_os = "netbsd",
target_os = "openbsd",
target_os = "vxworks"
target_os = "vxworks",
target_vendor = "apple",
))]
fn get_mode(fd: c_int) -> Option<(bool, bool)> {
let mode = unsafe { libc::fcntl(fd, libc::F_GETFL) };
@ -1574,12 +1574,12 @@ fn get_mode(fd: c_int) -> Option<(bool, bool)> {
#[cfg(not(any(
target_os = "linux",
target_os = "macos",
target_os = "freebsd",
target_os = "hurd",
target_os = "netbsd",
target_os = "openbsd",
target_os = "vxworks"
target_os = "vxworks",
target_vendor = "apple",
)))]
fn get_mode(_fd: c_int) -> Option<(bool, bool)> {
// FIXME(#24570): implement this for other Unix platforms

4
library/std/src/sys/pal/unix/mod.rs
View File

@ -63,11 +63,11 @@ pub unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
args::init(argc, argv);
// Normally, `thread::spawn` will call `Thread::set_name` but since this thread
// already exists, we have to call it ourselves. We only do this on macos
// already exists, we have to call it ourselves. We only do this on Apple targets
// because some unix-like operating systems such as Linux share process-id and
// thread-id for the main thread and so renaming the main thread will rename the
// process and we only want to enable this on platforms we've tested.
if cfg!(target_os = "macos") {
if cfg!(target_vendor = "apple") {
thread::Thread::set_name(&c"main");
}

9
library/std/src/sys/pal/unix/net.rs
View File

@ -86,7 +86,14 @@ pub fn new_raw(fam: c_int, ty: c_int) -> io::Result<Socket> {
// flag to atomically create the socket and set it as
// CLOEXEC. On Linux this was added in 2.6.27.
let fd = cvt(libc::socket(fam, ty | libc::SOCK_CLOEXEC, 0))?;
Ok(Socket(FileDesc::from_raw_fd(fd)))
let socket = Socket(FileDesc::from_raw_fd(fd));
// DragonFlyBSD, FreeBSD and NetBSD use `SO_NOSIGPIPE` as a `setsockopt`
// flag to disable `SIGPIPE` emission on socket.
#[cfg(any(target_os = "freebsd", target_os = "netbsd", target_os = "dragonfly"))]
setsockopt(&socket, libc::SOL_SOCKET, libc::SO_NOSIGPIPE, 1)?;
Ok(socket)
} else {
let fd = cvt(libc::socket(fam, ty, 0))?;
let fd = FileDesc::from_raw_fd(fd);