RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 21:27:35 +00:00
Code Issues Activity Actions

AK: Rename adopt() to adopt_ref()

Browse source 
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:
Andreas Kling 2021-04-23 16:46:57 +02:00
parent b3db01e20e
commit b91c49364d
228 changed files with 461 additions and 461 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/Devices/Device.h
View file

@ -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);

2
Kernel/Devices/HID/I8042Controller.cpp
View file

@ -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

2
Kernel/Devices/HID/PS2KeyboardDevice.cpp
View file

@ -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;

2
Kernel/Devices/HID/PS2MouseDevice.cpp
View file

@ -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;

2
Kernel/Devices/HID/VMWareMouseDevice.cpp
View file

@ -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 {};

2
Kernel/FileSystem/AnonymousFile.h
View file

@ -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;

2
Kernel/FileSystem/Custody.h
View file

@ -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();

10
Kernel/FileSystem/DevFS.cpp
View file

@ -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;

6
Kernel/FileSystem/DevPtsFS.cpp
View file

@ -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();

4
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -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.

2
Kernel/FileSystem/FIFO.cpp
View file

@ -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)

4
Kernel/FileSystem/FileDescription.cpp
View file

@ -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);

2
Kernel/FileSystem/InodeFile.h
View file

@ -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;

2
Kernel/FileSystem/InodeWatcher.cpp
View file

@ -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)

6
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -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()

8
Kernel/FileSystem/ProcFS.cpp
View file

@ -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 };

2
Kernel/FileSystem/ProcFS.h
View file

@ -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;

4
Kernel/FileSystem/TmpFS.cpp
View file

@ -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;
}

6
Kernel/Interrupts/InterruptManagement.cpp
View file

@ -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) {

4
Kernel/KBuffer.h
View file

@ -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)

2
Kernel/Net/E1000NetworkAdapter.cpp
View file

@ -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();
});
}

2
Kernel/Net/IPv4Socket.cpp
View file

@ -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;
}

2
Kernel/Net/LocalSocket.cpp
View file

@ -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)

2
Kernel/Net/NE2000NetworkAdapter.cpp
View file

@ -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();
});
}

2
Kernel/Net/RTL8139NetworkAdapter.cpp
View file

@ -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();
});
}

2
Kernel/Net/TCPSocket.cpp
View file

@ -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)

2
Kernel/Net/UDPSocket.cpp
View file

@ -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)

4
Kernel/Process.cpp
View file

@ -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;

2
Kernel/ProcessGroup.cpp
View file

@ -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);

2
Kernel/Storage/AHCIController.cpp
View file

@ -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()

4
Kernel/Storage/AHCIPort.cpp
View file

@ -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)

2
Kernel/Storage/AHCIPortHandler.cpp
View file

@ -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)

4
Kernel/Storage/BMIDEChannel.cpp
View file

@ -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)

4
Kernel/Storage/IDEChannel.cpp
View file

@ -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

2
Kernel/Storage/IDEController.cpp
View file

@ -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()

2
Kernel/Storage/PATADiskDevice.cpp
View file

@ -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)

2
Kernel/Storage/Partition/DiskPartition.cpp
View file

@ -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)

2
Kernel/Storage/RamdiskController.cpp
View file

@ -13,7 +13,7 @@ namespace Kernel {
NonnullRefPtr<RamdiskController> RamdiskController::initialize()
{
return adopt(*new RamdiskController());
return adopt_ref(*new RamdiskController());
}
bool RamdiskController::reset()

2
Kernel/Storage/RamdiskDevice.cpp
View file

@ -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)

2
Kernel/Storage/SATADiskDevice.cpp
View file

@ -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)

2
Kernel/Syscalls/fork.cpp
View file

@ -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;

2
Kernel/Syscalls/futex.cpp
View file

@ -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;

2
Kernel/TTY/MasterPTY.cpp
View file

@ -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);

2
Kernel/TTY/PTYMultiplexer.cpp
View file

@ -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()) {

2
Kernel/Thread.cpp
View file

@ -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)

2
Kernel/Time/APICTimer.cpp
View file

@ -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;

2
Kernel/Time/HPETComparator.cpp
View file

@ -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;
}

2
Kernel/Time/PIT.cpp
View file

@ -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)

2
Kernel/Time/RTC.cpp
View file

@ -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))

4
Kernel/TimerQueue.cpp
View file

@ -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)

12
Kernel/VM/AnonymousVMObject.cpp
View file

@ -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)

2
Kernel/VM/ContiguousVMObject.cpp
View file

@ -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)

4
Kernel/VM/PageDirectory.h
View file

@ -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();

2
Kernel/VM/PhysicalPage.cpp
View file

@ -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)

2
Kernel/VM/PhysicalRegion.cpp
View file

@ -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)

4
Kernel/VM/PrivateInodeVMObject.cpp
View file

@ -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)

4
Kernel/VM/SharedInodeVMObject.cpp
View file

@ -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)

4
Kernel/VirtIO/VirtIO.cpp
View file

@ -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: