mirror of
https://github.com/RGBCube/serenity
synced 2025-07-26 18:27:39 +00:00
Do a pass of compiler warning fixes.
This is really making me question not using 64-bit integers more.
This commit is contained in:
Andreas Kling
parent
243e1d8462
commit
58240fdb33
21 changed files with 89 additions and 84 deletions
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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(); }
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue