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

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
21 changed files with 89 additions and 84 deletions
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> create_zeroed(int);
static Retained<ByteBufferImpl> copy(const void*, int); static Retained<ByteBufferImpl> copy(const void*, int);
static Retained<ByteBufferImpl> wrap(void*, int); static Retained<ByteBufferImpl> wrap(void*, int);
static Retained<ByteBufferImpl> wrap(const void*, int);
static Retained<ByteBufferImpl> adopt(void*, int); static Retained<ByteBufferImpl> adopt(void*, int);
~ByteBufferImpl() { clear(); } ~ByteBufferImpl() { clear(); }
@ -89,6 +90,7 @@ public:
static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_uninitialized(size)); } 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 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 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 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)); } 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)); 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) inline Retained<ByteBufferImpl> ByteBufferImpl::adopt(void* data, int size)
{ {
return ::adopt(*new ByteBufferImpl(data, size, Adopt)); 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) 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"); perror("send");
exit(1); 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.) // This avoids wasting an entire block on short links. (Most links are short.)
if (is_symlink() && size() < max_inline_symlink_length) { if (is_symlink() && size() < max_inline_symlink_length) {
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count)); 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; return nread;
} }
@ -476,17 +476,17 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileD
return -EIO; 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; int first_block_logical_index = offset / block_size;
dword last_block_logical_index = (offset + count) / block_size; int last_block_logical_index = (offset + count) / block_size;
if (last_block_logical_index >= m_block_list.size()) if (last_block_logical_index >= m_block_list.size())
last_block_logical_index = m_block_list.size() - 1; 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; 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; byte* out = buffer;
#ifdef EXT2_DEBUG #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); //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 #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]); auto block = fs().read_block(m_block_list[bi]);
if (!block) { if (!block) {
kprintf("ext2fs: read_bytes: read_block(%u) failed (lbi: %u)\n", m_block_list[bi], bi); kprintf("ext2fs: read_bytes: read_block(%u) failed (lbi: %u)\n", m_block_list[bi], bi);
return -EIO; return -EIO;
} }
dword offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0; int 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 num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
memcpy(out, block.pointer() + offset_into_block, num_bytes_to_copy); memcpy(out, block.pointer() + offset_into_block, num_bytes_to_copy);
remaining_count -= num_bytes_to_copy; remaining_count -= num_bytes_to_copy;
nread += 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); dbgprintf("Ext2FSInode: write_bytes poking into i_block array for inline symlink '%s' (%u bytes)\n", String((const char*)data, count).characters(), count);
#endif #endif
memcpy(((byte*)m_raw_inode.i_block) + offset, data, (size_t)count); 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; m_raw_inode.i_size = offset + count;
set_metadata_dirty(true); set_metadata_dirty(true);
return count; return count;
@ -551,17 +551,17 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
dword first_block_logical_index = offset / block_size; int first_block_logical_index = offset / block_size;
dword last_block_logical_index = (offset + count) / block_size; int last_block_logical_index = (offset + count) / block_size;
if (last_block_logical_index >= block_list.size()) if (last_block_logical_index >= block_list.size())
last_block_logical_index = block_list.size() - 1; 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; 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; const byte* in = data;
#ifdef EXT2_DEBUG #ifdef EXT2_DEBUG
@ -569,9 +569,9 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
#endif #endif
auto buffer_block = ByteBuffer::create_uninitialized(block_size); auto buffer_block = ByteBuffer::create_uninitialized(block_size);
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) {
size_t offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0; int 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); int num_bytes_to_copy = min(block_size - offset_into_block, remaining_count);
ByteBuffer block; ByteBuffer block;
if (offset_into_block != 0 || num_bytes_to_copy != block_size) { 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); 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) { if (bi == last_logical_block_index_in_file && num_bytes_to_copy < block_size) {
size_t padding_start = new_size % block_size; int padding_start = new_size % block_size;
size_t padding_bytes = block_size - padding_start; int padding_bytes = block_size - padding_start;
#ifdef EXT2_DEBUG #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); 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 #endif
@ -847,17 +847,17 @@ void Ext2FS::traverse_inode_bitmap(unsigned group_index, F callback) const
} }
template<typename F> 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); ASSERT(group_index <= m_block_group_count);
auto& bgd = group_descriptor(group_index); auto& bgd = group_descriptor(group_index);
unsigned blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count); int blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count);
unsigned block_count = ceil_div(blocks_in_group, 8u); int block_count = ceil_div(blocks_in_group, 8u);
unsigned first_block_in_group = (group_index - 1) * blocks_per_group(); BlockIndex first_block_in_group = (group_index - 1) * blocks_per_group();
unsigned bits_per_block = block_size() * 8; 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); auto block = read_block(bgd.bg_block_bitmap + i);
ASSERT(block); ASSERT(block);
bool should_continue = callback(first_block_in_group + (i * bits_per_block) + 1, Bitmap::wrap(block.pointer(), blocks_in_group)); 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; 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); LOCKER(m_lock);
dbgprintf("Ext2FS: allocate_blocks(group: %u, count: %u)\n", group, count); 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; 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); LOCKER(m_lock);
dbgprintf("Ext2FS: allocate_inode(preferredGroup: %u, expectedSize: %u)\n", preferred_group, expected_size); 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; 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); LOCKER(m_lock);
ASSERT(parent_id.fsid() == fsid()); ASSERT(parent_id.fsid() == fsid());
@ -1388,10 +1388,10 @@ KResult Ext2FSInode::chown(uid_t uid, gid_t gid)
return KSuccess; return KSuccess;
} }
KResult Ext2FSInode::truncate(int size) KResult Ext2FSInode::truncate(off_t size)
{ {
LOCKER(m_lock); LOCKER(m_lock);
if (m_raw_inode.i_size == size) if ((off_t)m_raw_inode.i_size == size)
return KSuccess; return KSuccess;
m_raw_inode.i_size = size; m_raw_inode.i_size = size;
set_metadata_dirty(true); 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 size_t directory_entry_count() const override;
virtual KResult chmod(mode_t) override; virtual KResult chmod(mode_t) override;
virtual KResult chown(uid_t, gid_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; void populate_lookup_cache() const;
@ -83,36 +83,36 @@ private:
unsigned blocks_per_group() const; unsigned blocks_per_group() const;
unsigned inode_size() const; unsigned inode_size() const;
bool write_ext2_inode(unsigned, const ext2_inode&); bool write_ext2_inode(InodeIndex, const ext2_inode&);
ByteBuffer read_block_containing_inode(unsigned inode, unsigned& block_index, unsigned& offset) const; ByteBuffer read_block_containing_inode(InodeIndex inode, BlockIndex& block_index, unsigned& offset) const;
ByteBuffer read_super_block() const; ByteBuffer read_super_block() const;
bool write_super_block(const ext2_super_block&); bool write_super_block(const ext2_super_block&);
virtual const char* class_name() const override; virtual const char* class_name() const override;
virtual InodeIdentifier root_inode() 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> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override; virtual RetainPtr<Inode> get_inode(InodeIdentifier) const override;
unsigned allocate_inode(unsigned preferredGroup, unsigned expectedSize); InodeIndex allocate_inode(GroupIndex preferred_group, off_t expected_size);
Vector<BlockIndex> allocate_blocks(unsigned group, unsigned count); Vector<BlockIndex> allocate_blocks(GroupIndex, int count);
unsigned group_index_from_inode(unsigned) const; GroupIndex group_index_from_inode(InodeIndex) const;
GroupIndex group_index_from_block_index(BlockIndex) 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>&); bool write_block_list_for_inode(InodeIndex, ext2_inode&, const Vector<BlockIndex>&);
void dump_block_bitmap(unsigned groupIndex) const; void dump_block_bitmap(GroupIndex) const;
void dump_inode_bitmap(unsigned groupIndex) const; void dump_inode_bitmap(GroupIndex) const;
template<typename F> void traverse_inode_bitmap(unsigned groupIndex, F) const; template<typename F> void traverse_inode_bitmap(GroupIndex, F) const;
template<typename F> void traverse_block_bitmap(unsigned 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 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 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); bool set_block_allocation_state(BlockIndex, bool);
void uncache_inode(InodeIndex); 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'; 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) : name_length(nl)
, inode(i) , inode(i)
, file_type(ft) , file_type(ft)

6
Kernel/FileSystem/FileSystem.h
View file

@ -45,14 +45,14 @@ public:
struct DirectoryEntry { struct DirectoryEntry {
DirectoryEntry(const char* name, InodeIdentifier, byte file_type); 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]; char name[256];
int name_length { 0 }; int name_length { 0 };
InodeIdentifier inode; InodeIdentifier inode;
byte file_type { 0 }; 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> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) = 0;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const = 0; virtual RetainPtr<Inode> get_inode(InodeIdentifier) const = 0;
@ -102,7 +102,7 @@ public:
virtual size_t directory_entry_count() const = 0; virtual size_t directory_entry_count() const = 0;
virtual KResult chmod(mode_t) = 0; virtual KResult chmod(mode_t) = 0;
virtual KResult chown(uid_t, gid_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(); } LocalSocket* socket() { return m_socket.ptr(); }
const LocalSocket* socket() const { 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; 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); ASSERT(to_proc_parent_directory(identifier) == PDI_Root_sys);
return identifier.index() & 0xff; return identifier.index() & 0xff;
@ -186,7 +186,7 @@ ByteBuffer procfs$pid_fds(InodeIdentifier identifier)
if (process.number_of_open_file_descriptors() == 0) if (process.number_of_open_file_descriptors() == 0)
return { }; return { };
StringBuilder builder; 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); auto* descriptor = process.file_descriptor(i);
if (!descriptor) if (!descriptor)
continue; continue;
@ -714,28 +714,28 @@ void ProcFS::add_sys_bool(String&& name, Lockable<bool>& var, Function<void()>&&
{ {
InterruptDisabler disabler; 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 inode = adopt(*new ProcFSInode(*this, sys_var_to_identifier(fsid(), index).index()));
auto data = make<SysVariableData>(); auto data = make<SysVariableData>();
data->type = SysVariableData::Boolean; data->type = SysVariableData::Boolean;
data->notify_callback = move(notify_callback); data->notify_callback = move(notify_callback);
data->address = &var; data->address = &var;
inode->set_custom_data(move(data)); 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) void ProcFS::add_sys_string(String&& name, Lockable<String>& var, Function<void()>&& notify_callback)
{ {
InterruptDisabler disabler; 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 inode = adopt(*new ProcFSInode(*this, sys_var_to_identifier(fsid(), index).index()));
auto data = make<SysVariableData>(); auto data = make<SysVariableData>();
data->type = SysVariableData::String; data->type = SysVariableData::String;
data->notify_callback = move(notify_callback); data->notify_callback = move(notify_callback);
data->address = &var; data->address = &var;
inode->set_custom_data(move(data)); 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() bool ProcFS::initialize()
@ -748,13 +748,8 @@ const char* ProcFS::class_name() const
return "ProcFS"; 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"); kprintf("FIXME: Implement ProcFS::create_inode()?\n");
return { }; return { };
} }
@ -934,7 +929,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
if (!entry.name) if (!entry.name)
continue; continue;
if (entry.proc_file_type > __FI_Root_Start && entry.proc_file_type < __FI_Root_End) 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()) { for (auto pid_child : Process::all_pids()) {
char name[16]; char name[16];
@ -946,7 +941,7 @@ bool ProcFSInode::traverse_as_directory(Function<bool(const FS::DirectoryEntry&)
case FI_Root_sys: case FI_Root_sys:
for (int i = 0; i < fs().m_sys_entries.size(); ++i) { for (int i = 0; i < fs().m_sys_entries.size(); ++i) {
auto& entry = fs().m_sys_entries[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; 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()) if (entry.proc_file_type == FI_PID_exe && !process.executable_inode())
continue; continue;
// FIXME: strlen() here is sad. // 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) if (!descriptor)
continue; continue;
char name[16]; 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 }); 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())); ASSERT(is_persistent_inode(identifier()));
// FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support.. // FIXME: Being able to write into ProcFS at a non-zero offset seems like something we should maybe support..
ASSERT(offset == 0); 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); ASSERT(success);
return 0; return 0;
} }

2
Kernel/FileSystem/ProcFS.h
View file

@ -22,7 +22,7 @@ public:
virtual InodeIdentifier root_inode() const override; virtual InodeIdentifier root_inode() const override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) 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; 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); 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 }; 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) parentInode;
(void) name; (void) name;
@ -274,7 +274,7 @@ ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer
return -EPERM; return -EPERM;
// FIXME: Being able to write into SynthFS at a non-zero offset seems like something we should support.. // FIXME: Being able to write into SynthFS at a non-zero offset seems like something we should support..
ASSERT(offset == 0); 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); ASSERT(success);
return 0; return 0;
} }

2
Kernel/FileSystem/SyntheticFileSystem.h
View file

@ -14,7 +14,7 @@ public:
virtual bool initialize() override; virtual bool initialize() override;
virtual const char* class_name() const override; virtual const char* class_name() const override;
virtual InodeIdentifier root_inode() 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> create_directory(InodeIdentifier parentInode, const String& name, mode_t, int& error) override;
virtual RetainPtr<Inode> get_inode(InodeIdentifier) const 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) KResultOr<Retained<SharedMemory>> SharedMemory::open(const String& name, int flags, mode_t mode)
{ {
UNUSED_PARAM(flags);
LOCKER(shared_memories().lock()); LOCKER(shared_memories().lock());
auto it = shared_memories().resource().find(name); auto it = shared_memories().resource().find(name);
if (it != shared_memories().resource().end()) { if (it != shared_memories().resource().end()) {

2
Kernel/SharedMemory.h
View file

@ -15,7 +15,7 @@ public:
~SharedMemory(); ~SharedMemory();
String name() const { return m_name; } String name() const { return m_name; }
KResult truncate(int); KResult truncate(off_t);
VMObject* vmo() { return m_vmo.ptr(); } VMObject* vmo() { return m_vmo.ptr(); }
const VMObject* vmo() const { return m_vmo.ptr(); } const VMObject* vmo() const { return m_vmo.ptr(); }
uid_t uid() const { return m_uid; } 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 parse_uint(const String& str, bool& ok)
{ {
unsigned value = 0; 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') { if (str[i] < '0' || str[i] > '9') {
ok = false; ok = false;
return 0; return 0;

2
Kernel/sync.sh
View file

@ -4,7 +4,7 @@ if [ $(id -u) != 0 ]; then
fi fi
rm -vf _fs_contents.lock rm -vf _fs_contents.lock
rm -vf _fs_contents 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 mke2fs _fs_contents
chown 1000:1000 _fs_contents chown 1000:1000 _fs_contents
mkdir -vp mnt mkdir -vp mnt

2
LibC/stdio.cpp
View file

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

4
LibC/stdlib.cpp
View file

@ -133,7 +133,7 @@ void free(void* ptr)
return; 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_map[i / 8] &= ~(1 << (i % 8));
s_malloc_sum_alloc -= header->chunk_count * CHUNK_SIZE; 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) } else if (neg)
acc = -acc; acc = -acc;
if (endptr) if (endptr)
*endptr = (char*)(any ? s - 1 : str); *endptr = const_cast<char*>((any ? s - 1 : str));
return acc; 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) void* memchr(const void* ptr, int c, size_t size)
{ {
char ch = c; char ch = c;
char* cptr = (char*)ptr; auto* cptr = (const char*)ptr;
for (size_t i = 0; i < size; ++i) { for (size_t i = 0; i < size; ++i) {
if (cptr[i] == ch) if (cptr[i] == ch)
return cptr + i; return const_cast<char*>(cptr + i);
} }
return nullptr; return nullptr;
} }
@ -358,7 +358,7 @@ char* strpbrk(const char* s, const char* accept)
{ {
while (*s) while (*s)
if(strchr(accept, *s++)) if(strchr(accept, *s++))
return (char*)--s; return const_cast<char*>(--s);
return nullptr; return nullptr;
} }

2
LibC/unistd.cpp
View file

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

4
LibGUI/GWindow.cpp
View file

@ -245,7 +245,7 @@ void GWindow::event(CEvent& event)
message.rects[i] = rects[i]; message.rects[i] = rects[i];
ByteBuffer extra_data; ByteBuffer extra_data;
if (rects.size() > WSAPI_ClientMessage::max_inline_rect_count) 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); GEventLoop::current().post_message_to_server(message, extra_data);
} }
return; return;
@ -324,7 +324,7 @@ void GWindow::update(const Rect& a_rect)
request.rects[i] = m_pending_paint_event_rects[i]; request.rects[i] = m_pending_paint_event_rects[i];
ByteBuffer extra_data; ByteBuffer extra_data;
if (m_pending_paint_event_rects.size() > WSAPI_ClientMessage::max_inline_rect_count) 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(); request.rect_count = m_pending_paint_event_rects.size();
GEventLoop::current().post_message_to_server(request, extra_data); GEventLoop::current().post_message_to_server(request, extra_data);
m_pending_paint_event_rects.clear_with_capacity(); 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(); message.paint.window_size = window.size();
ByteBuffer extra_data; ByteBuffer extra_data;
if (rects.size() > WSAPI_ServerMessage::max_inline_rect_count) 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); post_message(message, extra_data);
} }

2
SharedGraphics/PNGLoader.cpp
View file

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