Struct Guard 

pub struct Guard<'a, B, G> {
    pub base: &'a B,
    /* private fields */
}

Fields

base: &'a B

Implementations

impl<'guard, G: 'guard + Deref<Target = TerminalMutableState>> Guard<'guard, Terminal, G>

pub fn termios(&self) -> &termios

Returns the terminal configuration.

pub fn get_available_read_size(&self, is_main: bool) -> usize

Returns the number of available bytes to read from the side of the terminal described by is_main.

pub fn is_main_closed(&self) -> bool

impl<'guard, G: 'guard + DerefMut<Target = TerminalMutableState>> Guard<'guard, Terminal, G>

pub fn main_close(&mut self)

close implementation of the main side of the terminal.

pub fn main_open(&mut self)

Called when a new reference to the main side of this terminal is made.

pub fn replica_close(&mut self)

close implementation of the replica side of the terminal.

pub fn replica_open(&mut self)

Called when a new reference to the replica side of this terminal is made.

impl<'a, B, S> Guard<'a, B, MutexGuard<'a, S>>

pub fn unlocked<F, U>(s: &mut Self, f: F) -> U

where F: FnOnce() -> U,

impl<'guard, B, S, G: 'guard + Deref<Target = S>> Guard<'guard, B, G>

pub fn new(base: &'guard B, guard: G) -> Self

pub fn as_ref(&self) -> StateRef<'_, B, S>

impl<'guard, B, S, G: 'guard + DerefMut<Target = S>> Guard<'guard, B, G>

pub fn as_mut(&mut self) -> StateMutRef<'_, B, S>

impl<'guard, G: 'guard + Deref<Target = ProcessGroupMutableState>> Guard<'guard, ProcessGroup, G>

pub fn thread_groups(&self) -> Box<dyn Iterator<Item = Arc<ThreadGroup>> + '_>

impl<'guard, G: 'guard + Deref<Target = SessionMutableState>> Guard<'guard, Session, G>

pub fn get_foreground_process_group_leader(&self) -> pid_t

pub fn get_foreground_process_group(&self) -> Option<Arc<ProcessGroup>>

impl<'guard, G: 'guard + DerefMut<Target = SessionMutableState>> Guard<'guard, Session, G>

pub fn remove(&mut self, pid: pid_t)

Removes the process group from the session. Returns whether the session is empty.

pub fn insert(&mut self, process_group: &Arc<ProcessGroup>)

pub fn set_foreground_process_group( &mut self, process_group: &Arc<ProcessGroup>, )

impl<'guard, G: 'guard + Deref<Target = TaskMutableState>> Guard<'guard, Task, G>

pub fn pending_signal_count(&self) -> usize

Returns the number of pending signals for this task, without considering the signal mask.

pub fn has_signal_pending(&self, signal: Signal) -> bool

Returns true if signal is pending for this task, without considering the signal mask.

pub fn pending_signals(&self) -> SigSet

The set of pending signals for the task, including the signals pending for the thread group.

pub fn task_specific_pending_signals(&self) -> SigSet

The set of pending signals for the task specifically, not including the signals pending for the thread group.

pub fn is_any_signal_allowed_by_mask(&self, mask: SigSet) -> bool

Returns true if any currently pending signal is allowed by mask.

pub fn is_any_signal_pending(&self) -> bool

Returns whether or not a signal is pending for this task, taking the current signal mask into account.

impl<'guard, G: 'guard + DerefMut<Target = TaskMutableState>> Guard<'guard, Task, G>

pub fn set_stopped( &mut self, stopped: StopState, siginfo: Option<SignalInfo>, current_task: Option<&CurrentTask>, event: Option<PtraceEventData>, )

pub fn set_ptrace( &mut self, tracer: Option<Box<PtraceState>>, ) -> Result<(), Errno>

pub fn can_accept_ptrace_commands(&mut self) -> bool

pub fn update_flags(&mut self, clear: TaskFlags, set: TaskFlags)

pub fn set_flags(&mut self, flag: TaskFlags, v: bool)

pub fn set_exit_status(&mut self, status: ExitStatus)

pub fn set_exit_status_if_not_already(&mut self, status: ExitStatus)

pub fn take_specific_signal( &mut self, siginfo: SignalInfo, ) -> Option<SignalInfo>

Removes and returns the next pending signal for this task.

Returns None if siginfo is a blocked signal, or no such signal is pending.

pub fn take_any_signal(&mut self) -> Option<SignalInfo>

Removes and returns a pending signal that is unblocked by the current signal mask.

Returns None if there are no unblocked signals pending.

pub fn take_signal_with_mask( &mut self, signal_mask: SigSet, ) -> Option<SignalInfo>

Removes and returns a pending signal that is unblocked by signal_mask.

Returns None if there are no signals pending that are unblocked by signal_mask.

pub fn take_kernel_signal(&mut self) -> Option<KernelSignal>

Removes and returns a pending internal signal.

Returns None if there are no signals pending.

impl<'guard, G: 'guard + Deref<Target = ThreadGroupMutableState>> Guard<'guard, ThreadGroup, G>

pub fn leader(&self) -> pid_t

pub fn leader_command(&self) -> TaskCommand

pub fn is_terminating(&self) -> bool

pub fn children(&self) -> impl Iterator<Item = Arc<ThreadGroup>> + '_

pub fn tasks(&self) -> impl Iterator<Item = TempRef<'_, Task>> + '_

pub fn task_ids(&self) -> impl Iterator<Item = &tid_t>

pub fn contains_task(&self, tid: tid_t) -> bool

pub fn get_task(&self, tid: tid_t) -> Option<TempRef<'_, Task>>

pub fn tasks_count(&self) -> usize

pub fn get_ppid(&self) -> pid_t

pub fn is_waitable(&self) -> bool

Indicates whether the thread group is waitable via waitid and waitpid for either WSTOPPED or WCONTINUED.

pub fn is_correct_exit_signal( for_clone: bool, exit_code: Option<Signal>, ) -> bool

pub fn get_live_task(&self) -> Result<TempRef<'_, Task>, Errno>

Returns a task in the current thread group.

impl<'guard, G: 'guard + DerefMut<Target = ThreadGroupMutableState>> Guard<'guard, ThreadGroup, G>

pub fn get_waitable_zombie( &mut self, zombie_list: &dyn Fn(&mut ThreadGroupMutableState) -> &mut Vec<OwnedRef<ZombieProcess>>, selector: &ProcessSelector, options: &WaitingOptions, pids: &mut PidTable, ) -> Option<WaitResult>

pub fn get_waitable_child( &mut self, selector: &ProcessSelector, options: &WaitingOptions, pids: &mut PidTable, ) -> WaitableChildResult

Returns any waitable child matching the given selector and options. Returns None if no child matching the selector is waitable. Returns ECHILD if no child matches the selector at all.

Will remove the waitable status from the child depending on options.

pub fn set_stopped( self, new_stopped: StopState, siginfo: Option<SignalInfo>, finalize_only: bool, ) -> StopState

Set the stop status of the process. If you pass |siginfo| of |None|, does not update the signal. If |finalize_only| is set, will check that the set will be a finalize (Stopping -> Stopped or Stopped -> Stopped) before executing it.

Returns the latest stop state after any changes.

pub fn send_signal(self, signal_info: SignalInfo)

Sends the signal signal_info to this thread group.

impl<'guard, G: 'guard + Deref<Target = DirEntryState>> Guard<'guard, DirEntry, G>

pub fn local_name(&self) -> &FsStr

pub fn parent(&self) -> &Option<DirEntryHandle>

pub fn is_dead(&self) -> bool

Whether this directory entry has been removed from the tree.

impl<'guard, G: 'guard + Deref<Target = MountState>> Guard<'guard, Arc<Mount>, G>

pub fn is_shared(&self) -> bool

Is the mount in a peer group? Corresponds to MS_SHARED.

impl<'guard, G: 'guard + DerefMut<Target = MountState>> Guard<'guard, Arc<Mount>, G>

pub fn make_shared(&mut self)

Put the mount in a peer group. Implements MS_SHARED.

pub fn make_private(&mut self)

Take the mount out of its peer group, also remove upstream if any. Implements MS_PRIVATE.

pub fn make_downstream(&mut self)

Take the mount out of its peer group and make it downstream instead. Implements MountFlags::DOWNSTREAM (MS_SLAVE).

Trait Implementations

impl<'a, B, S, G: Deref<Target = S>> Deref for Guard<'a, B, G>

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, B, S, G: DerefMut<Target = S>> DerefMut for Guard<'a, B, G>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.