mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 21:37:35 +00:00
More moving towards using signed types.
I'm still feeling this out, but I am starting to like the general idea.
This commit is contained in:
parent
beda478821
commit
9624b54703
48 changed files with 234 additions and 250 deletions
|
@ -10,7 +10,7 @@ public:
|
|||
DiskDevice& device() { return *m_device; }
|
||||
const DiskDevice& device() const { return *m_device; }
|
||||
|
||||
size_t block_size() const { return m_block_size; }
|
||||
int block_size() const { return m_block_size; }
|
||||
|
||||
protected:
|
||||
explicit DiskBackedFS(Retained<DiskDevice>&&);
|
||||
|
@ -24,6 +24,6 @@ protected:
|
|||
bool write_blocks(unsigned index, unsigned count, const ByteBuffer&);
|
||||
|
||||
private:
|
||||
size_t m_block_size { 0 };
|
||||
int m_block_size { 0 };
|
||||
Retained<DiskDevice> m_device;
|
||||
};
|
||||
|
|
|
@ -190,7 +190,7 @@ bool Ext2FS::write_block_list_for_inode(InodeIndex inode_index, ext2_inode& e2in
|
|||
{
|
||||
LOCKER(m_lock);
|
||||
|
||||
dbgprintf("Ext2FS: writing %u block(s) to i_block array\n", min((size_t)EXT2_NDIR_BLOCKS, blocks.size()));
|
||||
dbgprintf("Ext2FS: writing %u block(s) to i_block array\n", min(EXT2_NDIR_BLOCKS, blocks.size()));
|
||||
|
||||
auto old_shape = compute_block_list_shape(e2inode.i_blocks / (2 << super_block().s_log_block_size));
|
||||
auto new_shape = compute_block_list_shape(blocks.size());
|
||||
|
@ -429,7 +429,7 @@ RetainPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
|
|||
return new_inode;
|
||||
}
|
||||
|
||||
ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor*) const
|
||||
ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor*) const
|
||||
{
|
||||
Locker inode_locker(m_lock);
|
||||
ASSERT(offset >= 0);
|
||||
|
@ -441,7 +441,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDe
|
|||
static const unsigned max_inline_symlink_length = 60;
|
||||
if (is_symlink() && size() < max_inline_symlink_length) {
|
||||
ssize_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
|
||||
memcpy(buffer, m_raw_inode.i_block + offset, nread);
|
||||
memcpy(buffer, m_raw_inode.i_block + offset, (size_t)nread);
|
||||
return nread;
|
||||
}
|
||||
|
||||
|
@ -494,7 +494,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDe
|
|||
return nread;
|
||||
}
|
||||
|
||||
ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, FileDescriptor*)
|
||||
ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data, FileDescriptor*)
|
||||
{
|
||||
Locker inode_locker(m_lock);
|
||||
Locker fs_locker(fs().m_lock);
|
||||
|
@ -504,7 +504,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, F
|
|||
|
||||
ASSERT(offset >= 0);
|
||||
|
||||
const size_t block_size = fs().block_size();
|
||||
const ssize_t block_size = fs().block_size();
|
||||
size_t old_size = size();
|
||||
size_t new_size = max(static_cast<size_t>(offset) + count, size());
|
||||
|
||||
|
@ -539,8 +539,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, size_t count, const byte* data, F
|
|||
|
||||
auto buffer_block = ByteBuffer::create_uninitialized(block_size);
|
||||
for (dword bi = first_block_logical_index; remaining_count && bi <= last_block_logical_index; ++bi) {
|
||||
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);
|
||||
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);
|
||||
|
||||
ByteBuffer block;
|
||||
if (offset_into_block != 0) {
|
||||
|
@ -702,24 +702,24 @@ bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntr
|
|||
LOCKER(m_lock);
|
||||
dbgprintf("Ext2FS: New directory inode %u contents to write:\n", directoryInode);
|
||||
|
||||
unsigned directory_size = 0;
|
||||
int directory_size = 0;
|
||||
for (auto& entry : entries) {
|
||||
//kprintf(" - %08u %s\n", entry.inode.index(), entry.name);
|
||||
directory_size += EXT2_DIR_REC_LEN(entry.name_length);
|
||||
}
|
||||
|
||||
unsigned blocks_needed = ceil_div(directory_size, block_size());
|
||||
unsigned occupied_size = blocks_needed * block_size();
|
||||
int blocks_needed = ceil_div(directory_size, block_size());
|
||||
int occupied_size = blocks_needed * block_size();
|
||||
|
||||
dbgprintf("Ext2FS: directory size: %u (occupied: %u)\n", directory_size, occupied_size);
|
||||
|
||||
auto directory_data = ByteBuffer::create_uninitialized(occupied_size);
|
||||
|
||||
BufferStream stream(directory_data);
|
||||
for (unsigned i = 0; i < entries.size(); ++i) {
|
||||
for (int i = 0; i < entries.size(); ++i) {
|
||||
auto& entry = entries[i];
|
||||
|
||||
unsigned record_length = EXT2_DIR_REC_LEN(entry.name_length);
|
||||
int record_length = EXT2_DIR_REC_LEN(entry.name_length);
|
||||
if (i == entries.size() - 1)
|
||||
record_length += occupied_size - directory_size;
|
||||
|
||||
|
@ -735,27 +735,13 @@ bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntr
|
|||
stream << byte(entry.file_type);
|
||||
stream << entry.name;
|
||||
|
||||
unsigned padding = record_length - entry.name_length - 8;
|
||||
//dbgprintf(" *** pad %u bytes\n", padding);
|
||||
for (unsigned j = 0; j < padding; ++j) {
|
||||
int padding = record_length - entry.name_length - 8;
|
||||
for (int j = 0; j < padding; ++j)
|
||||
stream << byte(0);
|
||||
}
|
||||
}
|
||||
|
||||
stream.fill_to_end(0);
|
||||
|
||||
#if 0
|
||||
kprintf("data to write (%u):\n", directory_data.size());
|
||||
for (unsigned i = 0; i < directory_data.size(); ++i) {
|
||||
kprintf("%02x ", directory_data[i]);
|
||||
if ((i + 1) % 8 == 0)
|
||||
kprintf(" ");
|
||||
if ((i + 1) % 16 == 0)
|
||||
kprintf("\n");
|
||||
}
|
||||
kprintf("\n");
|
||||
#endif
|
||||
|
||||
auto directory_inode = get_inode({ fsid(), directoryInode });
|
||||
ssize_t nwritten = directory_inode->write_bytes(0, directory_data.size(), directory_data.pointer(), nullptr);
|
||||
return nwritten == directory_data.size();
|
||||
|
@ -806,7 +792,7 @@ void Ext2FS::dump_inode_bitmap(unsigned groupIndex) const
|
|||
{
|
||||
LOCKER(m_lock);
|
||||
traverse_inode_bitmap(groupIndex, [] (unsigned, const Bitmap& bitmap) {
|
||||
for (unsigned i = 0; i < bitmap.size(); ++i)
|
||||
for (int i = 0; i < bitmap.size(); ++i)
|
||||
kprintf("%c", bitmap.get(i) ? '1' : '0');
|
||||
return true;
|
||||
});
|
||||
|
@ -882,7 +868,7 @@ Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(unsigned group, unsigned coun
|
|||
// FIXME: Implement a scan that finds consecutive blocks if possible.
|
||||
Vector<BlockIndex> blocks;
|
||||
traverse_block_bitmap(group, [&blocks, count] (unsigned first_block_in_bitmap, const Bitmap& bitmap) {
|
||||
for (unsigned i = 0; i < bitmap.size(); ++i) {
|
||||
for (int i = 0; i < bitmap.size(); ++i) {
|
||||
if (!bitmap.get(i)) {
|
||||
blocks.append(first_block_in_bitmap + i);
|
||||
if (blocks.size() == count)
|
||||
|
@ -931,23 +917,23 @@ unsigned Ext2FS::allocate_inode(unsigned preferred_group, unsigned expected_size
|
|||
|
||||
dbgprintf("Ext2FS: allocate_inode: found suitable group [%u] for new inode with %u blocks needed :^)\n", groupIndex, needed_blocks);
|
||||
|
||||
unsigned firstFreeInodeInGroup = 0;
|
||||
traverse_inode_bitmap(groupIndex, [&firstFreeInodeInGroup] (unsigned firstInodeInBitmap, const Bitmap& bitmap) {
|
||||
for (unsigned i = 0; i < bitmap.size(); ++i) {
|
||||
unsigned first_free_inode_in_group = 0;
|
||||
traverse_inode_bitmap(groupIndex, [&first_free_inode_in_group] (unsigned firstInodeInBitmap, const Bitmap& bitmap) {
|
||||
for (int i = 0; i < bitmap.size(); ++i) {
|
||||
if (!bitmap.get(i)) {
|
||||
firstFreeInodeInGroup = firstInodeInBitmap + i;
|
||||
first_free_inode_in_group = firstInodeInBitmap + i;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
if (!firstFreeInodeInGroup) {
|
||||
if (!first_free_inode_in_group) {
|
||||
kprintf("Ext2FS: first_free_inode_in_group returned no inode, despite bgd claiming there are inodes :(\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned inode = firstFreeInodeInGroup;
|
||||
unsigned inode = first_free_inode_in_group;
|
||||
dbgprintf("Ext2FS: found suitable inode %u\n", inode);
|
||||
|
||||
ASSERT(get_inode_allocation_state(inode) == false);
|
||||
|
|
|
@ -25,13 +25,13 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(const String& name) override;
|
||||
virtual String reverse_lookup(InodeIdentifier) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, size_t, const byte* data, FileDescriptor*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescriptor*) override;
|
||||
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
|
||||
virtual bool remove_child(const String& name, int& error) override;
|
||||
virtual RetainPtr<Inode> parent() const override;
|
||||
|
|
|
@ -104,7 +104,7 @@ void Inode::will_be_destroyed()
|
|||
flush_metadata();
|
||||
}
|
||||
|
||||
void Inode::inode_contents_changed(off_t offset, size_t size, const byte* data)
|
||||
void Inode::inode_contents_changed(off_t offset, ssize_t size, const byte* data)
|
||||
{
|
||||
if (m_vmo)
|
||||
m_vmo->inode_contents_changed(Badge<Inode>(), offset, size, data);
|
||||
|
|
|
@ -47,7 +47,7 @@ public:
|
|||
DirectoryEntry(const char* name, InodeIdentifier, byte file_type);
|
||||
DirectoryEntry(const char* name, size_t name_length, InodeIdentifier, byte file_type);
|
||||
char name[256];
|
||||
size_t name_length { 0 };
|
||||
int name_length { 0 };
|
||||
InodeIdentifier inode;
|
||||
byte file_type { 0 };
|
||||
};
|
||||
|
@ -88,11 +88,11 @@ public:
|
|||
|
||||
ByteBuffer read_entire(FileDescriptor* = nullptr) const;
|
||||
|
||||
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const = 0;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const = 0;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const = 0;
|
||||
virtual InodeIdentifier lookup(const String& name) = 0;
|
||||
virtual String reverse_lookup(InodeIdentifier) = 0;
|
||||
virtual ssize_t write_bytes(off_t, size_t, const byte* data, FileDescriptor*) = 0;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* data, FileDescriptor*) = 0;
|
||||
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) = 0;
|
||||
virtual bool remove_child(const String& name, int& error) = 0;
|
||||
virtual RetainPtr<Inode> parent() const = 0;
|
||||
|
@ -123,7 +123,7 @@ public:
|
|||
protected:
|
||||
Inode(FS& fs, unsigned index);
|
||||
void set_metadata_dirty(bool b) { m_metadata_dirty = b; }
|
||||
void inode_contents_changed(off_t, size_t, const byte*);
|
||||
void inode_contents_changed(off_t, ssize_t, const byte*);
|
||||
void inode_size_changed(size_t old_size, size_t new_size);
|
||||
|
||||
mutable Lock m_lock;
|
||||
|
|
|
@ -791,6 +791,7 @@ void VMObject::for_each_region(Callback callback)
|
|||
|
||||
void VMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size)
|
||||
{
|
||||
(void)old_size;
|
||||
InterruptDisabler disabler;
|
||||
|
||||
size_t old_page_count = page_count();
|
||||
|
@ -813,7 +814,7 @@ void VMObject::inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size
|
|||
});
|
||||
}
|
||||
|
||||
void VMObject::inode_contents_changed(Badge<Inode>, off_t offset, size_t size, const byte* data)
|
||||
void VMObject::inode_contents_changed(Badge<Inode>, off_t offset, ssize_t size, const byte* data)
|
||||
{
|
||||
(void)size;
|
||||
(void)data;
|
||||
|
|
|
@ -107,7 +107,7 @@ public:
|
|||
const Vector<RetainPtr<PhysicalPage>>& physical_pages() const { return m_physical_pages; }
|
||||
Vector<RetainPtr<PhysicalPage>>& physical_pages() { return m_physical_pages; }
|
||||
|
||||
void inode_contents_changed(Badge<Inode>, off_t, size_t, const byte*);
|
||||
void inode_contents_changed(Badge<Inode>, off_t, ssize_t, const byte*);
|
||||
void inode_size_changed(Badge<Inode>, size_t old_size, size_t new_size);
|
||||
|
||||
size_t size() const { return m_size; }
|
||||
|
|
|
@ -808,7 +808,7 @@ InodeMetadata ProcFSInode::metadata() const
|
|||
return metadata;
|
||||
}
|
||||
|
||||
ssize_t ProcFSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor* descriptor) const
|
||||
ssize_t ProcFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor* descriptor) const
|
||||
{
|
||||
#ifdef PROCFS_DEBUG
|
||||
dbgprintf("ProcFS: read_bytes %u\n", index());
|
||||
|
@ -1034,7 +1034,7 @@ void ProcFSInode::flush_metadata()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t ProcFSInode::write_bytes(off_t offset, size_t size, const byte* buffer, FileDescriptor*)
|
||||
ssize_t ProcFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescriptor*)
|
||||
{
|
||||
auto* directory_entry = fs().get_directory_entry(identifier());
|
||||
if (!directory_entry || !directory_entry->write_callback)
|
||||
|
|
|
@ -76,13 +76,13 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(const String& name) override;
|
||||
virtual String reverse_lookup(InodeIdentifier) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, size_t, const byte* buffer, FileDescriptor*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescriptor*) override;
|
||||
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
|
||||
virtual bool remove_child(const String& name, int& error) override;
|
||||
virtual RetainPtr<Inode> parent() const override;
|
||||
|
|
|
@ -121,7 +121,7 @@ Region* Process::allocate_region_with_vmo(LinearAddress laddr, size_t size, Reta
|
|||
bool Process::deallocate_region(Region& region)
|
||||
{
|
||||
InterruptDisabler disabler;
|
||||
for (size_t i = 0; i < m_regions.size(); ++i) {
|
||||
for (int i = 0; i < m_regions.size(); ++i) {
|
||||
if (m_regions[i].ptr() == ®ion) {
|
||||
MM.unmap_region(region);
|
||||
m_regions.remove(i);
|
||||
|
@ -367,7 +367,7 @@ int Process::do_exec(String path, Vector<String> arguments, Vector<String> envir
|
|||
m_signal_mask = 0xffffffff;
|
||||
m_pending_signals = 0;
|
||||
|
||||
for (size_t i = 0; i < m_fds.size(); ++i) {
|
||||
for (int i = 0; i < m_fds.size(); ++i) {
|
||||
auto& daf = m_fds[i];
|
||||
if (daf.descriptor && daf.flags & FD_CLOEXEC) {
|
||||
daf.descriptor->close();
|
||||
|
@ -441,21 +441,19 @@ void Process::make_userspace_stack(Vector<String> arguments, Vector<String> envi
|
|||
// FIXME: It would be better if this didn't make us panic.
|
||||
ASSERT((total_blob_size + total_meta_size) < default_userspace_stack_size);
|
||||
|
||||
for (size_t i = 0; i < arguments.size(); ++i) {
|
||||
for (int i = 0; i < arguments.size(); ++i) {
|
||||
argv[i] = bufptr;
|
||||
memcpy(bufptr, arguments[i].characters(), arguments[i].length());
|
||||
bufptr += arguments[i].length();
|
||||
*(bufptr++) = '\0';
|
||||
printf("argv[%u] = %p (%s)\n", i, argv[i], argv[i]);
|
||||
}
|
||||
argv[arguments.size()] = nullptr;
|
||||
|
||||
for (size_t i = 0; i < environment.size(); ++i) {
|
||||
for (int i = 0; i < environment.size(); ++i) {
|
||||
env[i] = bufptr;
|
||||
memcpy(bufptr, environment[i].characters(), environment[i].length());
|
||||
bufptr += environment[i].length();
|
||||
*(bufptr++) = '\0';
|
||||
printf("env[%u] = %p (%s)\n", i, env[i], env[i]);
|
||||
}
|
||||
env[environment.size()] = nullptr;
|
||||
|
||||
|
@ -623,7 +621,7 @@ Process::Process(String&& name, uid_t uid, gid_t gid, pid_t ppid, RingLevel ring
|
|||
|
||||
if (fork_parent) {
|
||||
m_fds.resize(fork_parent->m_fds.size());
|
||||
for (size_t i = 0; i < fork_parent->m_fds.size(); ++i) {
|
||||
for (int i = 0; i < fork_parent->m_fds.size(); ++i) {
|
||||
if (!fork_parent->m_fds[i].descriptor)
|
||||
continue;
|
||||
#ifdef FORK_DEBUG
|
||||
|
@ -959,7 +957,7 @@ FileDescriptor* Process::file_descriptor(int fd)
|
|||
{
|
||||
if (fd < 0)
|
||||
return nullptr;
|
||||
if ((size_t)fd < m_fds.size())
|
||||
if (fd < m_fds.size())
|
||||
return m_fds[fd].descriptor.ptr();
|
||||
return nullptr;
|
||||
}
|
||||
|
@ -968,7 +966,7 @@ const FileDescriptor* Process::file_descriptor(int fd) const
|
|||
{
|
||||
if (fd < 0)
|
||||
return nullptr;
|
||||
if ((size_t)fd < m_fds.size())
|
||||
if (fd < m_fds.size())
|
||||
return m_fds[fd].descriptor.ptr();
|
||||
return nullptr;
|
||||
}
|
||||
|
@ -1894,7 +1892,7 @@ int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int Process::sys$getgroups(int count, gid_t* gids)
|
||||
int Process::sys$getgroups(ssize_t count, gid_t* gids)
|
||||
{
|
||||
if (count < 0)
|
||||
return -EINVAL;
|
||||
|
@ -1911,8 +1909,10 @@ int Process::sys$getgroups(int count, gid_t* gids)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int Process::sys$setgroups(size_t count, const gid_t* gids)
|
||||
int Process::sys$setgroups(ssize_t count, const gid_t* gids)
|
||||
{
|
||||
if (count < 0)
|
||||
return -EINVAL;
|
||||
if (!is_superuser())
|
||||
return -EPERM;
|
||||
if (count >= MAX_PROCESS_GIDS)
|
||||
|
@ -1921,7 +1921,7 @@ int Process::sys$setgroups(size_t count, const gid_t* gids)
|
|||
return -EFAULT;
|
||||
m_gids.clear();
|
||||
m_gids.set(m_gid);
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
for (int i = 0; i < count; ++i)
|
||||
m_gids.set(gids[i]);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -198,8 +198,8 @@ public:
|
|||
int sys$sigaction(int signum, const sigaction* act, sigaction* old_act);
|
||||
int sys$sigprocmask(int how, const sigset_t* set, sigset_t* old_set);
|
||||
int sys$sigpending(sigset_t*);
|
||||
int sys$getgroups(int size, gid_t*);
|
||||
int sys$setgroups(size_t, const gid_t*);
|
||||
int sys$getgroups(ssize_t, gid_t*);
|
||||
int sys$setgroups(ssize_t, const gid_t*);
|
||||
int sys$pipe(int* pipefd);
|
||||
int sys$killpg(int pgrp, int sig);
|
||||
int sys$setgid(gid_t);
|
||||
|
|
|
@ -112,10 +112,9 @@ bool SynthFS::remove_file(InodeIndex inode)
|
|||
if (pit == m_inodes.end())
|
||||
return false;
|
||||
auto& parent = *(*pit).value;
|
||||
for (size_t i = 0; i < parent.m_children.size(); ++i) {
|
||||
if (parent.m_children[i]->m_metadata.inode.index() != inode) {
|
||||
for (ssize_t i = 0; i < parent.m_children.size(); ++i) {
|
||||
if (parent.m_children[i]->m_metadata.inode.index() != inode)
|
||||
continue;
|
||||
}
|
||||
parent.m_children.remove(i);
|
||||
break;
|
||||
}
|
||||
|
@ -193,7 +192,7 @@ InodeMetadata SynthFSInode::metadata() const
|
|||
return m_metadata;
|
||||
}
|
||||
|
||||
ssize_t SynthFSInode::read_bytes(off_t offset, size_t count, byte* buffer, FileDescriptor* descriptor) const
|
||||
ssize_t SynthFSInode::read_bytes(off_t offset, ssize_t count, byte* buffer, FileDescriptor* descriptor) const
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
#ifdef SYNTHFS_DEBUG
|
||||
|
@ -269,7 +268,7 @@ void SynthFSInode::flush_metadata()
|
|||
{
|
||||
}
|
||||
|
||||
ssize_t SynthFSInode::write_bytes(off_t offset, size_t size, const byte* buffer, FileDescriptor*)
|
||||
ssize_t SynthFSInode::write_bytes(off_t offset, ssize_t size, const byte* buffer, FileDescriptor*)
|
||||
{
|
||||
LOCKER(m_lock);
|
||||
if (!m_write_callback)
|
||||
|
|
|
@ -56,13 +56,13 @@ public:
|
|||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ssize_t read_bytes(off_t, size_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual ssize_t read_bytes(off_t, ssize_t, byte* buffer, FileDescriptor*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual bool traverse_as_directory(Function<bool(const FS::DirectoryEntry&)>) const override;
|
||||
virtual InodeIdentifier lookup(const String& name) override;
|
||||
virtual String reverse_lookup(InodeIdentifier) override;
|
||||
virtual void flush_metadata() override;
|
||||
virtual ssize_t write_bytes(off_t, size_t, const byte* buffer, FileDescriptor*) override;
|
||||
virtual ssize_t write_bytes(off_t, ssize_t, const byte* buffer, FileDescriptor*) override;
|
||||
virtual bool add_child(InodeIdentifier child_id, const String& name, byte file_type, int& error) override;
|
||||
virtual bool remove_child(const String& name, int& error) override;
|
||||
virtual RetainPtr<Inode> parent() const override;
|
||||
|
|
|
@ -154,9 +154,9 @@ static dword handle(RegisterDump& regs, dword function, dword arg1, dword arg2,
|
|||
case Syscall::SC_umask:
|
||||
return current->sys$umask((mode_t)arg1);
|
||||
case Syscall::SC_getgroups:
|
||||
return current->sys$getgroups((int)arg1, (gid_t*)arg2);
|
||||
return current->sys$getgroups((ssize_t)arg1, (gid_t*)arg2);
|
||||
case Syscall::SC_setgroups:
|
||||
return current->sys$setgroups((size_t)arg1, (const gid_t*)arg2);
|
||||
return current->sys$setgroups((ssize_t)arg1, (const gid_t*)arg2);
|
||||
case Syscall::SC_sigreturn:
|
||||
current->sys$sigreturn();
|
||||
ASSERT_NOT_REACHED();
|
||||
|
|
|
@ -512,7 +512,7 @@ KResultOr<InodeIdentifier> VFS::resolve_path(const String& path, InodeIdentifier
|
|||
if (parent_id)
|
||||
*parent_id = crumb_id;
|
||||
|
||||
for (unsigned i = 0; i < parts.size(); ++i) {
|
||||
for (int i = 0; i < parts.size(); ++i) {
|
||||
bool inode_was_root_at_head_of_loop = crumb_id.is_root_inode();
|
||||
auto& part = parts[i];
|
||||
if (part.is_empty())
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue