blob: 5d5abaa3dc463d42bef4fedd1c2155be6a1bd389 [file]
// Copyright 2016 The Fuchsia Authors
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT
use crate::kernel::deadline::Deadline;
use crate::kernel::event::Event;
use crate::kernel::thread::Interruptible;
use crate::object::{
AutoBlocked, Blocked, HandleValue, PortDispatcher, ProcessDispatcher, WaitSignalObserver,
};
use crate::platform_rs::timer::InstantUnknown;
use crate::user_copy::{UserInOutPtr, UserOutPtr};
use debug::ltracef;
use fbl::InlineArray;
use syscalls_macro::syscall;
use zx_status::Status;
use zx_types::{
ZX_RIGHT_WAIT, ZX_RIGHT_WRITE, ZX_SIGNAL_HANDLE_CLOSED, ZX_WAIT_ASYNC_BOOT_TIMESTAMP,
ZX_WAIT_ASYNC_EDGE, ZX_WAIT_ASYNC_TIMESTAMP, ZX_WAIT_MANY_MAX_ITEMS, zx_instant_mono_t,
zx_signals_t, zx_wait_item_t,
};
const LOCAL_TRACE: u32 = 0;
zr::static_assert!(ZX_WAIT_MANY_MAX_ITEMS <= zx_types::ZX_CHANNEL_MAX_MSG_HANDLES as usize);
#[syscall]
pub fn sys_object_wait_one(
handle_value: HandleValue,
signals: zx_signals_t,
deadline: zx_instant_mono_t,
observed: UserOutPtr<zx_signals_t>,
) -> Result<(), Status> {
ltracef!("handle {:?}\n", handle_value);
pin_init::stack_pin_init!(let event = Event::init_unsignaled());
let event = event.into_ref();
let wait_signal_observer = core::pin::pin!(WaitSignalObserver::new());
let wait_signal_observer = wait_signal_observer.into_ref();
let slack_deadline = ProcessDispatcher::with_current(|up| {
let handle_table = up.handle_table();
ksync::lock!(let guard = handle_table.read_lock());
let handle = handle_table
.get_handle_locked(guard.token(), up, handle_value)
.ok_or(Status::BAD_HANDLE)?;
if !handle.has_rights(ZX_RIGHT_WAIT) {
return Err(Status::ACCESS_DENIED);
}
// SAFETY: `wait_signal_observer` is freshly constructed (not registered), stack-pinned
// strictly after `event`, and never leaked or forgotten; `handle.dispatcher()`'s lock is
// not held; and `end` is called unconditionally below (with no locks held) before
// `wait_signal_observer` is dropped and before `event` is destroyed.
unsafe {
wait_signal_observer.begin(guard.token(), event.get_ref(), &handle, signals)?;
}
let slack = up.get_timer_slack_policy();
Ok(Deadline::new(InstantUnknown(deadline), slack))
})?;
// Event::Wait() will return ZX_OK if already signaled,
// even if the deadline has passed. It will return ZX_ERR_TIMED_OUT
// after the deadline passes if the event has not been
// signaled.
let wait_result = {
let _blocked = AutoBlocked::new(Blocked::WAIT_ONE);
event.wait(&slack_deadline)
};
// Regardless of wait outcome, we must call End().
let signals_state = wait_signal_observer.end();
if !observed.is_null() {
observed.write(signals_state)?;
}
if (signals_state & ZX_SIGNAL_HANDLE_CLOSED) != 0 {
return Err(Status::CANCELED);
}
wait_result
}
#[syscall]
pub fn sys_object_wait_many(
user_items: UserInOutPtr<zx_wait_item_t>,
count: usize,
deadline: zx_instant_mono_t,
) -> Result<(), Status> {
ltracef!("count {}\n", count);
let slack = ProcessDispatcher::with_current(|up| up.get_timer_slack_policy());
let slack_deadline = Deadline::new(InstantUnknown(deadline), slack);
if count == 0 {
let now = crate::platform_rs::timer::current_mono_time();
{
let _blocked = AutoBlocked::new(Blocked::WAIT_MANY);
crate::kernel::thread::sleep_etc(&slack_deadline, Interruptible::YES, now)?;
}
return Err(Status::TIMED_OUT);
}
if count > ZX_WAIT_MANY_MAX_ITEMS {
return Err(Status::OUT_OF_RANGE);
}
let mut uninit_items =
[const { core::mem::MaybeUninit::<zx_wait_item_t>::uninit() }; ZX_WAIT_MANY_MAX_ITEMS];
let items = user_items.copy_slice_from_user(&mut uninit_items[..count])?;
const MAX_INLINE_OBSERVERS: usize = 8;
// WaitSignalObserver is heavier than it looks so make sure we know how
// much stack InlineArray is going to use, given limited kernel stack size.
zr::static_assert!(core::mem::size_of::<WaitSignalObserver<'_>>() * MAX_INLINE_OBSERVERS < 640);
pin_init::stack_pin_init!(let event = Event::init_unsignaled());
let event = event.into_ref();
pin_init::stack_try_pin_init!(
let observers = InlineArray::<WaitSignalObserver<'_>, MAX_INLINE_OBSERVERS>::init(count)
);
let observers = observers.map_err(|_| Status::NO_MEMORY)?;
let observers = observers.into_ref().get_ref().as_slice();
// We may need to unwind (which can be done outside the lock).
let mut num_added = 0;
let begin_result = ProcessDispatcher::with_current(|up| {
let handle_table = up.handle_table();
ksync::lock!(let guard = handle_table.read_lock());
for (obs, item) in observers.iter().zip(items.iter()) {
let handle = handle_table
.get_handle_locked(guard.token(), up, HandleValue::new(item.handle))
.ok_or(Status::BAD_HANDLE)?;
if !handle.has_rights(ZX_RIGHT_WAIT) {
return Err(Status::ACCESS_DENIED);
}
// SAFETY: `obs` is a freshly constructed (not yet registered) element of the
// stack-pinned `InlineArray` (declared strictly after `event`), which never moves,
// leaks, or forgets its inline or heap-allocated elements before dropping them in
// place. `handle.dispatcher()`'s lock is not held, and `end` is called on every
// registered observer (both on the `begin_result` unwind path and after `event.wait`,
// with no locks held) before the `InlineArray` is dropped and before `event` is
// destroyed.
unsafe {
core::pin::Pin::new_unchecked(obs).begin(
guard.token(),
event.get_ref(),
&handle,
item.waitfor,
)?;
}
num_added += 1;
}
Ok(())
});
if let Err(err) = begin_result {
for obs in &observers[..num_added] {
// SAFETY: `obs` is an element of the stack-pinned `InlineArray`, which never moves its
// inline or heap-allocated elements before dropping them in place.
unsafe { core::pin::Pin::new_unchecked(obs) }.end();
}
return Err(err);
}
// Event::Wait() will return ZX_OK if already signaled,
// even if deadline has passed. It will return ZX_ERR_TIMED_OUT
// after the deadline passes if the event has not been
// signaled.
let wait_result = {
let _blocked = AutoBlocked::new(Blocked::WAIT_MANY);
event.wait(&slack_deadline)
};
// Regardless of wait outcome, we must call End().
let mut combined = 0;
for (obs, item) in observers.iter().zip(items.iter_mut()) {
// SAFETY: `obs` is an element of the stack-pinned `InlineArray`, which never moves its
// inline or heap-allocated elements before dropping them in place.
let pending = unsafe { core::pin::Pin::new_unchecked(obs) }.end();
item.pending = pending;
combined |= pending;
}
user_items.copy_slice_to_user(items)?;
if (combined & ZX_SIGNAL_HANDLE_CLOSED) != 0 {
return Err(Status::CANCELED);
}
wait_result
}
// zx_status_t zx_object_wait_async
#[syscall]
pub fn sys_object_wait_async(
handle_value: HandleValue,
port_handle_value: HandleValue,
key: u64,
signals: zx_signals_t,
options: u32,
) -> Result<(), Status> {
ltracef!("handle {:x}\n", handle_value.raw_value());
if (options & !(ZX_WAIT_ASYNC_TIMESTAMP | ZX_WAIT_ASYNC_BOOT_TIMESTAMP | ZX_WAIT_ASYNC_EDGE))
!= 0
{
return Err(Status::INVALID_ARGS);
}
// It is invalid to request both a monotonic and boot timestamp.
if (options & ZX_WAIT_ASYNC_TIMESTAMP) != 0 && (options & ZX_WAIT_ASYNC_BOOT_TIMESTAMP) != 0 {
return Err(Status::INVALID_ARGS);
}
let up = ProcessDispatcher::get_current();
{
ksync::lock!(let guard = up.handle_table().read_lock());
// Note, we're doing this all while holding the handle table lock for two reasons.
//
// First, this thread may be racing with another thread that's closing the last handle to
// the port. By holding the lock we can ensure that this syscall behaves as if the port was
// closed just *before* the syscall started or closed just *after* it has completed.
//
// Second, MakeObserver takes a Handle. By holding the lock we ensure the Handle isn't
// destroyed out from under it.
let port_handle = up
.handle_table()
.get_handle_locked(guard.token(), &up, port_handle_value)
.ok_or(Status::BAD_HANDLE)?;
let port_dispatcher = port_handle.dispatcher_ref();
let port = port_dispatcher.downcast::<PortDispatcher>().ok_or(Status::WRONG_TYPE)?;
if !port_handle.has_rights(ZX_RIGHT_WRITE) {
return Err(Status::ACCESS_DENIED);
}
let handle = up
.handle_table()
.get_handle_locked(guard.token(), &up, handle_value)
.ok_or(Status::BAD_HANDLE)?;
if !handle.has_rights(ZX_RIGHT_WAIT) {
return Err(Status::ACCESS_DENIED);
}
let dispatcher = handle.dispatcher_ref();
dispatcher.make_port_observer(options, handle, signals, key, port)
}
}