RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 20:58:11 +00:00
Code Issues Activity Actions

AK: Rename the common integer typedefs to make it obvious what they are.

Browse source 
These types can be picked up by including <AK/Types.h>:

* u8, u16, u32, u64 (unsigned)
* i8, i16, i32, i64 (signed)
This commit is contained in:
Andreas Kling 2019-07-03 21:17:35 +02:00
parent c4c4bbc5ba
commit 27f699ef0c
208 changed files with 1603 additions and 1621 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/FileSystem/DiskBackedFileSystem.cpp
View file

@ -126,7 +126,7 @@ ByteBuffer DiskBackedFS::read_blocks(unsigned index, unsigned count) const
if (count == 1)
return read_block(index);
auto blocks = ByteBuffer::create_uninitialized(count * block_size());
byte* out = blocks.pointer();
u8* out = blocks.pointer();
for (unsigned i = 0; i < count; ++i) {
auto block = read_block(index + i);

42
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -12,7 +12,7 @@
static const ssize_t max_inline_symlink_length = 60;
static byte to_ext2_file_type(mode_t mode)
static u8 to_ext2_file_type(mode_t mode)
{
if (is_regular_file(mode))
return EXT2_FT_REG_FILE;
@ -59,7 +59,7 @@ ByteBuffer Ext2FS::read_super_block() const
bool Ext2FS::write_super_block(const ext2_super_block& sb)
{
LOCKER(m_lock);
const byte* raw = (const byte*)&sb;
const u8* raw = (const u8*)&sb;
bool success;
success = device().write_block(2, raw);
ASSERT(success);
@ -479,7 +479,7 @@ RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
return new_inode;
}
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription*) const
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription*) const
{
Locker inode_locker(m_lock);
ASSERT(offset >= 0);
@ -490,7 +490,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
// This avoids wasting an entire block on short links. (Most links are short.)
if (is_symlink() && size() < max_inline_symlink_length) {
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
memcpy(buffer, ((const byte*)m_raw_inode.i_block) + offset, (size_t)nread);
memcpy(buffer, ((const u8*)m_raw_inode.i_block) + offset, (size_t)nread);
return nread;
}
@ -518,7 +518,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
ssize_t nread = 0;
int remaining_count = min((off_t)count, (off_t)size() - offset);
byte* out = buffer;
u8* out = buffer;
#ifdef EXT2_DEBUG
kprintf("Ext2FS: Reading up to %u bytes %d bytes into inode %u:%u to %p\n", count, offset, identifier().fsid(), identifier().index(), buffer);
@ -543,10 +543,10 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
return nread;
}
bool Ext2FSInode::resize(qword new_size)
bool Ext2FSInode::resize(u64 new_size)
{
qword block_size = fs().block_size();
qword old_size = size();
u64 block_size = fs().block_size();
u64 old_size = size();
int blocks_needed_before = ceil_div(old_size, block_size);
int blocks_needed_after = ceil_div(new_size, block_size);
@ -585,7 +585,7 @@ bool Ext2FSInode::resize(qword new_size)
return true;
}
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data, FileDescription*)
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const u8* data, FileDescription*)
{
ASSERT(offset >= 0);
ASSERT(count >= 0);
@ -598,7 +598,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
#ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode: write_bytes poking into i_block array for inline symlink '%s' (%u bytes)\n", String((const char*)data, count).characters(), count);
#endif
memcpy(((byte*)m_raw_inode.i_block) + offset, data, (size_t)count);
memcpy(((u8*)m_raw_inode.i_block) + offset, data, (size_t)count);
if ((offset + count) > (off_t)m_raw_inode.i_size)
m_raw_inode.i_size = offset + count;
set_metadata_dirty(true);
@ -607,8 +607,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
}
const ssize_t block_size = fs().block_size();
qword old_size = size();
qword new_size = max(static_cast<qword>(offset) + count, (qword)size());
u64 old_size = size();
u64 new_size = max(static_cast<u64>(offset) + count, (u64)size());
if (!resize(new_size))
return -EIO;
@ -624,7 +624,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
ssize_t nwritten = 0;
int remaining_count = min((off_t)count, (off_t)new_size - offset);
const byte* in = data;
const u8* in = data;
#ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode::write_bytes: Writing %u bytes %d bytes into inode %u:%u from %p\n", count, offset, fsid(), index(), data);
@ -733,20 +733,20 @@ bool Ext2FSInode::write_directory(const Vector<FS::DirectoryEntry>& entries)
record_length += occupied_size - directory_size;
dbgprintf("* inode: %u", entry.inode.index());
dbgprintf(", name_len: %u", word(entry.name_length));
dbgprintf(", rec_len: %u", word(record_length));
dbgprintf(", file_type: %u", byte(entry.file_type));
dbgprintf(", name_len: %u", u16(entry.name_length));
dbgprintf(", rec_len: %u", u16(record_length));
dbgprintf(", file_type: %u", u8(entry.file_type));
dbgprintf(", name: %s\n", entry.name);
stream << dword(entry.inode.index());
stream << word(record_length);
stream << byte(entry.name_length);
stream << byte(entry.file_type);
stream << u32(entry.inode.index());
stream << u16(record_length);
stream << u8(entry.name_length);
stream << u8(entry.file_type);
stream << entry.name;
int padding = record_length - entry.name_length - 8;
for (int j = 0; j < padding; ++j)
stream << byte(0);
stream << u8(0);
}
stream.fill_to_end(0);

6
Kernel/FileSystem/Ext2FileSystem.h
View file

@ -25,12 +25,12 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(StringView name) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescription*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const u8* data, FileDescription*) override;
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;
virtual int set_atime(time_t) override;
@ -45,7 +45,7 @@ private:
bool write_directory(const Vector<FS::DirectoryEntry>&);
void populate_lookup_cache() const;
bool resize(qword);
bool resize(u64);
Ext2FS& fs();
const Ext2FS& fs() const;

6
Kernel/FileSystem/FIFO.cpp
View file

@ -16,7 +16,7 @@ Lockable<HashTable<FIFO*>>& all_fifos()
return *s_table;
}
RefPtr<FIFO> FIFO::from_fifo_id(dword id)
RefPtr<FIFO> FIFO::from_fifo_id(u32 id)
{
auto* ptr = reinterpret_cast<FIFO*>(id);
LOCKER(all_fifos().lock());
@ -93,7 +93,7 @@ bool FIFO::can_write(FileDescription&) const
return m_buffer.bytes_in_write_buffer() < 4096 || !m_readers;
}
ssize_t FIFO::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t FIFO::read(FileDescription&, u8* buffer, ssize_t size)
{
if (!m_writers && m_buffer.is_empty())
return 0;
@ -107,7 +107,7 @@ ssize_t FIFO::read(FileDescription&, byte* buffer, ssize_t size)
return nread;
}
ssize_t FIFO::write(FileDescription&, const byte* buffer, ssize_t size)
ssize_t FIFO::write(FileDescription&, const u8* buffer, ssize_t size)
{
if (!m_readers) {
current->process().send_signal(SIGPIPE, &current->process());

8
Kernel/FileSystem/FIFO.h
View file

@ -8,13 +8,13 @@ class FileDescription;
class FIFO final : public File {
public:
enum class Direction : byte {
enum class Direction : u8 {
Neither,
Reader,
Writer
};
static RefPtr<FIFO> from_fifo_id(dword);
static RefPtr<FIFO> from_fifo_id(u32);
static NonnullRefPtr<FIFO> create(uid_t);
virtual ~FIFO() override;
@ -28,8 +28,8 @@ public:
private:
// ^File
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual bool can_read(FileDescription&) const override;
virtual bool can_write(FileDescription&) const override;
virtual String absolute_path(const FileDescription&) const override;

14
Kernel/FileSystem/FileDescription.cpp
View file

@ -127,7 +127,7 @@ off_t FileDescription::seek(off_t offset, int whence)
return m_current_offset;
}
ssize_t FileDescription::read(byte* buffer, ssize_t count)
ssize_t FileDescription::read(u8* buffer, ssize_t count)
{
int nread = m_file->read(*this, buffer, count);
if (m_file->is_seekable())
@ -135,7 +135,7 @@ ssize_t FileDescription::read(byte* buffer, ssize_t count)
return nread;
}
ssize_t FileDescription::write(const byte* data, ssize_t size)
ssize_t FileDescription::write(const u8* data, ssize_t size)
{
int nwritten = m_file->write(*this, data, size);
if (m_file->is_seekable())
@ -167,7 +167,7 @@ bool FileDescription::is_directory() const
return metadata().is_directory();
}
ssize_t FileDescription::get_dir_entries(byte* buffer, ssize_t size)
ssize_t FileDescription::get_dir_entries(u8* buffer, ssize_t size)
{
auto metadata = this->metadata();
if (!metadata.is_valid())
@ -180,9 +180,9 @@ ssize_t FileDescription::get_dir_entries(byte* buffer, ssize_t size)
auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
BufferStream stream(temp_buffer);
VFS::the().traverse_directory_inode(*m_inode, [&stream](auto& entry) {
stream << (dword)entry.inode.index();
stream << (byte)entry.file_type;
stream << (dword)entry.name_length;
stream << (u32)entry.inode.index();
stream << (u8)entry.file_type;
stream << (u32)entry.name_length;
stream << entry.name;
return true;
});
@ -318,7 +318,7 @@ const Socket* FileDescription::socket() const
return static_cast<const Socket*>(m_file.ptr());
}
void FileDescription::set_file_flags(dword flags)
void FileDescription::set_file_flags(u32 flags)
{
m_is_blocking = !(flags & O_NONBLOCK);
m_should_append = flags & O_APPEND;

12
Kernel/FileSystem/FileDescription.h
View file

@ -30,8 +30,8 @@ public:
int close();
off_t seek(off_t, int whence);
ssize_t read(byte*, ssize_t);
ssize_t write(const byte* data, ssize_t);
ssize_t read(u8*, ssize_t);
ssize_t write(const u8* data, ssize_t);
KResult fstat(stat&);
KResult fchmod(mode_t);
@ -39,7 +39,7 @@ public:
bool can_read();
bool can_write();
ssize_t get_dir_entries(byte* buffer, ssize_t);
ssize_t get_dir_entries(u8* buffer, ssize_t);
ByteBuffer read_entire_file();
@ -74,8 +74,8 @@ public:
bool should_append() const { return m_should_append; }
void set_should_append(bool s) { m_should_append = s; }
dword file_flags() const { return m_file_flags; }
void set_file_flags(dword);
u32 file_flags() const { return m_file_flags; }
void set_file_flags(u32);
bool is_socket() const;
Socket* socket();
@ -116,7 +116,7 @@ private:
ByteBuffer m_generator_cache;
dword m_file_flags { 0 };
u32 m_file_flags { 0 };
bool m_is_blocking { true };
bool m_should_append { false };

14
Kernel/FileSystem/FileSystem.cpp
View file

@ -7,13 +7,13 @@
#include <Kernel/VM/MemoryManager.h>
#include <LibC/errno_numbers.h>
static dword s_lastFileSystemID;
static HashMap<dword, FS*>* s_fs_map;
static u32 s_lastFileSystemID;
static HashMap<u32, FS*>* s_fs_map;
static HashMap<dword, FS*>& all_fses()
static HashMap<u32, FS*>& all_fses()
{
if (!s_fs_map)
s_fs_map = new HashMap<dword, FS*>();
s_fs_map = new HashMap<u32, FS*>();
return *s_fs_map;
}
@ -28,7 +28,7 @@ FS::~FS()
all_fses().remove(m_fsid);
}
FS* FS::from_fsid(dword id)
FS* FS::from_fsid(u32 id)
{
auto it = all_fses().find(id);
if (it != all_fses().end())
@ -36,7 +36,7 @@ FS* FS::from_fsid(dword id)
return nullptr;
}
FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, u8 ft)
: name_length(strlen(n))
, inode(i)
, file_type(ft)
@ -45,7 +45,7 @@ FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
name[name_length] = '\0';
}
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, byte ft)
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, u8 ft)
: name_length(nl)
, inode(i)
, file_type(ft)

10
Kernel/FileSystem/FileSystem.h
View file

@ -16,7 +16,7 @@
#include <Kernel/KResult.h>
#include <Kernel/Lock.h>
static const dword mepoch = 476763780;
static const u32 mepoch = 476763780;
class Inode;
class FileDescription;
@ -30,7 +30,7 @@ public:
virtual ~FS();
unsigned fsid() const { return m_fsid; }
static FS* from_fsid(dword);
static FS* from_fsid(u32);
static void sync();
static void lock_all();
@ -46,12 +46,12 @@ public:
virtual unsigned free_inode_count() const { return 0; }
struct DirectoryEntry {
DirectoryEntry(const char* name, InodeIdentifier, byte file_type);
DirectoryEntry(const char* name, int name_length, InodeIdentifier, byte file_type);
DirectoryEntry(const char* name, InodeIdentifier, u8 file_type);
DirectoryEntry(const char* name, int name_length, InodeIdentifier, u8 file_type);
char name[256];
int name_length { 0 };
InodeIdentifier inode;
byte file_type { 0 };
u8 file_type { 0 };
};
virtual RefPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, off_t size, dev_t, int& error) = 0;

4
Kernel/FileSystem/Inode.cpp
View file

@ -35,7 +35,7 @@ ByteBuffer Inode::read_entire(FileDescription* descriptor) const
StringBuilder builder(initial_size);
ssize_t nread;
byte buffer[4096];
u8 buffer[4096];
off_t offset = 0;
for (;;) {
nread = read_bytes(offset, sizeof(buffer), buffer, descriptor);
@ -76,7 +76,7 @@ void Inode::will_be_destroyed()
flush_metadata();
}
void Inode::inode_contents_changed(off_t offset, ssize_t size, const byte* data)
void Inode::inode_contents_changed(off_t offset, ssize_t size, const u8* data)
{
if (m_vmo)
m_vmo->inode_contents_changed({}, offset, size, data);

6
Kernel/FileSystem/Inode.h
View file

@ -39,10 +39,10 @@ public:
ByteBuffer read_entire(FileDescription* = nullptr) const;
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const = 0;
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const = 0;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const = 0;
virtual InodeIdentifier lookup(StringView name) = 0;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescription*) = 0;
virtual ssize_t write_bytes(off_t, ssize_t, const u8* data, FileDescription*) = 0;
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) = 0;
virtual KResult remove_child(const StringView& name) = 0;
virtual size_t directory_entry_count() const = 0;
@ -76,7 +76,7 @@ public:
protected:
Inode(FS& fs, unsigned index);
void set_metadata_dirty(bool b) { m_metadata_dirty = b; }
void inode_contents_changed(off_t, ssize_t, const byte*);
void inode_contents_changed(off_t, ssize_t, const u8*);
void inode_size_changed(size_t old_size, size_t new_size);
mutable Lock m_lock { "Inode" };

4
Kernel/FileSystem/InodeFile.cpp
View file

@ -13,12 +13,12 @@ InodeFile::~InodeFile()
{
}
ssize_t InodeFile::read(FileDescription& description, byte* buffer, ssize_t count)
ssize_t InodeFile::read(FileDescription& description, u8* buffer, ssize_t count)
{
return m_inode->read_bytes(description.offset(), count, buffer, &description);
}
ssize_t InodeFile::write(FileDescription& description, const byte* data, ssize_t count)
ssize_t InodeFile::write(FileDescription& description, const u8* data, ssize_t count)
{
return m_inode->write_bytes(description.offset(), count, data, &description);
}

4
Kernel/FileSystem/InodeFile.h
View file

@ -19,8 +19,8 @@ public:
virtual bool can_read(FileDescription&) const override { return true; }
virtual bool can_write(FileDescription&) const override { return true; }
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot) override;
virtual String absolute_path(const FileDescription&) const override;

10
Kernel/FileSystem/InodeIdentifier.h
View file

@ -10,7 +10,7 @@ struct InodeMetadata;
class InodeIdentifier {
public:
InodeIdentifier() {}
InodeIdentifier(dword fsid, dword inode)
InodeIdentifier(u32 fsid, u32 inode)
: m_fsid(fsid)
, m_index(inode)
{
@ -18,8 +18,8 @@ public:
bool is_valid() const { return m_fsid != 0 && m_index != 0; }
dword fsid() const { return m_fsid; }
dword index() const { return m_index; }
u32 fsid() const { return m_fsid; }
u32 index() const { return m_index; }
FS* fs();
const FS* fs() const;
@ -39,6 +39,6 @@ public:
String to_string() const { return String::format("%u:%u", m_fsid, m_index); }
private:
dword m_fsid { 0 };
dword m_index { 0 };
u32 m_fsid { 0 };
u32 m_index { 0 };
};

2
Kernel/FileSystem/InodeMetadata.h
View file

@ -7,7 +7,7 @@
class Process;
inline constexpr dword encoded_device(unsigned major, unsigned minor)
inline constexpr u32 encoded_device(unsigned major, unsigned minor)
{
return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
}

44
Kernel/FileSystem/ProcFS.cpp
View file

@ -125,7 +125,7 @@ static inline InodeIdentifier to_parent_id(const InodeIdentifier& identifier)
}
#if 0
static inline byte to_unused_metadata(const InodeIdentifier& identifier)
static inline u8 to_unused_metadata(const InodeIdentifier& identifier)
{
return (identifier.index() >> 8) & 0xf;
}
@ -254,7 +254,7 @@ ByteBuffer procfs$pci(InodeIdentifier)
ByteBuffer procfs$uptime(InodeIdentifier)
{
StringBuilder builder;
builder.appendf("%u\n", (dword)(g_uptime / 1000));
builder.appendf("%u\n", (u32)(g_uptime / 1000));
return builder.to_byte_buffer();
}
@ -317,7 +317,7 @@ ByteBuffer procfs$pid_stack(InodeIdentifier identifier)
auto& process = handle->process();
ProcessPagingScope paging_scope(process);
struct RecognizedSymbol {
dword address;
u32 address;
const KSym* ksym;
};
StringBuilder builder;
@ -325,8 +325,8 @@ ByteBuffer procfs$pid_stack(InodeIdentifier identifier)
builder.appendf("Thread %d:\n", thread.tid());
Vector<RecognizedSymbol, 64> recognized_symbols;
recognized_symbols.append({ thread.tss().eip, ksymbolicate(thread.tss().eip) });
for (dword* stack_ptr = (dword*)thread.frame_ptr(); process.validate_read_from_kernel(VirtualAddress((dword)stack_ptr)); stack_ptr = (dword*)*stack_ptr) {
dword retaddr = stack_ptr[1];
for (u32* stack_ptr = (u32*)thread.frame_ptr(); process.validate_read_from_kernel(VirtualAddress((u32)stack_ptr)); stack_ptr = (u32*)*stack_ptr) {
u32 retaddr = stack_ptr[1];
recognized_symbols.append({ retaddr, ksymbolicate(retaddr) });
}
@ -397,7 +397,7 @@ ByteBuffer procfs$self(InodeIdentifier)
{
char buffer[16];
ksprintf(buffer, "%u", current->pid());
return ByteBuffer::copy((const byte*)buffer, strlen(buffer));
return ByteBuffer::copy((const u8*)buffer, strlen(buffer));
}
ByteBuffer procfs$mm(InodeIdentifier)
@ -471,28 +471,28 @@ ByteBuffer procfs$cpuinfo(InodeIdentifier)
{
CPUID cpuid(0);
builder.appendf("cpuid: ");
auto emit_dword = [&](dword value) {
auto emit_u32 = [&](u32 value) {
builder.appendf("%c%c%c%c",
value & 0xff,
(value >> 8) & 0xff,
(value >> 16) & 0xff,
(value >> 24) & 0xff);
};
emit_dword(cpuid.ebx());
emit_dword(cpuid.edx());
emit_dword(cpuid.ecx());
emit_u32(cpuid.ebx());
emit_u32(cpuid.edx());
emit_u32(cpuid.ecx());
builder.appendf("\n");
}
{
CPUID cpuid(1);
dword stepping = cpuid.eax() & 0xf;
dword model = (cpuid.eax() >> 4) & 0xf;
dword family = (cpuid.eax() >> 8) & 0xf;
dword type = (cpuid.eax() >> 12) & 0x3;
dword extended_model = (cpuid.eax() >> 16) & 0xf;
dword extended_family = (cpuid.eax() >> 20) & 0xff;
dword display_model;
dword display_family;
u32 stepping = cpuid.eax() & 0xf;
u32 model = (cpuid.eax() >> 4) & 0xf;
u32 family = (cpuid.eax() >> 8) & 0xf;
u32 type = (cpuid.eax() >> 12) & 0x3;
u32 extended_model = (cpuid.eax() >> 16) & 0xf;
u32 extended_family = (cpuid.eax() >> 20) & 0xff;
u32 display_model;
u32 display_family;
if (family == 15) {
display_family = family + extended_family;
display_model = model + (extended_model << 4);
@ -512,8 +512,8 @@ ByteBuffer procfs$cpuinfo(InodeIdentifier)
// FIXME: Check first that this is supported by calling CPUID with eax=0x80000000
// and verifying that the returned eax>=0x80000004.
char buffer[48];
dword* bufptr = reinterpret_cast<dword*>(buffer);
auto copy_brand_string_part_to_buffer = [&](dword i) {
u32* bufptr = reinterpret_cast<u32*>(buffer);
auto copy_brand_string_part_to_buffer = [&](u32 i) {
CPUID cpuid(0x80000002 + i);
*bufptr++ = cpuid.eax();
*bufptr++ = cpuid.ebx();
@ -858,7 +858,7 @@ InodeMetadata ProcFSInode::metadata() const
return metadata;
}
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription* description) const
{
#ifdef PROCFS_DEBUG
dbgprintf("ProcFS: read_bytes %u\n", index());
@ -1061,7 +1061,7 @@ void ProcFSInode::flush_metadata()
{
}
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescription*)
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const u8* buffer, FileDescription*)
{
auto* directory_entry = fs().get_directory_entry(identifier());
if (!directory_entry || !directory_entry->write_callback)

4
Kernel/FileSystem/ProcFS.h
View file

@ -80,12 +80,12 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(StringView name) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescription*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const u8* buffer, FileDescription*) override;
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;
virtual size_t directory_entry_count() const override;

6
Kernel/FileSystem/SyntheticFileSystem.cpp
View file

@ -185,7 +185,7 @@ InodeMetadata SynthFSInode::metadata() const
return m_metadata;
}
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescription* description) const
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, u8* buffer, FileDescription* description) const
{
LOCKER(m_lock);
#ifdef SYNTHFS_DEBUG
@ -227,7 +227,7 @@ bool SynthFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&
callback({ "..", 2, m_parent, 2 });
for (auto& child : m_children)
callback({ child->m_name.characters(), child->m_name.length(), child->m_metadata.inode, child->m_metadata.is_directory() ? (byte)2 : (byte)1 });
callback({ child->m_name.characters(), child->m_name.length(), child->m_metadata.inode, child->m_metadata.is_directory() ? (u8)2 : (u8)1 });
return true;
}
@ -250,7 +250,7 @@ void SynthFSInode::flush_metadata()
{
}
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescription*)
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const u8* buffer, FileDescription*)
{
LOCKER(m_lock);
if (!m_write_callback)

4
Kernel/FileSystem/SyntheticFileSystem.h
View file

@ -57,12 +57,12 @@ public:
private:
// ^Inode
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescription*) const override;
virtual ssize_t read_bytes(off_t, ssize_t, u8* buffer, FileDescription*) const override;
virtual InodeMetadata metadata() const override;
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
virtual InodeIdentifier lookup(StringView name) override;
virtual void flush_metadata() override;
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescription*) override;
virtual ssize_t write_bytes(off_t, ssize_t, const u8* buffer, FileDescription*) override;
virtual KResult add_child(InodeIdentifier child_id, const StringView& name, mode_t) override;
virtual KResult remove_child(const StringView& name) override;
virtual size_t directory_entry_count() const override;

2
Kernel/FileSystem/VirtualFileSystem.cpp
View file

@ -516,7 +516,7 @@ KResult VFS::symlink(StringView target, StringView linkpath, Custody& base)
auto new_file = parent_inode.fs().create_inode(parent_inode.identifier(), p.basename(), 0120644, 0, 0, error);
if (!new_file)
return KResult(error);
ssize_t nwritten = new_file->write_bytes(0, target.length(), (const byte*)target.characters(), nullptr);
ssize_t nwritten = new_file->write_bytes(0, target.length(), (const u8*)target.characters(), nullptr);
if (nwritten < 0)
return KResult(nwritten);
return KSuccess;

2
Kernel/FileSystem/VirtualFileSystem.h
View file

@ -107,7 +107,7 @@ private:
RefPtr<Inode> m_root_inode;
Vector<OwnPtr<Mount>> m_mounts;
HashMap<dword, Device*> m_devices;
HashMap<u32, Device*> m_devices;
RefPtr<Custody> m_root_custody;
};