mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 21:27:35 +00:00
AK: Rename adopt() to adopt_ref()
This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
This commit is contained in:
parent
b3db01e20e
commit
b91c49364d
228 changed files with 461 additions and 461 deletions
|
@ -51,7 +51,7 @@ public:
|
|||
template<typename AsyncRequestType, typename... Args>
|
||||
NonnullRefPtr<AsyncRequestType> make_request(Args&&... args)
|
||||
{
|
||||
auto request = adopt(*new AsyncRequestType(*this, forward<Args>(args)...));
|
||||
auto request = adopt_ref(*new AsyncRequestType(*this, forward<Args>(args)...));
|
||||
ScopedSpinLock lock(m_requests_lock);
|
||||
bool was_empty = m_requests.is_empty();
|
||||
m_requests.append(request);
|
||||
|
|
|
@ -14,7 +14,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<I8042Controller> I8042Controller::initialize()
|
||||
{
|
||||
return adopt(*new I8042Controller());
|
||||
return adopt_ref(*new I8042Controller());
|
||||
}
|
||||
|
||||
RefPtr<MouseDevice> I8042Controller::mouse() const
|
||||
|
|
|
@ -85,7 +85,7 @@ void PS2KeyboardDevice::handle_irq(const RegisterState&)
|
|||
|
||||
UNMAP_AFTER_INIT RefPtr<PS2KeyboardDevice> PS2KeyboardDevice::try_to_initialize(const I8042Controller& ps2_controller)
|
||||
{
|
||||
auto device = adopt(*new PS2KeyboardDevice(ps2_controller));
|
||||
auto device = adopt_ref(*new PS2KeyboardDevice(ps2_controller));
|
||||
if (device->initialize())
|
||||
return device;
|
||||
return nullptr;
|
||||
|
|
|
@ -176,7 +176,7 @@ void PS2MouseDevice::set_sample_rate(u8 rate)
|
|||
|
||||
UNMAP_AFTER_INIT RefPtr<PS2MouseDevice> PS2MouseDevice::try_to_initialize(const I8042Controller& ps2_controller)
|
||||
{
|
||||
auto device = adopt(*new PS2MouseDevice(ps2_controller));
|
||||
auto device = adopt_ref(*new PS2MouseDevice(ps2_controller));
|
||||
if (device->initialize())
|
||||
return device;
|
||||
return nullptr;
|
||||
|
|
|
@ -15,7 +15,7 @@ UNMAP_AFTER_INIT RefPtr<VMWareMouseDevice> VMWareMouseDevice::try_to_initialize(
|
|||
return {};
|
||||
if (!VMWareBackdoor::the()->vmmouse_is_absolute())
|
||||
return {};
|
||||
auto device = adopt(*new VMWareMouseDevice(ps2_controller));
|
||||
auto device = adopt_ref(*new VMWareMouseDevice(ps2_controller));
|
||||
if (device->initialize())
|
||||
return device;
|
||||
return {};
|
||||
|
|
|
@ -14,7 +14,7 @@ class AnonymousFile final : public File {
|
|||
public:
|
||||
static NonnullRefPtr<AnonymousFile> create(NonnullRefPtr<AnonymousVMObject> vmobject)
|
||||
{
|
||||
return adopt(*new AnonymousFile(move(vmobject)));
|
||||
return adopt_ref(*new AnonymousFile(move(vmobject)));
|
||||
}
|
||||
|
||||
virtual ~AnonymousFile() override;
|
||||
|
|
|
@ -21,7 +21,7 @@ class Custody : public RefCounted<Custody> {
|
|||
public:
|
||||
static NonnullRefPtr<Custody> create(Custody* parent, const StringView& name, Inode& inode, int mount_flags)
|
||||
{
|
||||
return adopt(*new Custody(parent, name, inode, mount_flags));
|
||||
return adopt_ref(*new Custody(parent, name, inode, mount_flags));
|
||||
}
|
||||
|
||||
~Custody();
|
||||
|
|
|
@ -14,11 +14,11 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<DevFS> DevFS::create()
|
||||
{
|
||||
return adopt(*new DevFS);
|
||||
return adopt_ref(*new DevFS);
|
||||
}
|
||||
|
||||
DevFS::DevFS()
|
||||
: m_root_inode(adopt(*new DevFSRootDirectoryInode(*this)))
|
||||
: m_root_inode(adopt_ref(*new DevFSRootDirectoryInode(*this)))
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
Device::for_each([&](Device& device) {
|
||||
|
@ -32,7 +32,7 @@ DevFS::DevFS()
|
|||
void DevFS::notify_new_device(Device& device)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
auto new_device_inode = adopt(*new DevFSDeviceInode(*this, device));
|
||||
auto new_device_inode = adopt_ref(*new DevFSDeviceInode(*this, device));
|
||||
m_nodes.append(new_device_inode);
|
||||
m_root_inode->m_devices.append(new_device_inode);
|
||||
}
|
||||
|
@ -274,7 +274,7 @@ KResultOr<NonnullRefPtr<Inode>> DevFSRootDirectoryInode::create_child(const Stri
|
|||
}
|
||||
if (name != "pts")
|
||||
return EROFS;
|
||||
auto new_directory_inode = adopt(*new DevFSPtsDirectoryInode(m_parent_fs));
|
||||
auto new_directory_inode = adopt_ref(*new DevFSPtsDirectoryInode(m_parent_fs));
|
||||
m_subfolders.append(new_directory_inode);
|
||||
m_parent_fs.m_nodes.append(new_directory_inode);
|
||||
return KResult(KSuccess);
|
||||
|
@ -284,7 +284,7 @@ KResultOr<NonnullRefPtr<Inode>> DevFSRootDirectoryInode::create_child(const Stri
|
|||
if (link.name() == name)
|
||||
return EEXIST;
|
||||
}
|
||||
auto new_link_inode = adopt(*new DevFSLinkInode(m_parent_fs, name));
|
||||
auto new_link_inode = adopt_ref(*new DevFSLinkInode(m_parent_fs, name));
|
||||
m_links.append(new_link_inode);
|
||||
m_parent_fs.m_nodes.append(new_link_inode);
|
||||
return new_link_inode;
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<DevPtsFS> DevPtsFS::create()
|
||||
{
|
||||
return adopt(*new DevPtsFS);
|
||||
return adopt_ref(*new DevPtsFS);
|
||||
}
|
||||
|
||||
DevPtsFS::DevPtsFS()
|
||||
|
@ -30,7 +30,7 @@ static AK::Singleton<HashTable<unsigned>> s_ptys;
|
|||
|
||||
bool DevPtsFS::initialize()
|
||||
{
|
||||
m_root_inode = adopt(*new DevPtsFSInode(*this, 1, nullptr));
|
||||
m_root_inode = adopt_ref(*new DevPtsFSInode(*this, 1, nullptr));
|
||||
m_root_inode->m_metadata.inode = { fsid(), 1 };
|
||||
m_root_inode->m_metadata.mode = 0040555;
|
||||
m_root_inode->m_metadata.uid = 0;
|
||||
|
@ -66,7 +66,7 @@ RefPtr<Inode> DevPtsFS::get_inode(InodeIdentifier inode_id) const
|
|||
auto* device = Device::get_device(201, pty_index);
|
||||
VERIFY(device);
|
||||
|
||||
auto inode = adopt(*new DevPtsFSInode(const_cast<DevPtsFS&>(*this), inode_id.index(), static_cast<SlavePTY*>(device)));
|
||||
auto inode = adopt_ref(*new DevPtsFSInode(const_cast<DevPtsFS&>(*this), inode_id.index(), static_cast<SlavePTY*>(device)));
|
||||
inode->m_metadata.inode = inode_id;
|
||||
inode->m_metadata.size = 0;
|
||||
inode->m_metadata.uid = device->uid();
|
||||
|
|
|
@ -55,7 +55,7 @@ static unsigned divide_rounded_up(unsigned a, unsigned b)
|
|||
|
||||
NonnullRefPtr<Ext2FS> Ext2FS::create(FileDescription& file_description)
|
||||
{
|
||||
return adopt(*new Ext2FS(file_description));
|
||||
return adopt_ref(*new Ext2FS(file_description));
|
||||
}
|
||||
|
||||
Ext2FS::Ext2FS(FileDescription& file_description)
|
||||
|
@ -797,7 +797,7 @@ RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
|
|||
if (!find_block_containing_inode(inode.index(), block_index, offset))
|
||||
return {};
|
||||
|
||||
auto new_inode = adopt(*new Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index()));
|
||||
auto new_inode = adopt_ref(*new Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index()));
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(&new_inode->m_raw_inode));
|
||||
if (auto result = read_block(block_index, &buffer, sizeof(ext2_inode), offset); result.is_error()) {
|
||||
// FIXME: Propagate the actual error.
|
||||
|
|
|
@ -27,7 +27,7 @@ static int s_next_fifo_id = 1;
|
|||
|
||||
NonnullRefPtr<FIFO> FIFO::create(uid_t uid)
|
||||
{
|
||||
return adopt(*new FIFO(uid));
|
||||
return adopt_ref(*new FIFO(uid));
|
||||
}
|
||||
|
||||
KResultOr<NonnullRefPtr<FileDescription>> FIFO::open_direction(FIFO::Direction direction)
|
||||
|
|
|
@ -25,7 +25,7 @@ namespace Kernel {
|
|||
|
||||
KResultOr<NonnullRefPtr<FileDescription>> FileDescription::create(Custody& custody)
|
||||
{
|
||||
auto description = adopt(*new FileDescription(InodeFile::create(custody.inode())));
|
||||
auto description = adopt_ref(*new FileDescription(InodeFile::create(custody.inode())));
|
||||
description->m_custody = custody;
|
||||
auto result = description->attach();
|
||||
if (result.is_error()) {
|
||||
|
@ -37,7 +37,7 @@ KResultOr<NonnullRefPtr<FileDescription>> FileDescription::create(Custody& custo
|
|||
|
||||
KResultOr<NonnullRefPtr<FileDescription>> FileDescription::create(File& file)
|
||||
{
|
||||
auto description = adopt(*new FileDescription(file));
|
||||
auto description = adopt_ref(*new FileDescription(file));
|
||||
auto result = description->attach();
|
||||
if (result.is_error()) {
|
||||
dbgln_if(FILEDESCRIPTION_DEBUG, "Failed to create file description for file: {}", result);
|
||||
|
|
|
@ -16,7 +16,7 @@ class InodeFile final : public File {
|
|||
public:
|
||||
static NonnullRefPtr<InodeFile> create(NonnullRefPtr<Inode>&& inode)
|
||||
{
|
||||
return adopt(*new InodeFile(move(inode)));
|
||||
return adopt_ref(*new InodeFile(move(inode)));
|
||||
}
|
||||
|
||||
virtual ~InodeFile() override;
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<InodeWatcher> InodeWatcher::create(Inode& inode)
|
||||
{
|
||||
return adopt(*new InodeWatcher(inode));
|
||||
return adopt_ref(*new InodeWatcher(inode));
|
||||
}
|
||||
|
||||
InodeWatcher::InodeWatcher(Inode& inode)
|
||||
|
|
|
@ -11,7 +11,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<Plan9FS> Plan9FS::create(FileDescription& file_description)
|
||||
{
|
||||
return adopt(*new Plan9FS(file_description));
|
||||
return adopt_ref(*new Plan9FS(file_description));
|
||||
}
|
||||
|
||||
Plan9FS::Plan9FS(FileDescription& file_description)
|
||||
|
@ -597,7 +597,7 @@ KResult Plan9FS::post_message_and_wait_for_a_reply(Message& message)
|
|||
{
|
||||
auto request_type = message.type();
|
||||
auto tag = message.tag();
|
||||
auto completion = adopt(*new ReceiveCompletion(tag));
|
||||
auto completion = adopt_ref(*new ReceiveCompletion(tag));
|
||||
auto result = post_message(message, completion);
|
||||
if (result.is_error())
|
||||
return result;
|
||||
|
@ -680,7 +680,7 @@ Plan9FSInode::Plan9FSInode(Plan9FS& fs, u32 fid)
|
|||
|
||||
NonnullRefPtr<Plan9FSInode> Plan9FSInode::create(Plan9FS& fs, u32 fid)
|
||||
{
|
||||
return adopt(*new Plan9FSInode(fs, fid));
|
||||
return adopt_ref(*new Plan9FSInode(fs, fid));
|
||||
}
|
||||
|
||||
Plan9FSInode::~Plan9FSInode()
|
||||
|
|
|
@ -237,7 +237,7 @@ struct ProcFSInodeData : public FileDescriptionData {
|
|||
|
||||
NonnullRefPtr<ProcFS> ProcFS::create()
|
||||
{
|
||||
return adopt(*new ProcFS);
|
||||
return adopt_ref(*new ProcFS);
|
||||
}
|
||||
|
||||
ProcFS::~ProcFS()
|
||||
|
@ -1018,10 +1018,10 @@ RefPtr<Inode> ProcFS::get_inode(InodeIdentifier inode_id) const
|
|||
// and if that fails we cannot return this instance anymore and just
|
||||
// create a new one.
|
||||
if (it->value->try_ref())
|
||||
return adopt(*it->value);
|
||||
return adopt_ref(*it->value);
|
||||
// We couldn't ref it, so just create a new one and replace the entry
|
||||
}
|
||||
auto inode = adopt(*new ProcFSInode(const_cast<ProcFS&>(*this), inode_id.index()));
|
||||
auto inode = adopt_ref(*new ProcFSInode(const_cast<ProcFS&>(*this), inode_id.index()));
|
||||
auto result = m_inodes.set(inode_id.index().value(), inode.ptr());
|
||||
VERIFY(result == ((it == m_inodes.end()) ? AK::HashSetResult::InsertedNewEntry : AK::HashSetResult::ReplacedExistingEntry));
|
||||
return inode;
|
||||
|
@ -1677,7 +1677,7 @@ KResult ProcFSInode::chmod(mode_t)
|
|||
|
||||
ProcFS::ProcFS()
|
||||
{
|
||||
m_root_inode = adopt(*new ProcFSInode(*this, 1));
|
||||
m_root_inode = adopt_ref(*new ProcFSInode(*this, 1));
|
||||
m_entries.resize(FI_MaxStaticFileIndex);
|
||||
m_entries[FI_Root_df] = { "df", FI_Root_df, false, procfs$df };
|
||||
m_entries[FI_Root_all] = { "all", FI_Root_all, false, procfs$all };
|
||||
|
|
|
@ -132,7 +132,7 @@ private:
|
|||
ProcFSProxyInode(ProcFS&, FileDescription&);
|
||||
static NonnullRefPtr<ProcFSProxyInode> create(ProcFS& fs, FileDescription& fd)
|
||||
{
|
||||
return adopt(*new ProcFSProxyInode(fs, fd));
|
||||
return adopt_ref(*new ProcFSProxyInode(fs, fd));
|
||||
}
|
||||
|
||||
NonnullRefPtr<FileDescription> m_fd;
|
||||
|
|
|
@ -13,7 +13,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<TmpFS> TmpFS::create()
|
||||
{
|
||||
return adopt(*new TmpFS);
|
||||
return adopt_ref(*new TmpFS);
|
||||
}
|
||||
|
||||
TmpFS::TmpFS()
|
||||
|
@ -86,7 +86,7 @@ TmpFSInode::~TmpFSInode()
|
|||
|
||||
NonnullRefPtr<TmpFSInode> TmpFSInode::create(TmpFS& fs, InodeMetadata metadata, InodeIdentifier parent)
|
||||
{
|
||||
auto inode = adopt(*new TmpFSInode(fs, metadata, parent));
|
||||
auto inode = adopt_ref(*new TmpFSInode(fs, metadata, parent));
|
||||
fs.register_inode(inode);
|
||||
return inode;
|
||||
}
|
||||
|
|
|
@ -125,7 +125,7 @@ UNMAP_AFTER_INIT void InterruptManagement::switch_to_pic_mode()
|
|||
dmesgln("Interrupts: Switch to Legacy PIC mode");
|
||||
InterruptDisabler disabler;
|
||||
m_smp_enabled = false;
|
||||
m_interrupt_controllers[0] = adopt(*new PIC());
|
||||
m_interrupt_controllers[0] = adopt_ref(*new PIC());
|
||||
SpuriousInterruptHandler::initialize(7);
|
||||
SpuriousInterruptHandler::initialize(15);
|
||||
for (auto& irq_controller : m_interrupt_controllers) {
|
||||
|
@ -183,7 +183,7 @@ UNMAP_AFTER_INIT void InterruptManagement::locate_apic_data()
|
|||
|
||||
int irq_controller_count = 0;
|
||||
if (madt->flags & PCAT_COMPAT_FLAG) {
|
||||
m_interrupt_controllers[0] = adopt(*new PIC());
|
||||
m_interrupt_controllers[0] = adopt_ref(*new PIC());
|
||||
irq_controller_count++;
|
||||
}
|
||||
size_t entry_index = 0;
|
||||
|
@ -195,7 +195,7 @@ UNMAP_AFTER_INIT void InterruptManagement::locate_apic_data()
|
|||
auto* ioapic_entry = (const ACPI::Structures::MADTEntries::IOAPIC*)madt_entry;
|
||||
dbgln("IOAPIC found @ MADT entry {}, MMIO Registers @ {}", entry_index, PhysicalAddress(ioapic_entry->ioapic_address));
|
||||
m_interrupt_controllers.resize(1 + irq_controller_count);
|
||||
m_interrupt_controllers[irq_controller_count] = adopt(*new IOAPIC(PhysicalAddress(ioapic_entry->ioapic_address), ioapic_entry->gsi_base));
|
||||
m_interrupt_controllers[irq_controller_count] = adopt_ref(*new IOAPIC(PhysicalAddress(ioapic_entry->ioapic_address), ioapic_entry->gsi_base));
|
||||
irq_controller_count++;
|
||||
}
|
||||
if (madt_entry->type == (u8)ACPI::Structures::MADTEntryType::InterruptSourceOverride) {
|
||||
|
|
|
@ -32,7 +32,7 @@ public:
|
|||
auto region = MM.allocate_kernel_region(page_round_up(size), name, access, strategy);
|
||||
if (!region)
|
||||
return nullptr;
|
||||
return adopt(*new KBufferImpl(region.release_nonnull(), size, strategy));
|
||||
return adopt_ref(*new KBufferImpl(region.release_nonnull(), size, strategy));
|
||||
}
|
||||
|
||||
static RefPtr<KBufferImpl> try_create_with_bytes(ReadonlyBytes bytes, Region::Access access, const char* name = "KBuffer", AllocationStrategy strategy = AllocationStrategy::Reserve)
|
||||
|
@ -41,7 +41,7 @@ public:
|
|||
if (!region)
|
||||
return nullptr;
|
||||
memcpy(region->vaddr().as_ptr(), bytes.data(), bytes.size());
|
||||
return adopt(*new KBufferImpl(region.release_nonnull(), bytes.size(), strategy));
|
||||
return adopt_ref(*new KBufferImpl(region.release_nonnull(), bytes.size(), strategy));
|
||||
}
|
||||
|
||||
static RefPtr<KBufferImpl> create_with_size(size_t size, Region::Access access, const char* name, AllocationStrategy strategy = AllocationStrategy::Reserve)
|
||||
|
|
|
@ -165,7 +165,7 @@ UNMAP_AFTER_INIT void E1000NetworkAdapter::detect()
|
|||
if (!is_valid_device_id(id.device_id))
|
||||
return;
|
||||
u8 irq = PCI::get_interrupt_line(address);
|
||||
[[maybe_unused]] auto& unused = adopt(*new E1000NetworkAdapter(address, irq)).leak_ref();
|
||||
[[maybe_unused]] auto& unused = adopt_ref(*new E1000NetworkAdapter(address, irq)).leak_ref();
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
@ -41,7 +41,7 @@ KResultOr<NonnullRefPtr<Socket>> IPv4Socket::create(int type, int protocol)
|
|||
if (type == SOCK_DGRAM)
|
||||
return UDPSocket::create(protocol);
|
||||
if (type == SOCK_RAW)
|
||||
return adopt(*new IPv4Socket(type, protocol));
|
||||
return adopt_ref(*new IPv4Socket(type, protocol));
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
|
|
|
@ -33,7 +33,7 @@ void LocalSocket::for_each(Function<void(const LocalSocket&)> callback)
|
|||
|
||||
KResultOr<NonnullRefPtr<Socket>> LocalSocket::create(int type)
|
||||
{
|
||||
return adopt(*new LocalSocket(type));
|
||||
return adopt_ref(*new LocalSocket(type));
|
||||
}
|
||||
|
||||
LocalSocket::LocalSocket(int type)
|
||||
|
|
|
@ -158,7 +158,7 @@ UNMAP_AFTER_INIT void NE2000NetworkAdapter::detect()
|
|||
if (!ne2k_ids.span().contains_slow(id))
|
||||
return;
|
||||
u8 irq = PCI::get_interrupt_line(address);
|
||||
[[maybe_unused]] auto& unused = adopt(*new NE2000NetworkAdapter(address, irq)).leak_ref();
|
||||
[[maybe_unused]] auto& unused = adopt_ref(*new NE2000NetworkAdapter(address, irq)).leak_ref();
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
@ -114,7 +114,7 @@ UNMAP_AFTER_INIT void RTL8139NetworkAdapter::detect()
|
|||
if (id != rtl8139_id)
|
||||
return;
|
||||
u8 irq = PCI::get_interrupt_line(address);
|
||||
[[maybe_unused]] auto& unused = adopt(*new RTL8139NetworkAdapter(address, irq)).leak_ref();
|
||||
[[maybe_unused]] auto& unused = adopt_ref(*new RTL8139NetworkAdapter(address, irq)).leak_ref();
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
@ -139,7 +139,7 @@ TCPSocket::~TCPSocket()
|
|||
|
||||
NonnullRefPtr<TCPSocket> TCPSocket::create(int protocol)
|
||||
{
|
||||
return adopt(*new TCPSocket(protocol));
|
||||
return adopt_ref(*new TCPSocket(protocol));
|
||||
}
|
||||
|
||||
KResultOr<size_t> TCPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
|
||||
|
|
|
@ -56,7 +56,7 @@ UDPSocket::~UDPSocket()
|
|||
|
||||
NonnullRefPtr<UDPSocket> UDPSocket::create(int protocol)
|
||||
{
|
||||
return adopt(*new UDPSocket(protocol));
|
||||
return adopt_ref(*new UDPSocket(protocol));
|
||||
}
|
||||
|
||||
KResultOr<size_t> UDPSocket::protocol_receive(ReadonlyBytes raw_ipv4_packet, UserOrKernelBuffer& buffer, size_t buffer_size, [[maybe_unused]] int flags)
|
||||
|
|
|
@ -143,7 +143,7 @@ RefPtr<Process> Process::create_user_process(RefPtr<Thread>& first_thread, const
|
|||
if (!cwd)
|
||||
cwd = VFS::the().root_custody();
|
||||
|
||||
auto process = adopt(*new Process(first_thread, parts.take_last(), uid, gid, parent_pid, false, move(cwd), nullptr, tty));
|
||||
auto process = adopt_ref(*new Process(first_thread, parts.take_last(), uid, gid, parent_pid, false, move(cwd), nullptr, tty));
|
||||
if (!first_thread)
|
||||
return {};
|
||||
process->m_fds.resize(m_max_open_file_descriptors);
|
||||
|
@ -171,7 +171,7 @@ RefPtr<Process> Process::create_user_process(RefPtr<Thread>& first_thread, const
|
|||
|
||||
RefPtr<Process> Process::create_kernel_process(RefPtr<Thread>& first_thread, String&& name, void (*entry)(void*), void* entry_data, u32 affinity)
|
||||
{
|
||||
auto process = adopt(*new Process(first_thread, move(name), (uid_t)0, (gid_t)0, ProcessID(0), true));
|
||||
auto process = adopt_ref(*new Process(first_thread, move(name), (uid_t)0, (gid_t)0, ProcessID(0), true));
|
||||
if (!first_thread)
|
||||
return {};
|
||||
first_thread->tss().eip = (FlatPtr)entry;
|
||||
|
|
|
@ -19,7 +19,7 @@ ProcessGroup::~ProcessGroup()
|
|||
|
||||
NonnullRefPtr<ProcessGroup> ProcessGroup::create(ProcessGroupID pgid)
|
||||
{
|
||||
auto process_group = adopt(*new ProcessGroup(pgid));
|
||||
auto process_group = adopt_ref(*new ProcessGroup(pgid));
|
||||
{
|
||||
ScopedSpinLock lock(g_process_groups_lock);
|
||||
g_process_groups->prepend(process_group);
|
||||
|
|
|
@ -17,7 +17,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<AHCIController> AHCIController::initialize(PCI::Address address)
|
||||
{
|
||||
return adopt(*new AHCIController(address));
|
||||
return adopt_ref(*new AHCIController(address));
|
||||
}
|
||||
|
||||
bool AHCIController::reset()
|
||||
|
|
|
@ -18,7 +18,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<AHCIPort::ScatterList> AHCIPort::ScatterList::create(AsyncBlockDeviceRequest& request, NonnullRefPtrVector<PhysicalPage> allocated_pages, size_t device_block_size)
|
||||
{
|
||||
return adopt(*new ScatterList(request, allocated_pages, device_block_size));
|
||||
return adopt_ref(*new ScatterList(request, allocated_pages, device_block_size));
|
||||
}
|
||||
|
||||
AHCIPort::ScatterList::ScatterList(AsyncBlockDeviceRequest& request, NonnullRefPtrVector<PhysicalPage> allocated_pages, size_t device_block_size)
|
||||
|
@ -29,7 +29,7 @@ AHCIPort::ScatterList::ScatterList(AsyncBlockDeviceRequest& request, NonnullRefP
|
|||
|
||||
NonnullRefPtr<AHCIPort> AHCIPort::create(const AHCIPortHandler& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
{
|
||||
return adopt(*new AHCIPort(handler, registers, port_index));
|
||||
return adopt_ref(*new AHCIPort(handler, registers, port_index));
|
||||
}
|
||||
|
||||
AHCIPort::AHCIPort(const AHCIPortHandler& handler, volatile AHCI::PortRegisters& registers, u32 port_index)
|
||||
|
|
|
@ -11,7 +11,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<AHCIPortHandler> AHCIPortHandler::create(AHCIController& controller, u8 irq, AHCI::MaskedBitField taken_ports)
|
||||
{
|
||||
return adopt(*new AHCIPortHandler(controller, irq, taken_ports));
|
||||
return adopt_ref(*new AHCIPortHandler(controller, irq, taken_ports));
|
||||
}
|
||||
|
||||
AHCIPortHandler::AHCIPortHandler(AHCIController& controller, u8 irq, AHCI::MaskedBitField taken_ports)
|
||||
|
|
|
@ -13,12 +13,12 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(const IDEController& ide_controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
{
|
||||
return adopt(*new BMIDEChannel(ide_controller, io_group, type));
|
||||
return adopt_ref(*new BMIDEChannel(ide_controller, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<BMIDEChannel> BMIDEChannel::create(const IDEController& ide_controller, u8 irq, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
{
|
||||
return adopt(*new BMIDEChannel(ide_controller, irq, io_group, type));
|
||||
return adopt_ref(*new BMIDEChannel(ide_controller, irq, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT BMIDEChannel::BMIDEChannel(const IDEController& controller, IDEChannel::IOAddressGroup io_group, IDEChannel::ChannelType type)
|
||||
|
|
|
@ -26,12 +26,12 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(const IDEController& controller, IOAddressGroup io_group, ChannelType type)
|
||||
{
|
||||
return adopt(*new IDEChannel(controller, io_group, type));
|
||||
return adopt_ref(*new IDEChannel(controller, io_group, type));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEChannel> IDEChannel::create(const IDEController& controller, u8 irq, IOAddressGroup io_group, ChannelType type)
|
||||
{
|
||||
return adopt(*new IDEChannel(controller, irq, io_group, type));
|
||||
return adopt_ref(*new IDEChannel(controller, irq, io_group, type));
|
||||
}
|
||||
|
||||
RefPtr<StorageDevice> IDEChannel::master_device() const
|
||||
|
|
|
@ -16,7 +16,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<IDEController> IDEController::initialize(PCI::Address address, bool force_pio)
|
||||
{
|
||||
return adopt(*new IDEController(address, force_pio));
|
||||
return adopt_ref(*new IDEController(address, force_pio));
|
||||
}
|
||||
|
||||
bool IDEController::reset()
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<PATADiskDevice> PATADiskDevice::create(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 capabilities, u64 max_addressable_block)
|
||||
{
|
||||
return adopt(*new PATADiskDevice(controller, channel, type, interface_type, capabilities, max_addressable_block));
|
||||
return adopt_ref(*new PATADiskDevice(controller, channel, type, interface_type, capabilities, max_addressable_block));
|
||||
}
|
||||
|
||||
UNMAP_AFTER_INIT PATADiskDevice::PATADiskDevice(const IDEController& controller, IDEChannel& channel, DriveType type, InterfaceType interface_type, u16 capabilities, u64 max_addressable_block)
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<DiskPartition> DiskPartition::create(BlockDevice& device, unsigned minor_number, DiskPartitionMetadata metadata)
|
||||
{
|
||||
return adopt(*new DiskPartition(device, minor_number, metadata));
|
||||
return adopt_ref(*new DiskPartition(device, minor_number, metadata));
|
||||
}
|
||||
|
||||
DiskPartition::DiskPartition(BlockDevice& device, unsigned minor_number, DiskPartitionMetadata metadata)
|
||||
|
|
|
@ -13,7 +13,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<RamdiskController> RamdiskController::initialize()
|
||||
{
|
||||
return adopt(*new RamdiskController());
|
||||
return adopt_ref(*new RamdiskController());
|
||||
}
|
||||
|
||||
bool RamdiskController::reset()
|
||||
|
|
|
@ -14,7 +14,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<RamdiskDevice> RamdiskDevice::create(const RamdiskController& controller, NonnullOwnPtr<Region>&& region, int major, int minor)
|
||||
{
|
||||
return adopt(*new RamdiskDevice(controller, move(region), major, minor));
|
||||
return adopt_ref(*new RamdiskDevice(controller, move(region), major, minor));
|
||||
}
|
||||
|
||||
RamdiskDevice::RamdiskDevice(const RamdiskController& controller, NonnullOwnPtr<Region>&& region, int major, int minor)
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<SATADiskDevice> SATADiskDevice::create(const AHCIController& controller, const AHCIPort& port, size_t sector_size, u64 max_addressable_block)
|
||||
{
|
||||
return adopt(*new SATADiskDevice(controller, port, sector_size, max_addressable_block));
|
||||
return adopt_ref(*new SATADiskDevice(controller, port, sector_size, max_addressable_block));
|
||||
}
|
||||
|
||||
SATADiskDevice::SATADiskDevice(const AHCIController& controller, const AHCIPort& port, size_t sector_size, u64 max_addressable_block)
|
||||
|
|
|
@ -16,7 +16,7 @@ KResultOr<pid_t> Process::sys$fork(RegisterState& regs)
|
|||
{
|
||||
REQUIRE_PROMISE(proc);
|
||||
RefPtr<Thread> child_first_thread;
|
||||
auto child = adopt(*new Process(child_first_thread, m_name, uid(), gid(), pid(), m_is_kernel_process, m_cwd, m_executable, m_tty, this));
|
||||
auto child = adopt_ref(*new Process(child_first_thread, m_name, uid(), gid(), pid(), m_is_kernel_process, m_cwd, m_executable, m_tty, this));
|
||||
if (!child_first_thread)
|
||||
return ENOMEM;
|
||||
child->m_root_directory = m_root_directory;
|
||||
|
|
|
@ -167,7 +167,7 @@ KResultOr<int> Process::sys$futex(Userspace<const Syscall::SC_futex_params*> use
|
|||
if (it != queues->end())
|
||||
return it->value;
|
||||
if (create_if_not_found) {
|
||||
auto futex_queue = adopt(*new FutexQueue(user_address_or_offset, vmobject));
|
||||
auto futex_queue = adopt_ref(*new FutexQueue(user_address_or_offset, vmobject));
|
||||
auto result = queues->set(user_address_or_offset, futex_queue);
|
||||
VERIFY(result == AK::HashSetResult::InsertedNewEntry);
|
||||
return futex_queue;
|
||||
|
|
|
@ -17,7 +17,7 @@ namespace Kernel {
|
|||
|
||||
MasterPTY::MasterPTY(unsigned index)
|
||||
: CharacterDevice(200, index)
|
||||
, m_slave(adopt(*new SlavePTY(*this, index)))
|
||||
, m_slave(adopt_ref(*new SlavePTY(*this, index)))
|
||||
, m_index(index)
|
||||
{
|
||||
m_pts_name = String::formatted("/dev/pts/{}", m_index);
|
||||
|
|
|
@ -40,7 +40,7 @@ KResultOr<NonnullRefPtr<FileDescription>> PTYMultiplexer::open(int options)
|
|||
if (m_freelist.is_empty())
|
||||
return EBUSY;
|
||||
auto master_index = m_freelist.take_last();
|
||||
auto master = adopt(*new MasterPTY(master_index));
|
||||
auto master = adopt_ref(*new MasterPTY(master_index));
|
||||
dbgln_if(PTMX_DEBUG, "PTYMultiplexer::open: Vending master {}", master->index());
|
||||
auto description = FileDescription::create(move(master));
|
||||
if (!description.is_error()) {
|
||||
|
|
|
@ -41,7 +41,7 @@ KResultOr<NonnullRefPtr<Thread>> Thread::try_create(NonnullRefPtr<Process> proce
|
|||
if (!kernel_stack_region)
|
||||
return ENOMEM;
|
||||
kernel_stack_region->set_stack(true);
|
||||
return adopt(*new Thread(move(process), kernel_stack_region.release_nonnull()));
|
||||
return adopt_ref(*new Thread(move(process), kernel_stack_region.release_nonnull()));
|
||||
}
|
||||
|
||||
Thread::Thread(NonnullRefPtr<Process> process, NonnullOwnPtr<Region> kernel_stack_region)
|
||||
|
|
|
@ -19,7 +19,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT APICTimer* APICTimer::initialize(u8 interrupt_number, HardwareTimerBase& calibration_source)
|
||||
{
|
||||
auto timer = adopt(*new APICTimer(interrupt_number, nullptr));
|
||||
auto timer = adopt_ref(*new APICTimer(interrupt_number, nullptr));
|
||||
timer->register_interrupt_handler();
|
||||
if (!timer->calibrate(calibration_source)) {
|
||||
return nullptr;
|
||||
|
|
|
@ -13,7 +13,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<HPETComparator> HPETComparator::create(u8 number, u8 irq, bool periodic_capable)
|
||||
{
|
||||
auto timer = adopt(*new HPETComparator(number, irq, periodic_capable));
|
||||
auto timer = adopt_ref(*new HPETComparator(number, irq, periodic_capable));
|
||||
timer->register_interrupt_handler();
|
||||
return timer;
|
||||
}
|
||||
|
|
|
@ -17,7 +17,7 @@ namespace Kernel {
|
|||
|
||||
UNMAP_AFTER_INIT NonnullRefPtr<PIT> PIT::initialize(Function<void(const RegisterState&)> callback)
|
||||
{
|
||||
return adopt(*new PIT(move(callback)));
|
||||
return adopt_ref(*new PIT(move(callback)));
|
||||
}
|
||||
|
||||
inline static void reset_countdown(u16 timer_reload)
|
||||
|
|
|
@ -16,7 +16,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<RealTimeClock> RealTimeClock::create(Function<void(const RegisterState&)> callback)
|
||||
{
|
||||
return adopt(*new RealTimeClock(move(callback)));
|
||||
return adopt_ref(*new RealTimeClock(move(callback)));
|
||||
}
|
||||
RealTimeClock::RealTimeClock(Function<void(const RegisterState&)> callback)
|
||||
: HardwareTimer(IRQ_TIMER, move(callback))
|
||||
|
|
|
@ -67,7 +67,7 @@ RefPtr<Timer> TimerQueue::add_timer_without_id(clockid_t clock_id, const Time& d
|
|||
// *must* be a RefPtr<Timer>. Otherwise calling cancel_timer() could
|
||||
// inadvertently cancel another timer that has been created between
|
||||
// returning from the timer handler and a call to cancel_timer().
|
||||
auto timer = adopt(*new Timer(clock_id, deadline, move(callback)));
|
||||
auto timer = adopt_ref(*new Timer(clock_id, deadline, move(callback)));
|
||||
|
||||
ScopedSpinLock lock(g_timerqueue_lock);
|
||||
timer->m_id = 0; // Don't generate a timer id
|
||||
|
@ -119,7 +119,7 @@ TimerId TimerQueue::add_timer(clockid_t clock_id, const Time& deadline, Function
|
|||
{
|
||||
auto expires = TimeManagement::the().current_time(clock_id).value();
|
||||
expires = expires + deadline;
|
||||
return add_timer(adopt(*new Timer(clock_id, expires, move(callback))));
|
||||
return add_timer(adopt_ref(*new Timer(clock_id, expires, move(callback))));
|
||||
}
|
||||
|
||||
bool TimerQueue::cancel_timer(TimerId id)
|
||||
|
|
|
@ -41,13 +41,13 @@ RefPtr<VMObject> AnonymousVMObject::clone()
|
|||
// one would keep the one it still has. This ensures that the original
|
||||
// one and this one, as well as the clone have sufficient resources
|
||||
// to cow all pages as needed
|
||||
m_shared_committed_cow_pages = adopt(*new CommittedCowPages(need_cow_pages));
|
||||
m_shared_committed_cow_pages = adopt_ref(*new CommittedCowPages(need_cow_pages));
|
||||
|
||||
// Both original and clone become COW. So create a COW map for ourselves
|
||||
// or reset all pages to be copied again if we were previously cloned
|
||||
ensure_or_reset_cow_map();
|
||||
|
||||
return adopt(*new AnonymousVMObject(*this));
|
||||
return adopt_ref(*new AnonymousVMObject(*this));
|
||||
}
|
||||
|
||||
RefPtr<AnonymousVMObject> AnonymousVMObject::create_with_size(size_t size, AllocationStrategy commit)
|
||||
|
@ -57,17 +57,17 @@ RefPtr<AnonymousVMObject> AnonymousVMObject::create_with_size(size_t size, Alloc
|
|||
if (!MM.commit_user_physical_pages(ceil_div(size, static_cast<size_t>(PAGE_SIZE))))
|
||||
return {};
|
||||
}
|
||||
return adopt(*new AnonymousVMObject(size, commit));
|
||||
return adopt_ref(*new AnonymousVMObject(size, commit));
|
||||
}
|
||||
|
||||
NonnullRefPtr<AnonymousVMObject> AnonymousVMObject::create_with_physical_pages(NonnullRefPtrVector<PhysicalPage> physical_pages)
|
||||
{
|
||||
return adopt(*new AnonymousVMObject(physical_pages));
|
||||
return adopt_ref(*new AnonymousVMObject(physical_pages));
|
||||
}
|
||||
|
||||
NonnullRefPtr<AnonymousVMObject> AnonymousVMObject::create_with_physical_page(PhysicalPage& page)
|
||||
{
|
||||
return adopt(*new AnonymousVMObject(page));
|
||||
return adopt_ref(*new AnonymousVMObject(page));
|
||||
}
|
||||
|
||||
RefPtr<AnonymousVMObject> AnonymousVMObject::create_for_physical_range(PhysicalAddress paddr, size_t size)
|
||||
|
@ -76,7 +76,7 @@ RefPtr<AnonymousVMObject> AnonymousVMObject::create_for_physical_range(PhysicalA
|
|||
dbgln("Shenanigans! create_for_physical_range({}, {}) would wrap around", paddr, size);
|
||||
return nullptr;
|
||||
}
|
||||
return adopt(*new AnonymousVMObject(paddr, size));
|
||||
return adopt_ref(*new AnonymousVMObject(paddr, size));
|
||||
}
|
||||
|
||||
AnonymousVMObject::AnonymousVMObject(size_t size, AllocationStrategy strategy)
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<ContiguousVMObject> ContiguousVMObject::create_with_size(size_t size, size_t physical_alignment)
|
||||
{
|
||||
return adopt(*new ContiguousVMObject(size, physical_alignment));
|
||||
return adopt_ref(*new ContiguousVMObject(size, physical_alignment));
|
||||
}
|
||||
|
||||
ContiguousVMObject::ContiguousVMObject(size_t size, size_t physical_alignment)
|
||||
|
|
|
@ -22,12 +22,12 @@ class PageDirectory : public RefCounted<PageDirectory> {
|
|||
public:
|
||||
static RefPtr<PageDirectory> create_for_userspace(const RangeAllocator* parent_range_allocator = nullptr)
|
||||
{
|
||||
auto page_directory = adopt(*new PageDirectory(parent_range_allocator));
|
||||
auto page_directory = adopt_ref(*new PageDirectory(parent_range_allocator));
|
||||
if (!page_directory->is_valid())
|
||||
return {};
|
||||
return page_directory;
|
||||
}
|
||||
static NonnullRefPtr<PageDirectory> create_kernel_page_directory() { return adopt(*new PageDirectory); }
|
||||
static NonnullRefPtr<PageDirectory> create_kernel_page_directory() { return adopt_ref(*new PageDirectory); }
|
||||
static RefPtr<PageDirectory> find_by_cr3(u32);
|
||||
|
||||
~PageDirectory();
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<PhysicalPage> PhysicalPage::create(PhysicalAddress paddr, bool supervisor, bool may_return_to_freelist)
|
||||
{
|
||||
return adopt(*new PhysicalPage(paddr, supervisor, may_return_to_freelist));
|
||||
return adopt_ref(*new PhysicalPage(paddr, supervisor, may_return_to_freelist));
|
||||
}
|
||||
|
||||
PhysicalPage::PhysicalPage(PhysicalAddress paddr, bool supervisor, bool may_return_to_freelist)
|
||||
|
|
|
@ -17,7 +17,7 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<PhysicalRegion> PhysicalRegion::create(PhysicalAddress lower, PhysicalAddress upper)
|
||||
{
|
||||
return adopt(*new PhysicalRegion(lower, upper));
|
||||
return adopt_ref(*new PhysicalRegion(lower, upper));
|
||||
}
|
||||
|
||||
PhysicalRegion::PhysicalRegion(PhysicalAddress lower, PhysicalAddress upper)
|
||||
|
|
|
@ -11,12 +11,12 @@ namespace Kernel {
|
|||
|
||||
NonnullRefPtr<PrivateInodeVMObject> PrivateInodeVMObject::create_with_inode(Inode& inode)
|
||||
{
|
||||
return adopt(*new PrivateInodeVMObject(inode, inode.size()));
|
||||
return adopt_ref(*new PrivateInodeVMObject(inode, inode.size()));
|
||||
}
|
||||
|
||||
RefPtr<VMObject> PrivateInodeVMObject::clone()
|
||||
{
|
||||
return adopt(*new PrivateInodeVMObject(*this));
|
||||
return adopt_ref(*new PrivateInodeVMObject(*this));
|
||||
}
|
||||
|
||||
PrivateInodeVMObject::PrivateInodeVMObject(Inode& inode, size_t size)
|
||||
|
|
|
@ -14,14 +14,14 @@ NonnullRefPtr<SharedInodeVMObject> SharedInodeVMObject::create_with_inode(Inode&
|
|||
size_t size = inode.size();
|
||||
if (auto shared_vmobject = inode.shared_vmobject())
|
||||
return shared_vmobject.release_nonnull();
|
||||
auto vmobject = adopt(*new SharedInodeVMObject(inode, size));
|
||||
auto vmobject = adopt_ref(*new SharedInodeVMObject(inode, size));
|
||||
vmobject->inode().set_shared_vmobject(*vmobject);
|
||||
return vmobject;
|
||||
}
|
||||
|
||||
RefPtr<VMObject> SharedInodeVMObject::clone()
|
||||
{
|
||||
return adopt(*new SharedInodeVMObject(*this));
|
||||
return adopt_ref(*new SharedInodeVMObject(*this));
|
||||
}
|
||||
|
||||
SharedInodeVMObject::SharedInodeVMObject(Inode& inode, size_t size)
|
||||
|
|
|
@ -22,11 +22,11 @@ void VirtIO::detect()
|
|||
return;
|
||||
switch (id.device_id) {
|
||||
case VIRTIO_CONSOLE_PCI_DEVICE_ID: {
|
||||
[[maybe_unused]] auto& unused = adopt(*new VirtIOConsole(address)).leak_ref();
|
||||
[[maybe_unused]] auto& unused = adopt_ref(*new VirtIOConsole(address)).leak_ref();
|
||||
break;
|
||||
}
|
||||
case VIRTIO_ENTROPY_PCI_DEVICE_ID: {
|
||||
[[maybe_unused]] auto& unused = adopt(*new VirtIORNG(address)).leak_ref();
|
||||
[[maybe_unused]] auto& unused = adopt_ref(*new VirtIORNG(address)).leak_ref();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue