1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Various utility functions useful for writing I/O tests
19 use std::io::net::ip::*;
20 use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
22 /// Get a port number, starting at 9600, for use in tests
23 pub fn next_test_port() -> u16 {
24 static NEXT_OFFSET: AtomicUint = ATOMIC_UINT_INIT;
25 base_port() + NEXT_OFFSET.fetch_add(1, Ordering::Relaxed) as u16
28 /// Get a temporary path which could be the location of a unix socket
29 pub fn next_test_unix() -> Path {
30 static COUNT: AtomicUint = ATOMIC_UINT_INIT;
31 // base port and pid are an attempt to be unique between multiple
32 // test-runners of different configurations running on one
33 // buildbot, the count is to be unique within this executable.
34 let string = format!("rust-test-unix-path-{}-{}-{}",
36 unsafe {libc::getpid()},
37 COUNT.fetch_add(1, Ordering::Relaxed));
39 os::tmpdir().join(string)
41 Path::new(format!("{}{}", r"\\.\pipe\", string))
45 /// Get a unique IPv4 localhost:port pair starting at 9600
46 pub fn next_test_ip4() -> SocketAddr {
47 SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: next_test_port() }
50 /// Get a unique IPv6 localhost:port pair starting at 9600
51 pub fn next_test_ip6() -> SocketAddr {
52 SocketAddr { ip: Ipv6Addr(0, 0, 0, 0, 0, 0, 0, 1), port: next_test_port() }
56 XXX: Welcome to MegaHack City.
58 The bots run multiple builds at the same time, and these builds
59 all want to use ports. This function figures out which workspace
60 it is running in and assigns a port range based on it.
62 fn base_port() -> u16 {
68 ("32-opt", base + range * 1),
69 ("32-nopt", base + range * 2),
70 ("64-opt", base + range * 3),
71 ("64-nopt", base + range * 4),
72 ("64-opt-vg", base + range * 5),
73 ("all-opt", base + range * 6),
74 ("snap3", base + range * 7),
75 ("dist", base + range * 8)
78 // FIXME (#9639): This needs to handle non-utf8 paths
79 let path = os::getcwd().unwrap();
80 let path_s = path.as_str().unwrap();
82 let mut final_base = base;
84 for &(dir, base) in bases.iter() {
85 if path_s.contains(dir) {
94 /// Raises the file descriptor limit when running tests if necessary
95 pub fn raise_fd_limit() {
96 unsafe { darwin_fd_limit::raise_fd_limit() }
99 /// darwin_fd_limit exists to work around an issue where launchctl on Mac OS X defaults the rlimit
100 /// maxfiles to 256/unlimited. The default soft limit of 256 ends up being far too low for our
101 /// multithreaded scheduler testing, depending on the number of cores available.
103 /// This fixes issue #7772.
104 #[cfg(target_os="macos")]
105 #[allow(non_camel_case_types)]
106 mod darwin_fd_limit {
108 type rlim_t = libc::uint64_t;
115 // name probably doesn't need to be mut, but the C function doesn't specify const
116 fn sysctl(name: *mut libc::c_int, namelen: libc::c_uint,
117 oldp: *mut libc::c_void, oldlenp: *mut libc::size_t,
118 newp: *mut libc::c_void, newlen: libc::size_t) -> libc::c_int;
119 fn getrlimit(resource: libc::c_int, rlp: *mut rlimit) -> libc::c_int;
120 fn setrlimit(resource: libc::c_int, rlp: *const rlimit) -> libc::c_int;
122 static CTL_KERN: libc::c_int = 1;
123 static KERN_MAXFILESPERPROC: libc::c_int = 29;
124 static RLIMIT_NOFILE: libc::c_int = 8;
126 pub unsafe fn raise_fd_limit() {
127 // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
128 // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
130 use mem::size_of_val;
131 use os::last_os_error;
133 // Fetch the kern.maxfilesperproc value
134 let mut mib: [libc::c_int; 2] = [CTL_KERN, KERN_MAXFILESPERPROC];
135 let mut maxfiles: libc::c_int = 0;
136 let mut size: libc::size_t = size_of_val(&maxfiles) as libc::size_t;
137 if sysctl(&mut mib[0], 2, &mut maxfiles as *mut libc::c_int as *mut libc::c_void, &mut size,
138 null_mut(), 0) != 0 {
139 let err = last_os_error();
140 panic!("raise_fd_limit: error calling sysctl: {}", err);
143 // Fetch the current resource limits
144 let mut rlim = rlimit{rlim_cur: 0, rlim_max: 0};
145 if getrlimit(RLIMIT_NOFILE, &mut rlim) != 0 {
146 let err = last_os_error();
147 panic!("raise_fd_limit: error calling getrlimit: {}", err);
150 // Bump the soft limit to the smaller of kern.maxfilesperproc and the hard limit
151 rlim.rlim_cur = ::cmp::min(maxfiles as rlim_t, rlim.rlim_max);
153 // Set our newly-increased resource limit
154 if setrlimit(RLIMIT_NOFILE, &rlim) != 0 {
155 let err = last_os_error();
156 panic!("raise_fd_limit: error calling setrlimit: {}", err);
161 #[cfg(not(target_os="macos"))]
162 mod darwin_fd_limit {
163 pub unsafe fn raise_fd_limit() {}