mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 06:47:34 +00:00
Everywhere: Rename ASSERT => VERIFY
(...and ASSERT_NOT_REACHED => VERIFY_NOT_REACHED) Since all of these checks are done in release builds as well, let's rename them to VERIFY to prevent confusion, as everyone is used to assertions being compiled out in release. We can introduce a new ASSERT macro that is specifically for debug checks, but I'm doing this wholesale conversion first since we've accumulated thousands of these already, and it's not immediately obvious which ones are suitable for ASSERT.
This commit is contained in:
parent
b33a6a443e
commit
5d180d1f99
725 changed files with 3448 additions and 3448 deletions
|
@ -195,7 +195,7 @@ static KResultOr<RequiredLoadRange> get_required_load_range(FileDescription& pro
|
|||
return IterationDecision::Continue;
|
||||
});
|
||||
|
||||
ASSERT(range.end > range.start);
|
||||
VERIFY(range.end > range.start);
|
||||
return range;
|
||||
};
|
||||
|
||||
|
@ -283,15 +283,15 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Space> new_space, Fil
|
|||
FlatPtr load_base_address = 0;
|
||||
|
||||
String elf_name = object_description.absolute_path();
|
||||
ASSERT(!Processor::current().in_critical());
|
||||
VERIFY(!Processor::current().in_critical());
|
||||
|
||||
MemoryManager::enter_space(*new_space);
|
||||
|
||||
KResult ph_load_result = KSuccess;
|
||||
elf_image.for_each_program_header([&](const ELF::Image::ProgramHeader& program_header) {
|
||||
if (program_header.type() == PT_TLS) {
|
||||
ASSERT(should_allocate_tls == ShouldAllocateTls::Yes);
|
||||
ASSERT(program_header.size_in_memory());
|
||||
VERIFY(should_allocate_tls == ShouldAllocateTls::Yes);
|
||||
VERIFY(program_header.size_in_memory());
|
||||
|
||||
if (!elf_image.is_within_image(program_header.raw_data(), program_header.size_in_image())) {
|
||||
dbgln("Shenanigans! ELF PT_TLS header sneaks outside of executable.");
|
||||
|
@ -325,8 +325,8 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Space> new_space, Fil
|
|||
|
||||
if (program_header.is_writable()) {
|
||||
// Writable section: create a copy in memory.
|
||||
ASSERT(program_header.size_in_memory());
|
||||
ASSERT(program_header.alignment() == PAGE_SIZE);
|
||||
VERIFY(program_header.size_in_memory());
|
||||
VERIFY(program_header.alignment() == PAGE_SIZE);
|
||||
|
||||
if (!elf_image.is_within_image(program_header.raw_data(), program_header.size_in_image())) {
|
||||
dbgln("Shenanigans! Writable ELF PT_LOAD header sneaks outside of executable.");
|
||||
|
@ -368,8 +368,8 @@ static KResultOr<LoadResult> load_elf_object(NonnullOwnPtr<Space> new_space, Fil
|
|||
}
|
||||
|
||||
// Non-writable section: map the executable itself in memory.
|
||||
ASSERT(program_header.size_in_memory());
|
||||
ASSERT(program_header.alignment() == PAGE_SIZE);
|
||||
VERIFY(program_header.size_in_memory());
|
||||
VERIFY(program_header.alignment() == PAGE_SIZE);
|
||||
int prot = 0;
|
||||
if (program_header.is_readable())
|
||||
prot |= PROT_READ;
|
||||
|
@ -454,17 +454,17 @@ KResultOr<LoadResult> Process::load(NonnullRefPtr<FileDescription> main_program_
|
|||
return interpreter_load_result.error();
|
||||
|
||||
// TLS allocation will be done in userspace by the loader
|
||||
ASSERT(!interpreter_load_result.value().tls_region);
|
||||
ASSERT(!interpreter_load_result.value().tls_alignment);
|
||||
ASSERT(!interpreter_load_result.value().tls_size);
|
||||
VERIFY(!interpreter_load_result.value().tls_region);
|
||||
VERIFY(!interpreter_load_result.value().tls_alignment);
|
||||
VERIFY(!interpreter_load_result.value().tls_size);
|
||||
|
||||
return interpreter_load_result;
|
||||
}
|
||||
|
||||
KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description, Vector<String> arguments, Vector<String> environment, RefPtr<FileDescription> interpreter_description, Thread*& new_main_thread, u32& prev_flags, const Elf32_Ehdr& main_program_header)
|
||||
{
|
||||
ASSERT(is_user_process());
|
||||
ASSERT(!Processor::current().in_critical());
|
||||
VERIFY(is_user_process());
|
||||
VERIFY(!Processor::current().in_critical());
|
||||
auto path = main_program_description->absolute_path();
|
||||
|
||||
dbgln_if(EXEC_DEBUG, "do_exec: {}", path);
|
||||
|
@ -522,7 +522,7 @@ KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description
|
|||
|
||||
auto signal_trampoline_region = m_space->allocate_region_with_vmobject(signal_trampoline_range.value(), g_signal_trampoline_region->vmobject(), 0, "Signal trampoline", PROT_READ | PROT_EXEC, true);
|
||||
if (signal_trampoline_region.is_error()) {
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
signal_trampoline_region.value()->set_syscall_region(true);
|
||||
|
@ -557,7 +557,7 @@ KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description
|
|||
int main_program_fd = -1;
|
||||
if (interpreter_description) {
|
||||
main_program_fd = alloc_fd();
|
||||
ASSERT(main_program_fd >= 0);
|
||||
VERIFY(main_program_fd >= 0);
|
||||
main_program_description->seek(0, SEEK_SET);
|
||||
main_program_description->set_readable(true);
|
||||
m_fds[main_program_fd].set(move(main_program_description), FD_CLOEXEC);
|
||||
|
@ -572,7 +572,7 @@ KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description
|
|||
return IterationDecision::Break;
|
||||
});
|
||||
}
|
||||
ASSERT(new_main_thread);
|
||||
VERIFY(new_main_thread);
|
||||
|
||||
auto auxv = generate_auxiliary_vector(load_result.load_base, load_result.entry_eip, m_uid, m_euid, m_gid, m_egid, path, main_program_fd);
|
||||
|
||||
|
@ -604,7 +604,7 @@ KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description
|
|||
auto tsr_result = new_main_thread->make_thread_specific_region({});
|
||||
if (tsr_result.is_error()) {
|
||||
// FIXME: We cannot fail this late. Refactor this so the allocation happens before we commit to the new executable.
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
new_main_thread->reset_fpu_state();
|
||||
|
||||
|
@ -630,8 +630,8 @@ KResult Process::do_exec(NonnullRefPtr<FileDescription> main_program_description
|
|||
}
|
||||
u32 lock_count_to_restore;
|
||||
[[maybe_unused]] auto rc = big_lock().force_unlock_if_locked(lock_count_to_restore);
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(Processor::current().in_critical());
|
||||
VERIFY_INTERRUPTS_DISABLED();
|
||||
VERIFY(Processor::current().in_critical());
|
||||
return KSuccess;
|
||||
}
|
||||
|
||||
|
@ -727,7 +727,7 @@ KResultOr<RefPtr<FileDescription>> Process::find_elf_interpreter_for_executable(
|
|||
auto interpreter_description = interp_result.value();
|
||||
auto interp_metadata = interpreter_description->metadata();
|
||||
|
||||
ASSERT(interpreter_description->inode());
|
||||
VERIFY(interpreter_description->inode());
|
||||
|
||||
// Validate the program interpreter as a valid elf binary.
|
||||
// If your program interpreter is a #! file or something, it's time to stop playing games :)
|
||||
|
@ -805,7 +805,7 @@ KResult Process::exec(String path, Vector<String> arguments, Vector<String> envi
|
|||
if (metadata.size < 3)
|
||||
return ENOEXEC;
|
||||
|
||||
ASSERT(description->inode());
|
||||
VERIFY(description->inode());
|
||||
|
||||
// Read the first page of the program into memory so we can validate the binfmt of it
|
||||
char first_page[PAGE_SIZE];
|
||||
|
@ -856,20 +856,20 @@ KResult Process::exec(String path, Vector<String> arguments, Vector<String> envi
|
|||
if (result.is_error())
|
||||
return result;
|
||||
|
||||
ASSERT_INTERRUPTS_DISABLED();
|
||||
ASSERT(Processor::current().in_critical());
|
||||
VERIFY_INTERRUPTS_DISABLED();
|
||||
VERIFY(Processor::current().in_critical());
|
||||
|
||||
auto current_thread = Thread::current();
|
||||
if (current_thread == new_main_thread) {
|
||||
// We need to enter the scheduler lock before changing the state
|
||||
// and it will be released after the context switch into that
|
||||
// thread. We should also still be in our critical section
|
||||
ASSERT(!g_scheduler_lock.own_lock());
|
||||
ASSERT(Processor::current().in_critical() == 1);
|
||||
VERIFY(!g_scheduler_lock.own_lock());
|
||||
VERIFY(Processor::current().in_critical() == 1);
|
||||
g_scheduler_lock.lock();
|
||||
current_thread->set_state(Thread::State::Running);
|
||||
Processor::assume_context(*current_thread, prev_flags);
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
Processor::current().leave_critical(prev_flags);
|
||||
|
@ -926,7 +926,7 @@ int Process::sys$execve(Userspace<const Syscall::SC_execve_params*> user_params)
|
|||
return -EFAULT;
|
||||
|
||||
auto result = exec(move(path), move(arguments), move(environment));
|
||||
ASSERT(result.is_error()); // We should never continue after a successful exec!
|
||||
VERIFY(result.is_error()); // We should never continue after a successful exec!
|
||||
return result.error();
|
||||
}
|
||||
|
||||
|
|
|
@ -37,7 +37,7 @@ void Process::sys$exit(int status)
|
|||
m_termination_signal = 0;
|
||||
die();
|
||||
Thread::current()->die_if_needed();
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -62,7 +62,7 @@ FutexQueue::~FutexQueue()
|
|||
|
||||
void FutexQueue::vmobject_deleted(VMObject& vmobject)
|
||||
{
|
||||
ASSERT(m_is_global); // If we got called we must be a global futex
|
||||
VERIFY(m_is_global); // If we got called we must be a global futex
|
||||
// Because we're taking ourselves out of the global queue, we need
|
||||
// to make sure we have at last a reference until we're done
|
||||
NonnullRefPtr<FutexQueue> own_ref(*this);
|
||||
|
@ -88,7 +88,7 @@ void FutexQueue::vmobject_deleted(VMObject& vmobject)
|
|||
dbgln("Futex @ {} unblocked {} waiters due to vmobject free", this, wake_count);
|
||||
}
|
||||
|
||||
ASSERT(did_wake_all); // No one should be left behind...
|
||||
VERIFY(did_wake_all); // No one should be left behind...
|
||||
}
|
||||
|
||||
void Process::clear_futex_queues_on_exec()
|
||||
|
@ -97,7 +97,7 @@ void Process::clear_futex_queues_on_exec()
|
|||
for (auto& it : m_futex_queues) {
|
||||
bool did_wake_all;
|
||||
it.value->wake_all(did_wake_all);
|
||||
ASSERT(did_wake_all); // No one should be left behind...
|
||||
VERIFY(did_wake_all); // No one should be left behind...
|
||||
}
|
||||
m_futex_queues.clear();
|
||||
}
|
||||
|
@ -172,16 +172,16 @@ int Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
|
|||
if (create_if_not_found) {
|
||||
// TODO: is there a better way than setting and finding it again?
|
||||
auto result = global_queues.set(&vmobject, {});
|
||||
ASSERT(result == AK::HashSetResult::InsertedNewEntry);
|
||||
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
||||
it = global_queues.find(&vmobject);
|
||||
ASSERT(it != global_queues.end());
|
||||
VERIFY(it != global_queues.end());
|
||||
return &it->value;
|
||||
}
|
||||
return nullptr;
|
||||
};
|
||||
|
||||
auto find_futex_queue = [&](VMObject* vmobject, FlatPtr user_address_or_offset, bool create_if_not_found) -> RefPtr<FutexQueue> {
|
||||
ASSERT(is_private || vmobject);
|
||||
VERIFY(is_private || vmobject);
|
||||
auto* queues = is_private ? &m_futex_queues : find_global_futex_queues(*vmobject, create_if_not_found);
|
||||
if (!queues)
|
||||
return {};
|
||||
|
@ -191,7 +191,7 @@ int Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
|
|||
if (create_if_not_found) {
|
||||
auto futex_queue = adopt(*new FutexQueue(user_address_or_offset, vmobject));
|
||||
auto result = queues->set(user_address_or_offset, futex_queue);
|
||||
ASSERT(result == AK::HashSetResult::InsertedNewEntry);
|
||||
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
||||
return futex_queue;
|
||||
}
|
||||
return {};
|
||||
|
@ -234,7 +234,7 @@ int Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
|
|||
atomic_thread_fence(AK::MemoryOrder::memory_order_acquire);
|
||||
|
||||
auto futex_queue = find_futex_queue(vmobject.ptr(), user_address_or_offset, true);
|
||||
ASSERT(futex_queue);
|
||||
VERIFY(futex_queue);
|
||||
|
||||
// We need to release the lock before blocking. But we have a reference
|
||||
// to the FutexQueue so that we can keep it alive.
|
||||
|
@ -358,13 +358,13 @@ int Process::sys$futex(Userspace<const Syscall::SC_futex_params*> user_params)
|
|||
return do_requeue(params.val3);
|
||||
|
||||
case FUTEX_WAIT_BITSET:
|
||||
ASSERT(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAIT
|
||||
VERIFY(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAIT
|
||||
if (params.val3 == 0)
|
||||
return -EINVAL;
|
||||
return do_wait(params.val3);
|
||||
|
||||
case FUTEX_WAKE_BITSET:
|
||||
ASSERT(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAKE
|
||||
VERIFY(params.val3 != FUTEX_BITSET_MATCH_ANY); // we should have turned it into FUTEX_WAKE
|
||||
if (params.val3 == 0)
|
||||
return -EINVAL;
|
||||
return do_wake(vmobject.ptr(), user_address_or_offset, params.val, params.val3);
|
||||
|
|
|
@ -36,7 +36,7 @@ int Process::sys$get_stack_bounds(FlatPtr* user_stack_base, size_t* user_stack_s
|
|||
auto* stack_region = space().find_region_containing(Range { VirtualAddress(stack_pointer), 1 });
|
||||
|
||||
// The syscall handler should have killed us if we had an invalid stack pointer.
|
||||
ASSERT(stack_region);
|
||||
VERIFY(stack_region);
|
||||
|
||||
FlatPtr stack_base = stack_region->range().base().get();
|
||||
size_t stack_size = stack_region->size();
|
||||
|
|
|
@ -47,7 +47,7 @@ KResult Process::do_killpg(ProcessGroupID pgrp, int signal)
|
|||
{
|
||||
InterruptDisabler disabler;
|
||||
|
||||
ASSERT(pgrp >= 0);
|
||||
VERIFY(pgrp >= 0);
|
||||
|
||||
// Send the signal to all processes in the given group.
|
||||
if (pgrp == 0) {
|
||||
|
@ -136,7 +136,7 @@ int Process::sys$kill(pid_t pid_or_pgid, int signal)
|
|||
if (pid_or_pgid == m_pid.value()) {
|
||||
return do_killself(signal);
|
||||
}
|
||||
ASSERT(pid_or_pgid >= 0);
|
||||
VERIFY(pid_or_pgid >= 0);
|
||||
ScopedSpinLock lock(g_processes_lock);
|
||||
auto peer = Process::from_pid(pid_or_pgid);
|
||||
if (!peer)
|
||||
|
|
|
@ -465,7 +465,7 @@ int Process::sys$munmap(void* addr, size_t size)
|
|||
if (!whole_region->is_mmap())
|
||||
return -EPERM;
|
||||
bool success = space().deallocate_region(*whole_region);
|
||||
ASSERT(success);
|
||||
VERIFY(success);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -557,7 +557,7 @@ void* Process::sys$allocate_tls(size_t size)
|
|||
main_thread = &thread;
|
||||
return IterationDecision::Break;
|
||||
});
|
||||
ASSERT(main_thread);
|
||||
VERIFY(main_thread);
|
||||
|
||||
auto range = space().allocate_range({}, size);
|
||||
if (!range.has_value())
|
||||
|
|
|
@ -80,7 +80,7 @@ int Process::sys$module_load(Userspace<const char*> user_path, size_t path_lengt
|
|||
if (!section.size())
|
||||
return IterationDecision::Continue;
|
||||
auto* section_storage = section_storage_by_name.get(section.name()).value_or(nullptr);
|
||||
ASSERT(section_storage);
|
||||
VERIFY(section_storage);
|
||||
section.relocations().for_each_relocation([&](const ELF::Image::Relocation& relocation) {
|
||||
auto& patch_ptr = *reinterpret_cast<ptrdiff_t*>(section_storage + relocation.offset());
|
||||
switch (relocation.type()) {
|
||||
|
@ -100,7 +100,7 @@ int Process::sys$module_load(Userspace<const char*> user_path, size_t path_lengt
|
|||
|
||||
if (relocation.symbol().bind() == STB_LOCAL) {
|
||||
auto* section_storage_containing_symbol = section_storage_by_name.get(relocation.symbol().section().name()).value_or(nullptr);
|
||||
ASSERT(section_storage_containing_symbol);
|
||||
VERIFY(section_storage_containing_symbol);
|
||||
u32 symbol_address = (ptrdiff_t)(section_storage_containing_symbol + relocation.symbol().value());
|
||||
if (symbol_address == 0)
|
||||
missing_symbols = true;
|
||||
|
@ -113,7 +113,7 @@ int Process::sys$module_load(Userspace<const char*> user_path, size_t path_lengt
|
|||
dbgln(" Symbol address: {:p}", symbol_address);
|
||||
patch_ptr += symbol_address;
|
||||
} else {
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
|
@ -205,7 +205,7 @@ KResult Process::poke_user_data(Userspace<u32*> address, u32 data)
|
|||
if (region->is_shared()) {
|
||||
// If the region is shared, we change its vmobject to a PrivateInodeVMObject
|
||||
// to prevent the write operation from changing any shared inode data
|
||||
ASSERT(region->vmobject().is_shared_inode());
|
||||
VERIFY(region->vmobject().is_shared_inode());
|
||||
region->set_vmobject(PrivateInodeVMObject::create_with_inode(static_cast<SharedInodeVMObject&>(region->vmobject()).inode()));
|
||||
region->set_shared(false);
|
||||
}
|
||||
|
|
|
@ -226,15 +226,15 @@ int Process::sys$poll(Userspace<const Syscall::SC_poll_params*> user_params)
|
|||
pfd.revents |= POLLNVAL;
|
||||
} else {
|
||||
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Read) {
|
||||
ASSERT(pfd.events & POLLIN);
|
||||
VERIFY(pfd.events & POLLIN);
|
||||
pfd.revents |= POLLIN;
|
||||
}
|
||||
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::ReadPriority) {
|
||||
ASSERT(pfd.events & POLLPRI);
|
||||
VERIFY(pfd.events & POLLPRI);
|
||||
pfd.revents |= POLLPRI;
|
||||
}
|
||||
if ((u32)fds_entry.unblocked_flags & (u32)Thread::FileBlocker::BlockFlags::Write) {
|
||||
ASSERT(pfd.events & POLLOUT);
|
||||
VERIFY(pfd.events & POLLOUT);
|
||||
pfd.revents |= POLLOUT;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -122,7 +122,7 @@ int Process::sys$accept(int accepting_socket_fd, Userspace<sockaddr*> user_addre
|
|||
}
|
||||
}
|
||||
auto accepted_socket = socket.accept();
|
||||
ASSERT(accepted_socket);
|
||||
VERIFY(accepted_socket);
|
||||
|
||||
if (user_address) {
|
||||
u8 address_buffer[sizeof(sockaddr_un)];
|
||||
|
@ -263,7 +263,7 @@ ssize_t Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int
|
|||
int msg_flags = 0;
|
||||
|
||||
if (result.value() > iovs[0].iov_len) {
|
||||
ASSERT(socket.type() != SOCK_STREAM);
|
||||
VERIFY(socket.type() != SOCK_STREAM);
|
||||
msg_flags |= MSG_TRUNC;
|
||||
}
|
||||
|
||||
|
|
|
@ -102,7 +102,7 @@ void Process::sys$exit_thread(Userspace<void*> exit_value)
|
|||
}
|
||||
|
||||
Thread::current()->exit(reinterpret_cast<void*>(exit_value.ptr()));
|
||||
ASSERT_NOT_REACHED();
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
|
||||
int Process::sys$detach_thread(pid_t tid)
|
||||
|
|
|
@ -125,7 +125,7 @@ int Process::sys$unveil(Userspace<const Syscall::SC_unveil_params*> user_params)
|
|||
lexical_path.parts().end(),
|
||||
{ new_unveiled_path, (UnveilAccess)new_permissions, true },
|
||||
[](auto& parent, auto& it) -> Optional<UnveilMetadata> { return UnveilMetadata { String::formatted("{}/{}", parent.path(), *it), parent.permissions(), false, parent.permissions_inherited_from_root() }; });
|
||||
ASSERT(m_veil_state != VeilState::Locked);
|
||||
VERIFY(m_veil_state != VeilState::Locked);
|
||||
m_veil_state = VeilState::Dropped;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -34,7 +34,7 @@ KResultOr<siginfo_t> Process::do_waitid(idtype_t idtype, int id, int options)
|
|||
KResultOr<siginfo_t> result = KResult(KSuccess);
|
||||
if (Thread::current()->block<Thread::WaitBlocker>({}, options, idtype, id, result).was_interrupted())
|
||||
return EINTR;
|
||||
ASSERT(!result.is_error() || (options & WNOHANG) || result.error() != KSuccess);
|
||||
VERIFY(!result.is_error() || (options & WNOHANG) || result.error() != KSuccess);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
|
@ -91,7 +91,7 @@ ssize_t Process::do_write(FileDescription& description, const UserOrKernelBuffer
|
|||
if (!description.can_write()) {
|
||||
if (!description.is_blocking()) {
|
||||
// Short write: We can no longer write to this non-blocking description.
|
||||
ASSERT(total_nwritten > 0);
|
||||
VERIFY(total_nwritten > 0);
|
||||
return total_nwritten;
|
||||
}
|
||||
auto unblock_flags = Thread::FileBlocker::BlockFlags::None;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue