Add getrlimit(2) and setrlimit(2)

src/sys/resource.rs

@@ -1,3 +1,4 @@
+//! Configure the process resource limits.
 use std::mem;
 
 use libc::{self, c_int, rlimit, RLIM_INFINITY};
@@ -39,18 +40,43 @@ libc_enum!{
         #[cfg(any(target_os = "android", target_os = "linux"))]
         RLIMIT_SIGPENDING,
 
-        // Non-Linux
+        // Available on some BSD
         #[cfg(target_os = "freebsd")]
         RLIMIT_KQUEUES,
         #[cfg(target_os = "freebsd")]
         RLIMIT_NPTS,
-        #[cfg(target_os = "freebsd")]
+        #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
         RLIMIT_SBSIZE,
         #[cfg(target_os = "freebsd")]
         RLIMIT_SWAP,
     }
 }
 
+/// Get the current processes resource limits
+///
+/// A value of `None` corresponds to `RLIM_INFINITY`, which means there's no limit.
+///
+/// # Parameters
+///
+/// * `resource`: The [`Resource`] that we want to get the limits of.
+///
+/// # Examples
+///
+/// ```
+/// use nix::sys::resource::{getrlimit, Resource};
+///
+/// fn main() {
+///     let (soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+///     println!("current soft_limit: {:?}", soft_limit);
+///     println!("current hard_limit: {:?}", hard_limit);
+/// }
+/// ```
+///
+/// # References
+///
+/// [getrlimit(2)](https://linux.die.net/man/2/getrlimit)
+///
+/// [`Resource`]: enum.Resource.html
 pub fn getrlimit(resource: Resource) -> Result<(Option<rlim_t>, Option<rlim_t>)> {
     let mut rlim: rlimit = unsafe { mem::uninitialized() };
     let res = unsafe { libc::getrlimit(resource as c_int, &mut rlim as *mut _) };
@@ -60,6 +86,34 @@ pub fn getrlimit(resource: Resource) -> Result<(Option<rlim_t>, Option<rlim_t>)>
     })
 }
 
+/// Set the current processes resource limits
+///
+/// A value of `None` corresponds to `RLIM_INFINITY`, which means there's no limit.
+///
+/// # Parameters
+///
+/// * `resource`: The [`Resource`] that we want to set the limits of.
+/// * `soft_limit`: The value that the kenrel enforces for the corresponding resource.
+/// * `hard_limit`: The ceiling for the soft limit. Must be lower or equal to the current hard limit
+///   for non-root users.
+///
+/// # Examples
+///
+/// ```no_run
+/// use nix::sys::resource::{setrlimit, Resource};
+///
+/// fn main() {
+///     let soft_limit = Some(1024);
+///     let hard_limit = None;
+///     setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
+/// }
+/// ```
+///
+/// # References
+///
+/// [setrlimit(2)](https://linux.die.net/man/2/setrlimit)
+///
+/// [`Resource`]: enum.Resource.html
 pub fn setrlimit(resource: Resource, soft_limit: Option<rlim_t>, hard_limit: Option<rlim_t>) -> Result<()> {
     let mut rlim: rlimit = unsafe { mem::uninitialized() };
     rlim.rlim_cur = soft_limit.unwrap_or(RLIM_INFINITY);

test/test_resource.rs

@@ -1,7 +1,22 @@
 use nix::sys::resource::{Resource, getrlimit, setrlimit};
 
 #[test]
-pub fn test_resource_limits() {
+pub fn test_resource_limits_nofile() {
+    let (soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+
+    // make sure the soft limit and hard limit are not equal
+    let soft_limit = match soft_limit {
+        Some(nofile) => Some(nofile -1),
+        None => Some(1024),
+    };
+    setrlimit(Resource::RLIMIT_NOFILE, soft_limit, hard_limit).unwrap();
+
+    let (new_soft_limit, new_hard_limit) = getrlimit(Resource::RLIMIT_NOFILE).unwrap();
+    assert!(new_soft_limit != new_hard_limit);
+}
+
+#[test]
+pub fn test_resource_limits_stack() {
     let (mut soft_limit, hard_limit) = getrlimit(Resource::RLIMIT_STACK).unwrap();
     let orig_limit = (soft_limit, hard_limit);