Kernel: Add explicit offset parameter to File::read etc

Author: https://github.com/deoxxa
Commit: https://github.com/SerenityOS/serenity/commit/a3edeb5868a
Pull-request: https://github.com/SerenityOS/serenity/pull/1725

Kernel/Devices/BXVGADevice.h

@@ -45,10 +45,10 @@ public:
 
 private:
     virtual const char* class_name() const override { return "BXVGA"; }
-    virtual bool can_read(const FileDescription&) const override { return true; }
-    virtual bool can_write(const FileDescription&) const override { return true; }
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override { return -EINVAL; }
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override { return -EINVAL; }
+    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override { return -EINVAL; }
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override { return -EINVAL; }
     virtual bool read_blocks(unsigned, u16, u8*) override { return false; }
     virtual bool write_blocks(unsigned, u16, const u8*) override { return false; }
 

Kernel/Devices/DiskPartition.cpp

@@ -48,32 +48,48 @@ DiskPartition::~DiskPartition()
 {
 }
 
-ssize_t DiskPartition::read(FileDescription& file_description, u8* buffer, ssize_t length)
+ssize_t DiskPartition::read(FileDescription& fd, size_t offset, u8* outbuf, ssize_t len)
 {
-    // FIXME: This is a hacky solution, but works fine for now...
-    off_t current_offset = file_description.seek(0, SEEK_CUR);
-    auto new_offset = current_offset + (m_block_offset * m_device->block_size());
-    if ((new_offset / m_device->block_size()) > m_block_limit || ((new_offset + length) / m_device->block_size()) > m_block_limit) {
-        return 0;
-    }
-    file_description.seek(new_offset, SEEK_SET);
-    auto result = m_device->read(file_description, buffer, length);
-    file_description.seek(current_offset, SEEK_SET);
-    return result;
+    unsigned adjust = m_block_offset * block_size();
+
+#ifdef OFFD_DEBUG
+    klog() << "DiskPartition::read offset=" << fd.offset() << " adjust=" << adjust << " len=" << len;
+#endif
+
+    return m_device->read(fd, offset + adjust, outbuf, len);
 }
 
-ssize_t DiskPartition::write(FileDescription& file_description, const u8* buffer, ssize_t length)
+bool DiskPartition::can_read(const FileDescription& fd, size_t offset) const
 {
-    // FIXME: This is a hacky solution, but works fine for now...
-    off_t current_offset = file_description.seek(0, SEEK_CUR);
-    auto new_offset = current_offset + (m_block_offset * m_device->block_size());
-    if ((new_offset / m_device->block_size()) > m_block_limit || ((new_offset + length) / m_device->block_size()) > m_block_limit) {
-        return 0;
-    }
-    file_description.seek(new_offset, SEEK_SET);
-    auto result = m_device->write(file_description, buffer, length);
-    file_description.seek(current_offset, SEEK_SET);
-    return result;
+    unsigned adjust = m_block_offset * block_size();
+
+#ifdef OFFD_DEBUG
+    klog() << "DiskPartition::can_read offset=" << offset << " adjust=" << adjust;
+#endif
+
+    return m_device->can_read(fd, offset + adjust);
+}
+
+ssize_t DiskPartition::write(FileDescription& fd, size_t offset, const u8* inbuf, ssize_t len)
+{
+    unsigned adjust = m_block_offset * block_size();
+
+#ifdef OFFD_DEBUG
+    klog() << "DiskPartition::write offset=" << offset << " adjust=" << adjust << " len=" << len;
+#endif
+
+    return m_device->write(fd, offset + adjust, inbuf, len);
+}
+
+bool DiskPartition::can_write(const FileDescription& fd, size_t offset) const
+{
+    unsigned adjust = m_block_offset * block_size();
+
+#ifdef OFFD_DEBUG
+    klog() << "DiskPartition::can_write offset=" << offset << " adjust=" << adjust;
+#endif
+
+    return m_device->can_write(fd, offset + adjust);
 }
 
 bool DiskPartition::read_blocks(unsigned index, u16 count, u8* out)

Kernel/Devices/DiskPartition.h

@@ -40,10 +40,10 @@ public:
     virtual bool write_blocks(unsigned index, u16 count, const u8*) override;
 
     // ^BlockDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override { return true; }
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
 
 private:
     virtual const char* class_name() const override;

Kernel/Devices/FullDevice.cpp

@@ -40,19 +40,19 @@ FullDevice::~FullDevice()
 {
 }
 
-bool FullDevice::can_read(const FileDescription&) const
+bool FullDevice::can_read(const FileDescription&, size_t) const
 {
     return true;
 }
 
-ssize_t FullDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t FullDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     ssize_t count = min(PAGE_SIZE, size);
     memset(buffer, 0, (size_t)count);
     return count;
 }
 
-ssize_t FullDevice::write(FileDescription&, const u8*, ssize_t size)
+ssize_t FullDevice::write(FileDescription&, size_t, const u8*, ssize_t size)
 {
     if (size == 0)
         return 0;

Kernel/Devices/FullDevice.h

@@ -38,10 +38,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
     virtual const char* class_name() const override { return "FullDevice"; }
 };
 

Kernel/Devices/KeyboardDevice.cpp

@@ -573,12 +573,12 @@ KeyboardDevice::~KeyboardDevice()
 {
 }
 
-bool KeyboardDevice::can_read(const FileDescription&) const
+bool KeyboardDevice::can_read(const FileDescription&, size_t) const
 {
     return !m_queue.is_empty();
 }
 
-ssize_t KeyboardDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t KeyboardDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     ssize_t nread = 0;
     while (nread < size) {
@@ -594,7 +594,7 @@ ssize_t KeyboardDevice::read(FileDescription&, u8* buffer, ssize_t size)
     return nread;
 }
 
-ssize_t KeyboardDevice::write(FileDescription&, const u8*, ssize_t)
+ssize_t KeyboardDevice::write(FileDescription&, size_t, const u8*, ssize_t)
 {
     return 0;
 }

Kernel/Devices/KeyboardDevice.h

@@ -52,10 +52,10 @@ public:
     void set_maps(const char* n_map, const char* n_shift_map, const char* n_alt_map, const char* n_altgr_map);
 
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8* buffer, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t write(FileDescription&, const u8* buffer, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8* buffer, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t write(FileDescription&, size_t, const u8* buffer, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
 
     virtual const char* purpose() const override { return class_name(); }
 

Kernel/Devices/MBVGADevice.h

@@ -45,10 +45,10 @@ public:
 
 private:
     virtual const char* class_name() const override { return "MBVGA"; }
-    virtual bool can_read(const FileDescription&) const override { return true; }
-    virtual bool can_write(const FileDescription&) const override { return true; }
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override { return -EINVAL; }
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override { return -EINVAL; }
+    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override { return -EINVAL; }
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override { return -EINVAL; }
     virtual bool read_blocks(unsigned, u16, u8*) override { return false; }
     virtual bool write_blocks(unsigned, u16, const u8*) override { return false; }
 

Kernel/Devices/NullDevice.cpp

@@ -47,17 +47,17 @@ NullDevice::~NullDevice()
 {
 }
 
-bool NullDevice::can_read(const FileDescription&) const
+bool NullDevice::can_read(const FileDescription&, size_t) const
 {
     return true;
 }
 
-ssize_t NullDevice::read(FileDescription&, u8*, ssize_t)
+ssize_t NullDevice::read(FileDescription&, size_t, u8*, ssize_t)
 {
     return 0;
 }
 
-ssize_t NullDevice::write(FileDescription&, const u8*, ssize_t buffer_size)
+ssize_t NullDevice::write(FileDescription&, size_t, const u8*, ssize_t buffer_size)
 {
     return min(PAGE_SIZE, buffer_size);
 }

Kernel/Devices/NullDevice.h

@@ -40,10 +40,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
-    virtual bool can_read(const FileDescription&) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_read(const FileDescription&, size_t) const override;
     virtual const char* class_name() const override { return "NullDevice"; }
 };
 

Kernel/Devices/PATADiskDevice.cpp

@@ -80,9 +80,9 @@ void PATADiskDevice::set_drive_geometry(u16 cyls, u16 heads, u16 spt)
     m_sectors_per_track = spt;
 }
 
-ssize_t PATADiskDevice::read(FileDescription& fd, u8* outbuf, ssize_t len)
+ssize_t PATADiskDevice::read(FileDescription&, size_t offset, u8* outbuf, ssize_t len)
 {
-    unsigned index = fd.offset() / block_size();
+    unsigned index = offset / block_size();
     u16 whole_blocks = len / block_size();
     ssize_t remaining = len % block_size();
 
@@ -116,14 +116,14 @@ ssize_t PATADiskDevice::read(FileDescription& fd, u8* outbuf, ssize_t len)
     return pos + remaining;
 }
 
-bool PATADiskDevice::can_read(const FileDescription& fd) const
+bool PATADiskDevice::can_read(const FileDescription&, size_t offset) const
 {
-    return static_cast<unsigned>(fd.offset()) < (m_cylinders * m_heads * m_sectors_per_track * block_size());
+    return offset < (m_cylinders * m_heads * m_sectors_per_track * block_size());
 }
 
-ssize_t PATADiskDevice::write(FileDescription& fd, const u8* inbuf, ssize_t len)
+ssize_t PATADiskDevice::write(FileDescription&, size_t offset, const u8* inbuf, ssize_t len)
 {
-    unsigned index = fd.offset() / block_size();
+    unsigned index = offset / block_size();
     u16 whole_blocks = len / block_size();
     ssize_t remaining = len % block_size();
 
@@ -162,9 +162,9 @@ ssize_t PATADiskDevice::write(FileDescription& fd, const u8* inbuf, ssize_t len)
     return pos + remaining;
 }
 
-bool PATADiskDevice::can_write(const FileDescription& fd) const
+bool PATADiskDevice::can_write(const FileDescription&, size_t offset) const
 {
-    return static_cast<unsigned>(fd.offset()) < (m_cylinders * m_heads * m_sectors_per_track * block_size());
+    return offset < (m_cylinders * m_heads * m_sectors_per_track * block_size());
 }
 
 bool PATADiskDevice::read_sectors_with_dma(u32 lba, u16 count, u8* outbuf)

Kernel/Devices/PATADiskDevice.h

@@ -61,10 +61,10 @@ public:
     void set_drive_geometry(u16, u16, u16);
 
     // ^BlockDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
 
 protected:
     explicit PATADiskDevice(PATAChannel&, DriveType, int, int);

Kernel/Devices/PS2MouseDevice.cpp

@@ -293,12 +293,12 @@ u8 PS2MouseDevice::mouse_read()
     return IO::in8(I8042_BUFFER);
 }
 
-bool PS2MouseDevice::can_read(const FileDescription&) const
+bool PS2MouseDevice::can_read(const FileDescription&, size_t) const
 {
     return !m_queue.is_empty();
 }
 
-ssize_t PS2MouseDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t PS2MouseDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     ASSERT(size > 0);
     size_t nread = 0;
@@ -318,7 +318,7 @@ ssize_t PS2MouseDevice::read(FileDescription&, u8* buffer, ssize_t size)
     return nread;
 }
 
-ssize_t PS2MouseDevice::write(FileDescription&, const u8*, ssize_t)
+ssize_t PS2MouseDevice::write(FileDescription&, size_t, const u8*, ssize_t)
 {
     return 0;
 }

Kernel/Devices/PS2MouseDevice.h

@@ -42,10 +42,10 @@ public:
     static PS2MouseDevice& the();
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
 
     virtual const char* purpose() const override { return class_name(); }
 

Kernel/Devices/RandomDevice.cpp

@@ -38,18 +38,18 @@ RandomDevice::~RandomDevice()
 {
 }
 
-bool RandomDevice::can_read(const FileDescription&) const
+bool RandomDevice::can_read(const FileDescription&, size_t) const
 {
     return true;
 }
 
-ssize_t RandomDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t RandomDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     get_good_random_bytes(buffer, size);
     return size;
 }
 
-ssize_t RandomDevice::write(FileDescription&, const u8*, ssize_t size)
+ssize_t RandomDevice::write(FileDescription&, size_t, const u8*, ssize_t size)
 {
     // FIXME: Use input for entropy? I guess that could be a neat feature?
     return min(PAGE_SIZE, size);

Kernel/Devices/RandomDevice.h

@@ -38,10 +38,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
     virtual const char* class_name() const override { return "RandomDevice"; }
 };
 

Kernel/Devices/SB16.cpp

@@ -167,12 +167,12 @@ void SB16::set_irq_line(u8 irq_number)
     change_irq_number(irq_number);
 }
 
-bool SB16::can_read(const FileDescription&) const
+bool SB16::can_read(const FileDescription&, size_t) const
 {
     return false;
 }
 
-ssize_t SB16::read(FileDescription&, u8*, ssize_t)
+ssize_t SB16::read(FileDescription&, size_t, u8*, ssize_t)
 {
     return 0;
 }
@@ -226,7 +226,7 @@ void SB16::wait_for_irq()
     disable_irq();
 }
 
-ssize_t SB16::write(FileDescription&, const u8* data, ssize_t length)
+ssize_t SB16::write(FileDescription&, size_t, const u8* data, ssize_t length)
 {
     if (!m_dma_region) {
         auto page = MM.allocate_supervisor_physical_page();

Kernel/Devices/SB16.h

@@ -45,10 +45,10 @@ public:
     static SB16& the();
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
 
     virtual const char* purpose() const override { return class_name(); }
 

Kernel/Devices/SerialDevice.cpp

@@ -40,12 +40,12 @@ SerialDevice::~SerialDevice()
 {
 }
 
-bool SerialDevice::can_read(const FileDescription&) const
+bool SerialDevice::can_read(const FileDescription&, size_t) const
 {
     return (get_line_status() & DataReady) != 0;
 }
 
-ssize_t SerialDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t SerialDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     if (!size)
         return 0;
@@ -58,12 +58,12 @@ ssize_t SerialDevice::read(FileDescription&, u8* buffer, ssize_t size)
     return 1;
 }
 
-bool SerialDevice::can_write(const FileDescription&) const
+bool SerialDevice::can_write(const FileDescription&, size_t) const
 {
     return (get_line_status() & EmptyTransmitterHoldingRegister) != 0;
 }
 
-ssize_t SerialDevice::write(FileDescription&, const u8* buffer, ssize_t size)
+ssize_t SerialDevice::write(FileDescription&, size_t, const u8* buffer, ssize_t size)
 {
     if (!size)
         return 0;

Kernel/Devices/SerialDevice.h

@@ -40,10 +40,10 @@ public:
     virtual ~SerialDevice() override;
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
 
     enum InterruptEnable {
         LowPowerMode = 0x01 << 5,

Kernel/Devices/ZeroDevice.cpp

@@ -39,19 +39,19 @@ ZeroDevice::~ZeroDevice()
 {
 }
 
-bool ZeroDevice::can_read(const FileDescription&) const
+bool ZeroDevice::can_read(const FileDescription&, size_t) const
 {
     return true;
 }
 
-ssize_t ZeroDevice::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t ZeroDevice::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     ssize_t count = min(PAGE_SIZE, size);
     memset(buffer, 0, (size_t)count);
     return count;
 }
 
-ssize_t ZeroDevice::write(FileDescription&, const u8*, ssize_t size)
+ssize_t ZeroDevice::write(FileDescription&, size_t, const u8*, ssize_t size)
 {
     return min(PAGE_SIZE, size);
 }

Kernel/Devices/ZeroDevice.h

@@ -38,10 +38,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
     virtual const char* class_name() const override { return "ZeroDevice"; }
 };
 

Kernel/FileSystem/FIFO.cpp

@@ -106,17 +106,17 @@ void FIFO::detach(Direction direction)
     }
 }
 
-bool FIFO::can_read(const FileDescription&) const
+bool FIFO::can_read(const FileDescription&, size_t) const
 {
     return !m_buffer.is_empty() || !m_writers;
 }
 
-bool FIFO::can_write(const FileDescription&) const
+bool FIFO::can_write(const FileDescription&, size_t) const
 {
     return m_buffer.space_for_writing() || !m_readers;
 }
 
-ssize_t FIFO::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t FIFO::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     if (!m_writers && m_buffer.is_empty())
         return 0;
@@ -130,7 +130,7 @@ ssize_t FIFO::read(FileDescription&, u8* buffer, ssize_t size)
     return nread;
 }
 
-ssize_t FIFO::write(FileDescription&, const u8* buffer, ssize_t size)
+ssize_t FIFO::write(FileDescription&, size_t, const u8* buffer, ssize_t size)
 {
     if (!m_readers) {
         Thread::current->send_signal(SIGPIPE, Process::current);

Kernel/FileSystem/FIFO.h

@@ -54,10 +54,10 @@ public:
 
 private:
     // ^File
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual String absolute_path(const FileDescription&) const override;
     virtual const char* class_name() const override { return "FIFO"; }
     virtual bool is_fifo() const override { return true; }

Kernel/FileSystem/File.h

@@ -71,11 +71,11 @@ public:
     virtual KResultOr<NonnullRefPtr<FileDescription>> open(int options);
     virtual void close();
 
-    virtual bool can_read(const FileDescription&) const = 0;
-    virtual bool can_write(const FileDescription&) const = 0;
+    virtual bool can_read(const FileDescription&, size_t) const = 0;
+    virtual bool can_write(const FileDescription&, size_t) const = 0;
 
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) = 0;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) = 0;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) = 0;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) = 0;
     virtual int ioctl(FileDescription&, unsigned request, unsigned arg);
     virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t size, int prot, bool shared);
 

Kernel/FileSystem/FileDescription.cpp

@@ -130,7 +130,7 @@ ssize_t FileDescription::read(u8* buffer, ssize_t count)
     if ((m_current_offset + count) < 0)
         return -EOVERFLOW;
     SmapDisabler disabler;
-    int nread = m_file->read(*this, buffer, count);
+    int nread = m_file->read(*this, offset(), buffer, count);
     if (nread > 0 && m_file->is_seekable())
         m_current_offset += nread;
     return nread;
@@ -142,7 +142,7 @@ ssize_t FileDescription::write(const u8* data, ssize_t size)
     if ((m_current_offset + size) < 0)
         return -EOVERFLOW;
     SmapDisabler disabler;
-    int nwritten = m_file->write(*this, data, size);
+    int nwritten = m_file->write(*this, offset(), data, size);
     if (nwritten > 0 && m_file->is_seekable())
         m_current_offset += nwritten;
     return nwritten;
@@ -150,12 +150,12 @@ ssize_t FileDescription::write(const u8* data, ssize_t size)
 
 bool FileDescription::can_write() const
 {
-    return m_file->can_write(*this);
+    return m_file->can_write(*this, offset());
 }
 
 bool FileDescription::can_read() const
 {
-    return m_file->can_read(*this);
+    return m_file->can_read(*this, offset());
 }
 
 ByteBuffer FileDescription::read_entire_file()

Kernel/FileSystem/InodeFile.cpp

@@ -44,17 +44,17 @@ InodeFile::~InodeFile()
 {
 }
 
-ssize_t InodeFile::read(FileDescription& description, u8* buffer, ssize_t count)
+ssize_t InodeFile::read(FileDescription& description, size_t offset, u8* buffer, ssize_t count)
 {
-    ssize_t nread = m_inode->read_bytes(description.offset(), count, buffer, &description);
+    ssize_t nread = m_inode->read_bytes(offset, count, buffer, &description);
     if (nread > 0)
         Thread::current->did_file_read(nread);
     return nread;
 }
 
-ssize_t InodeFile::write(FileDescription& description, const u8* data, ssize_t count)
+ssize_t InodeFile::write(FileDescription& description, size_t offset, const u8* data, ssize_t count)
 {
-    ssize_t nwritten = m_inode->write_bytes(description.offset(), count, data, &description);
+    ssize_t nwritten = m_inode->write_bytes(offset, count, data, &description);
     if (nwritten > 0) {
         m_inode->set_mtime(kgettimeofday().tv_sec);
         Thread::current->did_file_write(nwritten);

Kernel/FileSystem/InodeFile.h

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

Kernel/FileSystem/InodeWatcher.cpp

@@ -47,17 +47,17 @@ InodeWatcher::~InodeWatcher()
         safe_inode->unregister_watcher({}, *this);
 }
 
-bool InodeWatcher::can_read(const FileDescription&) const
+bool InodeWatcher::can_read(const FileDescription&, size_t) const
 {
     return !m_queue.is_empty() || !m_inode;
 }
 
-bool InodeWatcher::can_write(const FileDescription&) const
+bool InodeWatcher::can_write(const FileDescription&, size_t) const
 {
     return true;
 }
 
-ssize_t InodeWatcher::read(FileDescription&, u8* buffer, ssize_t buffer_size)
+ssize_t InodeWatcher::read(FileDescription&, size_t, u8* buffer, ssize_t buffer_size)
 {
     ASSERT(!m_queue.is_empty() || !m_inode);
 
@@ -71,7 +71,7 @@ ssize_t InodeWatcher::read(FileDescription&, u8* buffer, ssize_t buffer_size)
     return sizeof(event);
 }
 
-ssize_t InodeWatcher::write(FileDescription&, const u8*, ssize_t)
+ssize_t InodeWatcher::write(FileDescription&, size_t, const u8*, ssize_t)
 {
     return -EIO;
 }

Kernel/FileSystem/InodeWatcher.h

@@ -49,10 +49,10 @@ public:
         Type type { Type::Invalid };
     };
 
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
     virtual String absolute_path(const FileDescription&) const override;
     virtual const char* class_name() const override { return "InodeWatcher"; };
 

Kernel/Net/IPv4Socket.cpp

@@ -168,7 +168,7 @@ void IPv4Socket::detach(FileDescription&)
 {
 }
 
-bool IPv4Socket::can_read(const FileDescription&) const
+bool IPv4Socket::can_read(const FileDescription&, size_t) const
 {
     if (m_role == Role::Listener)
         return can_accept();
@@ -177,7 +177,7 @@ bool IPv4Socket::can_read(const FileDescription&) const
     return m_can_read;
 }
 
-bool IPv4Socket::can_write(const FileDescription&) const
+bool IPv4Socket::can_write(const FileDescription&, size_t) const
 {
     return is_connected();
 }

Kernel/Net/IPv4Socket.h

@@ -56,8 +56,8 @@ public:
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
     virtual void attach(FileDescription&) override;
     virtual void detach(FileDescription&) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
     virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
     virtual KResult setsockopt(int level, int option, const void*, socklen_t) override;

Kernel/Net/LocalSocket.cpp

@@ -227,7 +227,7 @@ void LocalSocket::detach(FileDescription& description)
     }
 }
 
-bool LocalSocket::can_read(const FileDescription& description) const
+bool LocalSocket::can_read(const FileDescription& description, size_t) const
 {
     auto role = this->role(description);
     if (role == Role::Listener)
@@ -249,7 +249,7 @@ bool LocalSocket::has_attached_peer(const FileDescription& description) const
     ASSERT_NOT_REACHED();
 }
 
-bool LocalSocket::can_write(const FileDescription& description) const
+bool LocalSocket::can_write(const FileDescription& description, size_t) const
 {
     auto role = this->role(description);
     if (role == Role::Accepted)
@@ -298,7 +298,7 @@ ssize_t LocalSocket::recvfrom(FileDescription& description, void* buffer, size_t
                 return 0;
             return -EAGAIN;
         }
-    } else if (!can_read(description)) {
+    } else if (!can_read(description, 0)) {
         auto result = Thread::current->block<Thread::ReadBlocker>(description);
         if (result != Thread::BlockResult::WokeNormally)
             return -EINTR;

Kernel/Net/LocalSocket.h

@@ -55,8 +55,8 @@ public:
     virtual void get_peer_address(sockaddr*, socklen_t*) override;
     virtual void attach(FileDescription&) override;
     virtual void detach(FileDescription&) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual ssize_t sendto(FileDescription&, const void*, size_t, int, const sockaddr*, socklen_t) override;
     virtual ssize_t recvfrom(FileDescription&, void*, size_t, int flags, sockaddr*, socklen_t*) override;
     virtual KResult getsockopt(FileDescription&, int level, int option, void*, socklen_t*) override;

Kernel/Net/Socket.cpp

@@ -176,14 +176,14 @@ KResult Socket::getsockopt(FileDescription&, int level, int option, void* value,
     }
 }
 
-ssize_t Socket::read(FileDescription& description, u8* buffer, ssize_t size)
+ssize_t Socket::read(FileDescription& description, size_t, u8* buffer, ssize_t size)
 {
     if (is_shut_down_for_reading())
         return 0;
     return recvfrom(description, buffer, size, 0, nullptr, 0);
 }
 
-ssize_t Socket::write(FileDescription& description, const u8* data, ssize_t size)
+ssize_t Socket::write(FileDescription& description, size_t, const u8* data, ssize_t size)
 {
     if (is_shut_down_for_writing())
         return -EPIPE;

Kernel/Net/Socket.h

@@ -124,8 +124,8 @@ public:
     Lock& lock() { return m_lock; }
 
     // ^File
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override final;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override final;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override final;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override final;
     virtual String absolute_path(const FileDescription&) const override = 0;
 
     bool has_receive_timeout() const { return m_receive_timeout.tv_sec || m_receive_timeout.tv_usec; }

Kernel/TTY/MasterPTY.cpp

@@ -59,14 +59,14 @@ String MasterPTY::pts_name() const
     return m_pts_name;
 }
 
-ssize_t MasterPTY::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t MasterPTY::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     if (!m_slave && m_buffer.is_empty())
         return 0;
     return m_buffer.read(buffer, size);
 }
 
-ssize_t MasterPTY::write(FileDescription&, const u8* buffer, ssize_t size)
+ssize_t MasterPTY::write(FileDescription&, size_t, const u8* buffer, ssize_t size)
 {
     if (!m_slave)
         return -EIO;
@@ -74,14 +74,14 @@ ssize_t MasterPTY::write(FileDescription&, const u8* buffer, ssize_t size)
     return size;
 }
 
-bool MasterPTY::can_read(const FileDescription&) const
+bool MasterPTY::can_read(const FileDescription&, size_t) const
 {
     if (!m_slave)
         return true;
     return !m_buffer.is_empty();
 }
 
-bool MasterPTY::can_write(const FileDescription&) const
+bool MasterPTY::can_write(const FileDescription&, size_t) const
 {
     return true;
 }

Kernel/TTY/MasterPTY.h

@@ -50,10 +50,10 @@ public:
 
 private:
     // ^CharacterDevice
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual void close() override;
     virtual bool is_master_pty() const override { return true; }
     virtual int ioctl(FileDescription&, unsigned request, unsigned arg) override;

Kernel/TTY/PTYMultiplexer.h

@@ -44,10 +44,10 @@ public:
 
     // ^CharacterDevice
     virtual KResultOr<NonnullRefPtr<FileDescription>> open(int options) override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override { return 0; }
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override { return 0; }
-    virtual bool can_read(const FileDescription&) const override { return true; }
-    virtual bool can_write(const FileDescription&) const override { return true; }
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override { return 0; }
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override { return 0; }
+    virtual bool can_read(const FileDescription&, size_t) const override { return true; }
+    virtual bool can_write(const FileDescription&, size_t) const override { return true; }
 
     void notify_master_destroyed(Badge<MasterPTY>, unsigned index);
 

Kernel/TTY/SlavePTY.cpp

@@ -76,23 +76,23 @@ ssize_t SlavePTY::on_tty_write(const u8* data, ssize_t size)
     return m_master->on_slave_write(data, size);
 }
 
-bool SlavePTY::can_write(const FileDescription&) const
+bool SlavePTY::can_write(const FileDescription&, size_t) const
 {
     return m_master->can_write_from_slave();
 }
 
-bool SlavePTY::can_read(const FileDescription& description) const
+bool SlavePTY::can_read(const FileDescription& description, size_t offset) const
 {
     if (m_master->is_closed())
         return true;
-    return TTY::can_read(description);
+    return TTY::can_read(description, offset);
 }
 
-ssize_t SlavePTY::read(FileDescription& description, u8* buffer, ssize_t size)
+ssize_t SlavePTY::read(FileDescription& description, size_t offset, u8* buffer, ssize_t size)
 {
     if (m_master->is_closed())
         return 0;
-    return TTY::read(description, buffer, size);
+    return TTY::read(description, offset, buffer, size);
 }
 
 void SlavePTY::close()

Kernel/TTY/SlavePTY.h

@@ -47,9 +47,9 @@ private:
     virtual void echo(u8) override;
 
     // ^CharacterDevice
-    virtual bool can_read(const FileDescription&) const override;
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual const char* class_name() const override { return "SlavePTY"; }
     virtual void close() override;
 

Kernel/TTY/TTY.cpp

@@ -52,7 +52,7 @@ void TTY::set_default_termios()
     memcpy(m_termios.c_cc, default_cc, sizeof(default_cc));
 }
 
-ssize_t TTY::read(FileDescription&, u8* buffer, ssize_t size)
+ssize_t TTY::read(FileDescription&, size_t, u8* buffer, ssize_t size)
 {
     ASSERT(size >= 0);
 
@@ -85,7 +85,7 @@ ssize_t TTY::read(FileDescription&, u8* buffer, ssize_t size)
     return size;
 }
 
-ssize_t TTY::write(FileDescription&, const u8* buffer, ssize_t size)
+ssize_t TTY::write(FileDescription&, size_t, const u8* buffer, ssize_t size)
 {
 #ifdef TTY_DEBUG
     dbg() << "TTY::write {" << String::format("%u", size) << "} ";
@@ -98,7 +98,7 @@ ssize_t TTY::write(FileDescription&, const u8* buffer, ssize_t size)
     return size;
 }
 
-bool TTY::can_read(const FileDescription&) const
+bool TTY::can_read(const FileDescription&, size_t) const
 {
     if (in_canonical_mode()) {
         return m_available_lines > 0;
@@ -106,7 +106,7 @@ bool TTY::can_read(const FileDescription&) const
     return !m_input_buffer.is_empty();
 }
 
-bool TTY::can_write(const FileDescription&) const
+bool TTY::can_write(const FileDescription&, size_t) const
 {
     return true;
 }

Kernel/TTY/TTY.h

@@ -39,10 +39,10 @@ class TTY : public CharacterDevice {
 public:
     virtual ~TTY() override;
 
-    virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
-    virtual bool can_read(const FileDescription&) const override;
-    virtual bool can_write(const FileDescription&) const override;
+    virtual ssize_t read(FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(FileDescription&, size_t, const u8*, ssize_t) override;
+    virtual bool can_read(const FileDescription&, size_t) const override;
+    virtual bool can_write(const FileDescription&, size_t) const override;
     virtual int ioctl(FileDescription&, unsigned request, unsigned arg) override final;
     virtual String absolute_path(const FileDescription&) const override { return tty_name(); }
 

Libraries/LibBareMetal/Output/Console.cpp

@@ -57,19 +57,19 @@ Console::~Console()
 }
 
 #if defined(KERNEL)
-bool Console::can_read(const Kernel::FileDescription&) const
+bool Console::can_read(const Kernel::FileDescription&, size_t) const
 {
     return false;
 }
 
-ssize_t Console::read(Kernel::FileDescription&, u8*, ssize_t)
+ssize_t Console::read(Kernel::FileDescription&, size_t, u8*, ssize_t)
 {
     // FIXME: Implement reading from the console.
     //        Maybe we could use a ring buffer for this device?
     return 0;
 }
 
-ssize_t Console::write(Kernel::FileDescription&, const u8* data, ssize_t size)
+ssize_t Console::write(Kernel::FileDescription&, size_t, const u8* data, ssize_t size)
 {
     if (!size)
         return 0;

Libraries/LibBareMetal/Output/Console.h

@@ -57,10 +57,10 @@ public:
 
 #if defined(KERNEL)
     // ^CharacterDevice
-    virtual bool can_read(const Kernel::FileDescription&) const override;
-    virtual bool can_write(const Kernel::FileDescription&) const override { return true; }
-    virtual ssize_t read(Kernel::FileDescription&, u8*, ssize_t) override;
-    virtual ssize_t write(Kernel::FileDescription&, const u8*, ssize_t) override;
+    virtual bool can_read(const Kernel::FileDescription&, size_t) const override;
+    virtual bool can_write(const Kernel::FileDescription&, size_t) const override { return true; }
+    virtual ssize_t read(Kernel::FileDescription&, size_t, u8*, ssize_t) override;
+    virtual ssize_t write(Kernel::FileDescription&, size_t, const u8*, ssize_t) override;
     virtual const char* class_name() const override { return "Console"; }
 #endif
     void set_implementation(ConsoleImplementation* implementation)