LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-20 01:37:39 +03:00
Code Issues Packages Projects Releases Wiki Activity

Do a pass of compiler warning fixes.

Browse Source 
This is really making me question not using 64-bit integers more.
This commit is contained in:
Andreas Kling 2019-04-23 13:00:53 +02:00
parent 243e1d8462
commit 58240fdb33
Notes: sideshowbarker 2024-07-19 14:37:12 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/58240fdb337
21 changed files with 89 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
AK/ByteBuffer.h
View File

@ -14,6 +14,7 @@ public:
static Retained<ByteBufferImpl> create_zeroed(int);
static Retained<ByteBufferImpl> copy(const void*, int);
static Retained<ByteBufferImpl> wrap(void*, int);
static Retained<ByteBufferImpl> wrap(const void*, int);
static Retained<ByteBufferImpl> adopt(void*, int);
~ByteBufferImpl() { clear(); }
@ -89,6 +90,7 @@ public:
static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_uninitialized(size)); }
static ByteBuffer create_zeroed(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_zeroed(size)); }
static ByteBuffer copy(const void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::copy(data, size)); }
static ByteBuffer wrap(const void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::wrap(data, size)); }
static ByteBuffer wrap(void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::wrap(data, size)); }
static ByteBuffer adopt(void* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::adopt(data, size)); }
@ -219,6 +221,11 @@ inline Retained<ByteBufferImpl> ByteBufferImpl::wrap(void* data, int size)
return ::adopt(*new ByteBufferImpl(data, size, Wrap));
}
inline Retained<ByteBufferImpl> ByteBufferImpl::wrap(const void* data, int size)
{
return ::adopt(*new ByteBufferImpl(const_cast<void*>(data), size, Wrap));
}
inline Retained<ByteBufferImpl> ByteBufferImpl::adopt(void* data, int size)
{
return ::adopt(*new ByteBufferImpl(data, size, Adopt));

2
Applications/IRCClient/IRCClient.cpp
View File

@ -158,7 +158,7 @@ void IRCClient::process_line(ByteBuffer&& line)
void IRCClient::send(const String& text)
{
if (!m_socket->send(ByteBuffer::wrap((void*)text.characters(), text.length()))) {
if (!m_socket->send(ByteBuffer::wrap(text.characters(), text.length()))) {
perror("send");
exit(1);
}

62
Kernel/FileSystem/Ext2FileSystem.cpp
View File

@ -459,7 +459,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, ((byte*)m_raw_inode.i_block) + offset, (size_t)nread);
memcpy(buffer, ((const byte*)m_raw_inode.i_block) + offset, (size_t)nread);
return nread;
}
@ -476,17 +476,17 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
return -EIO;
}
const size_t block_size = fs().block_size();
const int block_size = fs().block_size();
dword first_block_logical_index = offset / block_size;
dword last_block_logical_index = (offset + count) / block_size;
int first_block_logical_index = offset / block_size;
int last_block_logical_index = (offset + count) / block_size;
if (last_block_logical_index >= m_block_list.size())
last_block_logical_index = m_block_list.size() - 1;
dword offset_into_first_block = offset % block_size;
int offset_into_first_block = offset % block_size;
ssize_t nread = 0;
size_t remaining_count = min((off_t)count, (off_t)size() - offset);
int remaining_count = min((off_t)count, (off_t)size() - offset);
byte* out = buffer;
#ifdef EXT2_DEBUG
@ -494,15 +494,15 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
//kprintf("ok let's do it, read(%u, %u) -> blocks %u thru %u, oifb: %u\n", offset, count, first_block_logical_index, last_block_logical_index, offset_into_first_block);
#endif
for (dword bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
for (int bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
auto block = fs().read_block(m_block_list[bi]);
if (!block) {
kprintf("ext2fs: read_bytes: read_block(%u) failed (lbi: %u)\n", m_block_list[bi], bi);
return -EIO;
}
dword offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
dword num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
int offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
int num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
memcpy(out, block.pointer() + offset_into_block, num_bytes_to_copy);
remaining_count -= num_bytes_to_copy;
nread += num_bytes_to_copy;
@ -526,7 +526,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
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);
if ((offset + count) > m_raw_inode.i_size)
if ((offset + count) > (off_t)m_raw_inode.i_size)
m_raw_inode.i_size = offset + count;
set_metadata_dirty(true);
return count;
@ -551,17 +551,17 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
ASSERT_NOT_REACHED();
}
dword first_block_logical_index = offset / block_size;
dword last_block_logical_index = (offset + count) / block_size;
int first_block_logical_index = offset / block_size;
int last_block_logical_index = (offset + count) / block_size;
if (last_block_logical_index >= block_list.size())
last_block_logical_index = block_list.size() - 1;
dword offset_into_first_block = offset % block_size;
int offset_into_first_block = offset % block_size;
dword last_logical_block_index_in_file = size() / block_size;
int last_logical_block_index_in_file = size() / block_size;
ssize_t nwritten = 0;
size_t remaining_count = min((off_t)count, (off_t)new_size - offset);
int remaining_count = min((off_t)count, (off_t)new_size - offset);
const byte* in = data;
#ifdef EXT2_DEBUG
@ -569,9 +569,9 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
#endif
auto buffer_block = ByteBuffer::create_uninitialized(block_size);
for (dword bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
size_t offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
size_t num_bytes_to_copy = min((size_t)block_size - offset_into_block, remaining_count);
for (int bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
int offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
int num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
ByteBuffer block;
if (offset_into_block != 0 || num_bytes_to_copy != block_size) {
@ -585,8 +585,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
memcpy(block.pointer() + offset_into_block, in, num_bytes_to_copy);
if (bi == last_logical_block_index_in_file && num_bytes_to_copy < block_size) {
size_t padding_start = new_size % block_size;
size_t padding_bytes = block_size - padding_start;
int padding_start = new_size % block_size;
int padding_bytes = block_size - padding_start;
#ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode::write_bytes padding last block of file with zero x %u (new_size=%u, offset_into_block=%u, num_bytes_to_copy=%u)\n", padding_bytes, new_size, offset_into_block, num_bytes_to_copy);
#endif
@ -847,17 +847,17 @@ void Ext2FS::traverse_inode_bitmap(unsigned group_index, F callback) const
}
template<typename F>
void Ext2FS::traverse_block_bitmap(unsigned group_index, F callback) const
void Ext2FS::traverse_block_bitmap(GroupIndex group_index, F callback) const
{
ASSERT(group_index <= m_block_group_count);
auto& bgd = group_descriptor(group_index);
unsigned blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count);
unsigned block_count = ceil_div(blocks_in_group, 8u);
unsigned first_block_in_group = (group_index - 1) * blocks_per_group();
unsigned bits_per_block = block_size() * 8;
int blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count);
int block_count = ceil_div(blocks_in_group, 8u);
BlockIndex first_block_in_group = (group_index - 1) * blocks_per_group();
int bits_per_block = block_size() * 8;
for (unsigned i = 0; i < block_count; ++i) {
for (int i = 0; i < block_count; ++i) {
auto block = read_block(bgd.bg_block_bitmap + i);
ASSERT(block);
bool should_continue = callback(first_block_in_group + (i * bits_per_block) + 1, Bitmap::wrap(block.pointer(), blocks_in_group));
@ -880,7 +880,7 @@ bool Ext2FS::write_ext2_inode(unsigned inode, const ext2_inode& e2inode)
return success;
}
Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(unsigned group, unsigned count)
Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(GroupIndex group, int count)
{
LOCKER(m_lock);
dbgprintf("Ext2FS: allocate_blocks(group: %u, count: %u)\n", group, count);
@ -913,7 +913,7 @@ Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(unsigned group, unsigned coun
return blocks;
}
unsigned Ext2FS::allocate_inode(unsigned preferred_group, unsigned expected_size)
unsigned Ext2FS::allocate_inode(GroupIndex preferred_group, off_t expected_size)
{
LOCKER(m_lock);
dbgprintf("Ext2FS: allocate_inode(preferredGroup: %u, expectedSize: %u)\n", preferred_group, expected_size);
@ -1134,7 +1134,7 @@ RetainPtr<Inode> Ext2FS::create_directory(InodeIdentifier parent_id, const Strin
return inode;
}
RetainPtr<Inode> Ext2FS::create_inode(InodeIdentifier parent_id, const String& name, mode_t mode, unsigned size, int& error)
RetainPtr<Inode> Ext2FS::create_inode(InodeIdentifier parent_id, const String& name, mode_t mode, off_t size, int& error)
{
LOCKER(m_lock);
ASSERT(parent_id.fsid() == fsid());
@ -1388,10 +1388,10 @@ KResult Ext2FSInode::chown(uid_t uid, gid_t gid)
return KSuccess;
}
KResult Ext2FSInode::truncate(int size)
KResult Ext2FSInode::truncate(off_t size)
{
LOCKER(m_lock);
if (m_raw_inode.i_size == size)
if ((off_t)m_raw_inode.i_size == size)
return KSuccess;
m_raw_inode.i_size = size;
set_metadata_dirty(true);

28
Kernel/FileSystem/Ext2FileSystem.h
View File

@ -42,7 +42,7 @@ private:
virtual size_t directory_entry_count() const override;
virtual KResult chmod(mode_t) override;
virtual KResult chown(uid_t, gid_t) override;
virtual KResult truncate(int) override;
virtual KResult truncate(off_t) override;
void populate_lookup_cache() const;
@ -83,36 +83,36 @@ private:
unsigned blocks_per_group() const;
unsigned inode_size() const;
bool write_ext2_inode(unsigned, const ext2_inode&);
ByteBuffer read_block_containing_inode(unsigned inode, unsigned& block_index, unsigned& offset) const;
bool write_ext2_inode(InodeIndex, const ext2_inode&);
ByteBuffer read_block_containing_inode(InodeIndex inode, BlockIndex& block_index, unsigned& offset) const;
ByteBuffer read_super_block() const;
bool write_super_block(const ext2_super_block&);
virtual const char* class_name() const override;
virtual InodeIdentifier root_inode() const override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, unsigned size, int& error) override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, off_t size, int& error) override;
virtual RetainPtr<Inode> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override;
unsigned allocate_inode(unsigned preferredGroup, unsigned expectedSize);
Vector<BlockIndex> allocate_blocks(unsigned group, unsigned count);
unsigned group_index_from_inode(unsigned) const;
InodeIndex allocate_inode(GroupIndex preferred_group, off_t expected_size);
Vector<BlockIndex> allocate_blocks(GroupIndex, int count);
GroupIndex group_index_from_inode(InodeIndex) const;
GroupIndex group_index_from_block_index(BlockIndex) const;
Vector<unsigned> block_list_for_inode(const ext2_inode&, bool include_block_list_blocks = false) const;
Vector<BlockIndex> block_list_for_inode(const ext2_inode&, bool include_block_list_blocks = false) const;
bool write_block_list_for_inode(InodeIndex, ext2_inode&, const Vector<BlockIndex>&);
void dump_block_bitmap(unsigned groupIndex) const;
void dump_inode_bitmap(unsigned groupIndex) const;
void dump_block_bitmap(GroupIndex) const;
void dump_inode_bitmap(GroupIndex) const;
template<typename F> void traverse_inode_bitmap(unsigned groupIndex, F) const;
template<typename F> void traverse_block_bitmap(unsigned groupIndex, F) const;
template<typename F> void traverse_inode_bitmap(GroupIndex, F) const;
template<typename F> void traverse_block_bitmap(GroupIndex, F) const;
bool add_inode_to_directory(InodeIndex parent, InodeIndex child, const String& name, byte file_type, int& error);
bool write_directory_inode(unsigned directoryInode, Vector<DirectoryEntry>&&);
bool write_directory_inode(InodeIndex, Vector<DirectoryEntry>&&);
bool get_inode_allocation_state(InodeIndex) const;
bool set_inode_allocation_state(unsigned inode, bool);
bool set_inode_allocation_state(InodeIndex, bool);
bool set_block_allocation_state(BlockIndex, bool);
void uncache_inode(InodeIndex);

2
Kernel/FileSystem/FileSystem.cpp
View File

@ -77,7 +77,7 @@ FS::DirectoryEntry::DirectoryEntry(const char* n, InodeIdentifier i, byte ft)
name[name_length] = '\0';
}
FS::DirectoryEntry::DirectoryEntry(const char* n, size_t nl, InodeIdentifier i, byte ft)
FS::DirectoryEntry::DirectoryEntry(const char* n, int nl, InodeIdentifier i, byte ft)
: name_length(nl)
, inode(i)
, file_type(ft)

6
Kernel/FileSystem/FileSystem.h
View File

@ -45,14 +45,14 @@ public:
struct DirectoryEntry {
DirectoryEntry(const char* name, InodeIdentifier, byte file_type);
DirectoryEntry(const char* name, size_t name_length, InodeIdentifier, byte file_type);
DirectoryEntry(const char* name, int name_length, InodeIdentifier, byte file_type);
char name[256];
int name_length { 0 };
InodeIdentifier inode;
byte file_type { 0 };
};
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, unsigned size, int& error) = 0;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, off_t size, int& error) = 0;
virtual RetainPtr<Inode> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) = 0;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const = 0;
@ -102,7 +102,7 @@ public:
virtual size_t directory_entry_count() const = 0;
virtual KResult chmod(mode_t) = 0;
virtual KResult chown(uid_t, gid_t) = 0;
virtual KResult truncate(int) { return KSuccess; }
virtual KResult truncate(off_t) { return KSuccess; }
LocalSocket* socket() { return m_socket.ptr(); }
const LocalSocket* socket() const { return m_socket.ptr(); }

29
Kernel/FileSystem/ProcFS.cpp
View File

@ -77,7 +77,7 @@ static inline int to_fd(const InodeIdentifier& identifier)
return (identifier.index() & 0xff) - FI_MaxStaticFileIndex;
}
static inline unsigned to_sys_index(const InodeIdentifier& identifier)
static inline int to_sys_index(const InodeIdentifier& identifier)
{
ASSERT(to_proc_parent_directory(identifier) == PDI_Root_sys);
return identifier.index() & 0xff;
@ -186,7 +186,7 @@ ByteBuffer procfs$pid_fds(InodeIdentifier identifier)
if (process.number_of_open_file_descriptors() == 0)
return { };
StringBuilder builder;
for (size_t i = 0; i < process.max_open_file_descriptors(); ++i) {
for (int i = 0; i < process.max_open_file_descriptors(); ++i) {
auto* descriptor = process.file_descriptor(i);
if (!descriptor)
continue;
@ -714,28 +714,28 @@ void ProcFS::add_sys_bool(String&& name, Lockable<bool>& var, Function<void()>&&
{
InterruptDisabler disabler;
unsigned index = m_sys_entries.size();
int index = m_sys_entries.size();
auto inode = adopt(*new ProcFSInode(*this, sys_var_to_identifier(fsid(), index).index()));
auto data = make<SysVariableData>();
data->type = SysVariableData::Boolean;
data->notify_callback = move(notify_callback);
data->address = &var;
inode->set_custom_data(move(data));
m_sys_entries.append({ strdup(name.characters()), name.length(), read_sys_bool, write_sys_bool, move(inode) });
m_sys_entries.append({ strdup(name.characters()), 0, read_sys_bool, write_sys_bool, move(inode) });
}
void ProcFS::add_sys_string(String&& name, Lockable<String>& var, Function<void()>&& notify_callback)
{
InterruptDisabler disabler;
unsigned index = m_sys_entries.size();
int index = m_sys_entries.size();
auto inode = adopt(*new ProcFSInode(*this, sys_var_to_identifier(fsid(), index).index()));
auto data = make<SysVariableData>();
data->type = SysVariableData::String;
data->notify_callback = move(notify_callback);
data->address = &var;
inode->set_custom_data(move(data));
m_sys_entries.append({ strdup(name.characters()), name.length(), read_sys_string, write_sys_string, move(inode) });
m_sys_entries.append({ strdup(name.characters()), 0, read_sys_string, write_sys_string, move(inode) });
}
bool ProcFS::initialize()
@ -748,13 +748,8 @@ const char* ProcFS::class_name() const
return "ProcFS";
}
RetainPtr<Inode> ProcFS::create_inode(InodeIdentifier parentInode, const String& name, mode_t mode, unsigned size, int& error)
RetainPtr<Inode> ProcFS::create_inode(InodeIdentifier, const String&, mode_t, off_t, int&)
{
(void) parentInode;
(void) name;
(void) mode;
(void) size;
(void) error;
kprintf("FIXME: Implement ProcFS::create_inode()?\n");
return { };
}
@ -934,7 +929,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (!entry.name)
continue;
if (entry.proc_file_type > __FI_Root_Start && entry.proc_file_type < __FI_Root_End)
callback({ entry.name, strlen(entry.name), to_identifier(fsid(), PDI_Root, 0, (ProcFileType)entry.proc_file_type), 0 });
callback({ entry.name, (int)strlen(entry.name), to_identifier(fsid(), PDI_Root, 0, (ProcFileType)entry.proc_file_type), 0 });
}
for (auto pid_child : Process::all_pids()) {
char name[16];
@ -946,7 +941,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
case FI_Root_sys:
for (int i = 0; i < fs().m_sys_entries.size(); ++i) {
auto& entry = fs().m_sys_entries[i];
callback({ entry.name, strlen(entry.name), sys_var_to_identifier(fsid(), i), 0 });
callback({ entry.name, (int)strlen(entry.name), sys_var_to_identifier(fsid(), i), 0 });
}
break;
@ -960,7 +955,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (entry.proc_file_type == FI_PID_exe && !process.executable_inode())
continue;
// FIXME: strlen() here is sad.
callback({ entry.name, strlen(entry.name), to_identifier(fsid(), PDI_PID, pid, (ProcFileType)entry.proc_file_type), 0 });
callback({ entry.name, (int)strlen(entry.name), to_identifier(fsid(), PDI_PID, pid, (ProcFileType)entry.proc_file_type), 0 });
}
}
}
@ -976,7 +971,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (!descriptor)
continue;
char name[16];
size_t name_length = ksprintf(name, "%u", i);
int name_length = ksprintf(name, "%u", i);
callback({ name, name_length, to_identifier_with_fd(fsid(), pid, i), 0 });
}
}
@ -1100,7 +1095,7 @@ ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer,
ASSERT(is_persistent_inode(identifier()));
// FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support..
ASSERT(offset == 0);
bool success = directory_entry->write_callback(identifier(), ByteBuffer::wrap((byte*)buffer, size));
bool success = directory_entry->write_callback(identifier(), ByteBuffer::wrap(buffer, size));
ASSERT(success);
return 0;
}

2
Kernel/FileSystem/ProcFS.h
View File

@ -22,7 +22,7 @@ public:
virtual InodeIdentifier root_inode() const override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parent_id, const String& name, mode_t, unsigned size, int& error) override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parent_id, const String& name, mode_t, off_t size, int& error) override;
virtual RetainPtr<Inode> create_directory(InodeIdentifier parent_id, const String& name, mode_t, int& error) override;
void add_sys_file(String&&, Function<ByteBuffer(ProcFSInode&)>&& read_callback, Function<ssize_t(ProcFSInode&, const ByteBuffer&)>&& write_callback);

4
Kernel/FileSystem/SyntheticFileSystem.cpp
View File

@ -138,7 +138,7 @@ InodeIdentifier SynthFS::root_inode() const
return { fsid(), 1 };
}
RetainPtr<Inode> SynthFS::create_inode(InodeIdentifier parentInode, const String& name, mode_t mode, unsigned size, int& error)
RetainPtr<Inode> SynthFS::create_inode(InodeIdentifier parentInode, const String& name, mode_t mode, off_t size, int& error)
{
(void) parentInode;
(void) name;
@ -274,7 +274,7 @@ ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer
return -EPERM;
// FIXME: Being able to write into SynthFS at a non-zero offset seems like something we should support..
ASSERT(offset == 0);
bool success = m_write_callback(*this, ByteBuffer::wrap((byte*)buffer, size));
bool success = m_write_callback(*this, ByteBuffer::wrap(buffer, size));
ASSERT(success);
return 0;
}

2
Kernel/FileSystem/SyntheticFileSystem.h
View File

@ -14,7 +14,7 @@ public:
virtual bool initialize() override;
virtual const char* class_name() const override;
virtual InodeIdentifier root_inode() const override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, unsigned size, int& error) override;
virtual RetainPtr<Inode> create_inode(InodeIdentifier parentInode, const String& name, mode_t, off_t size, int& error) override;
virtual RetainPtr<Inode> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override;

1
Kernel/SharedMemory.cpp
View File

@ -14,6 +14,7 @@ Lockable<HashMap<String, RetainPtr<SharedMemory>>>& shared_memories()
KResultOr<Retained<SharedMemory>> SharedMemory::open(const String& name, int flags, mode_t mode)
{
UNUSED_PARAM(flags);
LOCKER(shared_memories().lock());
auto it = shared_memories().resource().find(name);
if (it != shared_memories().resource().end()) {

2
Kernel/SharedMemory.h
View File

@ -15,7 +15,7 @@ public:
~SharedMemory();
String name() const { return m_name; }
KResult truncate(int);
KResult truncate(off_t);
VMObject* vmo() { return m_vmo.ptr(); }
const VMObject* vmo() const { return m_vmo.ptr(); }
uid_t uid() const { return m_uid; }

2
Kernel/TTY/VirtualConsole.cpp
View File

@ -131,7 +131,7 @@ inline bool is_valid_final_character(byte ch)
unsigned parse_uint(const String& str, bool& ok)
{
unsigned value = 0;
for (size_t i = 0; i < str.length(); ++i) {
for (int i = 0; i < str.length(); ++i) {
if (str[i] < '0' || str[i] > '9') {
ok = false;
return 0;

2
Kernel/sync.sh
View File

@ -4,7 +4,7 @@ if [ $(id -u) != 0 ]; then
fi
rm -vf _fs_contents.lock
rm -vf _fs_contents
dd if=/dev/zero of=_fs_contents bs=1M count=256
dd if=/dev/zero of=_fs_contents bs=1M count=512
mke2fs _fs_contents
chown 1000:1000 _fs_contents
mkdir -vp mnt

2
LibC/stdio.cpp
View File

@ -9,6 +9,7 @@
#include <unistd.h>
#include <fcntl.h>
#include <AK/printf.cpp>
#include <AK/StdLibExtras.h>
#include <Kernel/Syscall.h>
extern "C" {
@ -405,6 +406,7 @@ FILE* freopen(const char* pathname, const char* mode, FILE* stream)
FILE* fdopen(int fd, const char* mode)
{
UNUSED_PARAM(mode);
// FIXME: Verify that the mode matches how fd is already open.
if (fd < 0)
return nullptr;

4
LibC/stdlib.cpp
View File

@ -133,7 +133,7 @@ void free(void* ptr)
return;
}
for (unsigned i = header->first_chunk_index; i < (header->first_chunk_index + header->chunk_count); ++i)
for (int i = header->first_chunk_index; i < (header->first_chunk_index + header->chunk_count); ++i)
s_malloc_map[i / 8] &= ~(1 << (i % 8));
s_malloc_sum_alloc -= header->chunk_count * CHUNK_SIZE;
@ -473,7 +473,7 @@ long strtol(const char* str, char** endptr, int base)
} else if (neg)
acc = -acc;
if (endptr)
*endptr = (char*)(any ? s - 1 : str);
*endptr = const_cast<char*>((any ? s - 1 : str));
return acc;
}

6
LibC/string.cpp
View File

@ -202,10 +202,10 @@ char* strchr(const char* str, int c)
void* memchr(const void* ptr, int c, size_t size)
{
char ch = c;
char* cptr = (char*)ptr;
auto* cptr = (const char*)ptr;
for (size_t i = 0; i < size; ++i) {
if (cptr[i] == ch)
return cptr + i;
return const_cast<char*>(cptr + i);
}
return nullptr;
}
@ -358,7 +358,7 @@ char* strpbrk(const char* s, const char* accept)
{
while (*s)
if(strchr(accept, *s++))
return (char*)--s;
return const_cast<char*>(--s);
return nullptr;
}

2
LibC/unistd.cpp
View File

@ -83,7 +83,7 @@ int execl(const char* filename, const char* arg0, ...)
}
va_end(ap);
args.append(nullptr);
return execve(filename, (char* const *)args.data(), environ);
return execve(filename, const_cast<char* const*>(args.data()), environ);
}
uid_t getuid()

4
LibGUI/GWindow.cpp
View File

@ -245,7 +245,7 @@ void GWindow::event(CEvent& event)
message.rects[i] = rects[i];
ByteBuffer extra_data;
if (rects.size() > WSAPI_ClientMessage::max_inline_rect_count)
extra_data = ByteBuffer::wrap((void*)&rects[WSAPI_ClientMessage::max_inline_rect_count], (rects.size() - WSAPI_ClientMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
extra_data = ByteBuffer::wrap(&rects[WSAPI_ClientMessage::max_inline_rect_count], (rects.size() - WSAPI_ClientMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
GEventLoop::current().post_message_to_server(message, extra_data);
}
return;
@ -324,7 +324,7 @@ void GWindow::update(const Rect& a_rect)
request.rects[i] = m_pending_paint_event_rects[i];
ByteBuffer extra_data;
if (m_pending_paint_event_rects.size() > WSAPI_ClientMessage::max_inline_rect_count)
extra_data = ByteBuffer::wrap((void*)&m_pending_paint_event_rects[WSAPI_ClientMessage::max_inline_rect_count], (m_pending_paint_event_rects.size() - WSAPI_ClientMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
extra_data = ByteBuffer::wrap(&m_pending_paint_event_rects[WSAPI_ClientMessage::max_inline_rect_count], (m_pending_paint_event_rects.size() - WSAPI_ClientMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
request.rect_count = m_pending_paint_event_rects.size();
GEventLoop::current().post_message_to_server(request, extra_data);
m_pending_paint_event_rects.clear_with_capacity();

2
Servers/WindowServer/WSClientConnection.cpp
View File

@ -516,7 +516,7 @@ void WSClientConnection::post_paint_message(WSWindow& window)
message.paint.window_size = window.size();
ByteBuffer extra_data;
if (rects.size() > WSAPI_ServerMessage::max_inline_rect_count)
extra_data = ByteBuffer::wrap((void*)&rects[WSAPI_ServerMessage::max_inline_rect_count], (rects.size() - WSAPI_ServerMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
extra_data = ByteBuffer::wrap(&rects[WSAPI_ServerMessage::max_inline_rect_count], (rects.size() - WSAPI_ServerMessage::max_inline_rect_count) * sizeof(WSAPI_Rect));
post_message(message, extra_data);
}

2
SharedGraphics/PNGLoader.cpp
View File

@ -82,7 +82,7 @@ public:
{
if (m_size_remaining < count)
return false;
buffer = ByteBuffer::wrap((void*)m_data_ptr, count);
buffer = ByteBuffer::wrap(m_data_ptr, count);
m_data_ptr += count;
m_size_remaining -= count;
return true;