From 09a654a6228c5b19ae4c640350019e3b0bdacd20 Mon Sep 17 00:00:00 2001 From: Daniel Ohlsson Date: Fri, 15 Apr 2022 10:28:58 -0600 Subject: [PATCH] Remove unnecessary PrctlOption enum --- src/sys/prctl.rs | 139 ++++++----------------------------------------- 1 file changed, 16 insertions(+), 123 deletions(-) diff --git a/src/sys/prctl.rs b/src/sys/prctl.rs index 6c43b04f1a..c7ddc1c9d9 100644 --- a/src/sys/prctl.rs +++ b/src/sys/prctl.rs @@ -13,113 +13,6 @@ use libc::{c_char, c_int, c_ulong}; use std::convert::TryFrom; use std::ffi::{CStr, CString}; -pub use self::PrctlOption::*; - -libc_enum! { - /// Types of prctl options see [prctl(2)](https://man7.org/linux/man-pages/man2/prctl.2.html) for more information. - - #[repr(i32)] - #[non_exhaustive] - #[allow(non_camel_case_types)] - pub enum PrctlOption { - /// Set the parent-death signal of the calling process to arg2 - PR_SET_PDEATHSIG, - /// Read the current parent-death signal into the location pointed to by arg2 - PR_GET_PDEATHSIG, - /// Return from the function the calling process's dumpable attribute - PR_GET_DUMPABLE, - /// Set the process's dumpable attribute to arg2 - PR_SET_DUMPABLE, - /// Read the current access control bits into the location pointed to by arg2. PowerPC - /// only. - PR_GET_UNALIGN, - /// Set unaligned access control bits to arg2. PowerPC only. - PR_SET_UNALIGN, - /// Set the calling thread's "keep capabilities" flag. arg2 must be either 0 (clear the - /// flag) or 1 (set the flag) - PR_GET_KEEPCAPS, - /// Return from the function the calling thread's "keep capabilities" flag - PR_SET_KEEPCAPS, - /// Read floating-point exception mode into the location pointed to by arg2. PowerPC only. - PR_GET_FPEXC, - /// Set floating-point exception mode to arg2. PowerPC only. - PR_SET_FPEXC, - /// Return from the function which process timing method is currently in use - PR_GET_TIMING, - /// Set process timing method to arg2 - PR_SET_TIMING, - /// Set the name of the calling thread (max 16 bytes) to the value in the location pointed - /// to by (char *) arg2 - PR_SET_NAME, - /// Read the name of the calling thread into the buffer pointed to by (char *) arg2 - PR_GET_NAME, - /// Read the endian-ness of the calling process into the location pointed to by arg2. - /// PowerPC only. - PR_GET_ENDIAN, - /// Set the endian-ness of the calling process to arg2. PowerPC only. - PR_SET_ENDIAN, - /// Return from the function the secure computing mode of the calling thread - PR_GET_SECCOMP, - /// Set the "securebits" flags of the calling thread to the value supplied in arg2. See - /// capabilities(7) - PR_SET_SECCOMP, - /// Return 1 from the function if the capability specified in arg2 is in the calling - /// thread's capability bounding set, or 0 if it is not - PR_CAPBSET_READ, - /// Drop the capability specified in arg2 from the calling thread's capability bounding set - PR_CAPBSET_DROP, - /// Read the state of the timestamp counter flag into the location pointed to by arg2 - PR_GET_TSC, - /// Set the state of the timestamp counter flag to arg2 - PR_SET_TSC, - /// Return from the function the "securebits" flags of the calling thread. See - /// capabilities(7) - PR_GET_SECUREBITS, - /// Set the "securebits" flags of the calling thread to arg2 - PR_SET_SECUREBITS, - /// Set the timer slack value for the calling thread to arg2 - PR_SET_TIMERSLACK, - /// Return from the function the current timer slack value of the calling thread - PR_GET_TIMERSLACK, - /// Disable all performance counters attached to the calling process - PR_TASK_PERF_EVENTS_DISABLE, - /// Enable performance counters attached to the calling process - PR_TASK_PERF_EVENTS_ENABLE, - /// Set the machine check memory corruption kill policy for the calling thread to arg2 - PR_MCE_KILL, - /// Return from the function the current machine check kill policy - PR_MCE_KILL_GET, - /// Modify certain kernel memory map descriptor fields of the calling process - PR_SET_MM, - /// Set the process ID that is allowed to ptrace this process. Only relevant when Yama LSM - /// is enabled. - PR_SET_PTRACER, - /// Set the "child subreaper" attribute of the calling process to arg2 - PR_SET_CHILD_SUBREAPER, - /// Read the "child subreaper" attribute of the calling process into the location pointed - /// to by arg2 - PR_GET_CHILD_SUBREAPER, - /// Set the calling thread's "no new privs" attribute to the value in arg2 - PR_SET_NO_NEW_PRIVS, - /// Return from the function the value of the "no new privs" attribute for the calling - /// thread - PR_GET_NO_NEW_PRIVS, - /// Read the "clear child tid" address into the location pointed to by (int **) arg2 - PR_GET_TID_ADDRESS, - /// Set the state of the "THP disable" flag for the calling thread to arg2 - PR_SET_THP_DISABLE, - /// return from the function the "THP disable" flag for the calling thread - PR_GET_THP_DISABLE, - /// Set the MIPS "floating-point mode" for the process to arg2. MIPS only. - PR_SET_FP_MODE, - /// Return from the function the "floatin-point mode" for the process. MIPS only. - PR_GET_FP_MODE, - /// Reads or changes the ambient capability set of the calling thread, according to the - /// value of arg2 - PR_CAP_AMBIENT, - } -} - libc_enum! { /// The type of hardware memory corruption kill policy for the thread. @@ -137,14 +30,14 @@ libc_enum! { impl TryFrom } -fn prctl_set_bool(option: PrctlOption, status: bool) -> Result<()> { - let res = unsafe { libc::prctl(option as c_int, status as c_ulong, 0, 0, 0) }; +fn prctl_set_bool(option: c_int, status: bool) -> Result<()> { + let res = unsafe { libc::prctl(option, status as c_ulong, 0, 0, 0) }; Errno::result(res).map(drop) } /// Set the "child subreaper" attribute for this process pub fn set_child_subreaper(attribute: bool) -> Result<()> { - prctl_set_bool(PR_SET_CHILD_SUBREAPER, attribute) + prctl_set_bool(libc::PR_SET_CHILD_SUBREAPER, attribute) } /// Get the "child subreaper" attribute for this process @@ -152,19 +45,19 @@ pub fn get_child_subreaper() -> Result { // prctl writes into this var let mut subreaper: c_int = 0; - let res = unsafe { libc::prctl(PR_GET_CHILD_SUBREAPER as c_int, &mut subreaper, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_GET_CHILD_SUBREAPER, &mut subreaper, 0, 0, 0) }; Errno::result(res).map(|_| subreaper != 0) } /// Set the dumpable attribute which determines if core dumps are created for this process. pub fn set_dumpable(attribute: bool) -> Result<()> { - prctl_set_bool(PR_SET_DUMPABLE, attribute) + prctl_set_bool(libc::PR_SET_DUMPABLE, attribute) } /// Get the dumpable attribute for this process. pub fn get_dumpable() -> Result { - let res = unsafe { libc::prctl(PR_GET_DUMPABLE as c_int, 0, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_GET_DUMPABLE, 0, 0, 0, 0) }; Errno::result(res).map(|res| res != 0) } @@ -172,19 +65,19 @@ pub fn get_dumpable() -> Result { /// Set the "keep capabilities" attribute for this process. This causes the thread to retain /// capabilities even if it switches its UID to a nonzero value. pub fn set_keepcaps(attribute: bool) -> Result<()> { - prctl_set_bool(PR_SET_KEEPCAPS, attribute) + prctl_set_bool(libc::PR_SET_KEEPCAPS, attribute) } /// Get the "keep capabilities" attribute for this process pub fn get_keepcaps() -> Result { - let res = unsafe { libc::prctl(PR_GET_KEEPCAPS as c_int, 0, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_GET_KEEPCAPS, 0, 0, 0, 0) }; Errno::result(res).map(|res| res != 0) } /// Clear the thread memory corruption kill policy and use the system-wide default pub fn clear_mce_kill() -> Result<()> { - let res = unsafe { libc::prctl(PR_MCE_KILL as c_int, libc::PR_MCE_KILL_CLEAR, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_MCE_KILL, libc::PR_MCE_KILL_CLEAR, 0, 0, 0) }; Errno::result(res).map(drop) } @@ -193,7 +86,7 @@ pub fn clear_mce_kill() -> Result<()> { pub fn set_mce_kill(policy: PrctlMCEKillPolicy) -> Result<()> { let res = unsafe { libc::prctl( - PR_MCE_KILL as c_int, + libc::PR_MCE_KILL, libc::PR_MCE_KILL_SET, policy as c_ulong, 0, @@ -206,7 +99,7 @@ pub fn set_mce_kill(policy: PrctlMCEKillPolicy) -> Result<()> { /// Get the thread memory corruption kill policy pub fn get_mce_kill() -> Result { - let res = unsafe { libc::prctl(PR_MCE_KILL_GET as c_int, 0, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_MCE_KILL_GET, 0, 0, 0, 0) }; match Errno::result(res) { Ok(val) => Ok(PrctlMCEKillPolicy::try_from(val)?), @@ -222,7 +115,7 @@ pub fn set_pdeathsig>>(signal: T) -> Result<()> { None => 0, }; - let res = unsafe { libc::prctl(PR_SET_PDEATHSIG as c_int, sig, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_SET_PDEATHSIG, sig, 0, 0, 0) }; Errno::result(res).map(drop) } @@ -232,7 +125,7 @@ pub fn get_pdeathsig() -> Result> { // prctl writes into this var let mut sig: c_int = 0; - let res = unsafe { libc::prctl(PR_GET_PDEATHSIG as c_int, &mut sig, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_GET_PDEATHSIG, &mut sig, 0, 0, 0) }; match Errno::result(res) { Ok(_) => Ok(match sig { @@ -244,10 +137,10 @@ pub fn get_pdeathsig() -> Result> { } /// Set the name of the calling thread (max 15 bytes) -pub fn set_name(name: &String) -> Result<()> { +pub fn set_name(name: &str) -> Result<()> { let name = CString::new(name.as_bytes()).unwrap(); - let res = unsafe { libc::prctl(PR_SET_NAME as c_int, name.as_ptr(), 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_SET_NAME, name.as_ptr(), 0, 0, 0) }; Errno::result(res).map(drop) } @@ -256,7 +149,7 @@ pub fn set_name(name: &String) -> Result<()> { pub fn get_name() -> Result { let buf = [32u8; 16]; - let res = unsafe { libc::prctl(PR_GET_NAME as c_int, &buf, 0, 0, 0) }; + let res = unsafe { libc::prctl(libc::PR_GET_NAME, &buf, 0, 0, 0) }; let ptr = buf.as_ptr() as *const c_char; let cstr = unsafe { CStr::from_ptr(ptr) };