view rust/chg/src/procutil.rs @ 50400:95acba2c29f6

encoding: avoid quadratic time complexity when json-encoding non-UTF8 strings Apparently the code uses "+=" with a bytes object, which is linear-time, so the whole encoding is quadratic-time. This patch makes us use a bytearray object, instead, which has a(n amortized-)constant-time append operation. The encoding is still not particularly fast, but at least a 10MB file takes tens of seconds, not many hours to encode.
author Arseniy Alekseyev <aalekseyev@janestreet.com>
date Mon, 06 Mar 2023 11:27:57 +0000
parents 426294d06ddc
children
line wrap: on
line source

// Copyright 2018 Yuya Nishihara <yuya@tcha.org>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.

//! Low-level utility for signal and process handling.

use libc::{self, c_int, pid_t, size_t, ssize_t};
use std::io;
use std::os::unix::io::RawFd;
use std::sync;

#[link(name = "procutil", kind = "static")]
extern "C" {
    // sendfds.c
    fn sendfds(sockfd: c_int, fds: *const c_int, fdlen: size_t) -> ssize_t;

    // sighandlers.c
    fn setupsignalhandler(pid: pid_t, pgid: pid_t) -> c_int;
    fn restoresignalhandler() -> c_int;
}

/// Returns the effective uid of the current process.
pub fn get_effective_uid() -> u32 {
    unsafe { libc::geteuid() }
}

/// Returns the umask of the current process.
///
/// # Safety
///
/// This is unsafe because the umask value is temporarily changed, and
/// the change can be observed from the other threads. Don't call this in
/// multi-threaded context.
pub unsafe fn get_umask() -> u32 {
    let mask = libc::umask(0);
    libc::umask(mask);
    mask
}

/// Changes the given fd to blocking mode.
pub fn set_blocking_fd(fd: RawFd) -> io::Result<()> {
    let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
    if flags < 0 {
        return Err(io::Error::last_os_error());
    }
    let r =
        unsafe { libc::fcntl(fd, libc::F_SETFL, flags & !libc::O_NONBLOCK) };
    if r < 0 {
        return Err(io::Error::last_os_error());
    }
    Ok(())
}

/// Sends file descriptors via the given socket.
pub fn send_raw_fds(sock_fd: RawFd, fds: &[RawFd]) -> io::Result<()> {
    let r = unsafe { sendfds(sock_fd, fds.as_ptr(), fds.len() as size_t) };
    if r < 0 {
        return Err(io::Error::last_os_error());
    }
    Ok(())
}

static SETUP_SIGNAL_HANDLER: sync::Once = sync::Once::new();
static RESTORE_SIGNAL_HANDLER: sync::Once = sync::Once::new();

/// Installs signal handlers to forward signals to the server.
///
/// # Safety
///
/// This touches global states, and thus synchronized as a one-time
/// initialization function.
pub fn setup_signal_handler_once(
    pid: u32,
    pgid: Option<u32>,
) -> io::Result<()> {
    let pid_signed = pid as i32;
    let pgid_signed = pgid.map(|n| n as i32).unwrap_or(0);
    let mut r = 0;
    SETUP_SIGNAL_HANDLER.call_once(|| {
        r = unsafe { setupsignalhandler(pid_signed, pgid_signed) };
    });
    if r < 0 {
        return Err(io::Error::last_os_error());
    }
    Ok(())
}

/// Restores the original signal handlers.
///
/// # Safety
///
/// This touches global states, and thus synchronized as a one-time
/// initialization function.
pub fn restore_signal_handler_once() -> io::Result<()> {
    let mut r = 0;
    RESTORE_SIGNAL_HANDLER.call_once(|| {
        r = unsafe { restoresignalhandler() };
    });
    if r < 0 {
        return Err(io::Error::last_os_error());
    }
    Ok(())
}