Kernel: Have File virtuals take a FileDescriptor& rather than a Process&.

This will allow us to implement different behaviors depending on the role
of the descriptor a File is being accessed through.

Kernel/FileSystem/FIFO.cpp

@@ -81,17 +81,17 @@ void FIFO::detach(Direction direction)
     }
 }
 
-bool FIFO::can_read(Process&) const
+bool FIFO::can_read(FileDescriptor&) const
 {
     return !m_buffer.is_empty() || !m_writers;
 }
 
-bool FIFO::can_write(Process&) const
+bool FIFO::can_write(FileDescriptor&) const
 {
     return m_buffer.bytes_in_write_buffer() < 4096;
 }
 
-ssize_t FIFO::read(Process&, byte* buffer, ssize_t size)
+ssize_t FIFO::read(FileDescriptor&, byte* buffer, ssize_t size)
 {
     if (!m_writers && m_buffer.is_empty())
         return 0;
@@ -105,7 +105,7 @@ ssize_t FIFO::read(Process&, byte* buffer, ssize_t size)
     return nread;
 }
 
-ssize_t FIFO::write(Process&, const byte* buffer, ssize_t size)
+ssize_t FIFO::write(FileDescriptor&, const byte* buffer, ssize_t size)
 {
     if (!m_readers)
         return 0;

Kernel/FileSystem/FIFO.h

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

Kernel/FileSystem/FileDescriptor.cpp

@@ -173,10 +173,10 @@ off_t FileDescriptor::seek(off_t offset, int whence)
     return m_current_offset;
 }
 
-ssize_t FileDescriptor::read(Process& process, byte* buffer, ssize_t count)
+ssize_t FileDescriptor::read(byte* buffer, ssize_t count)
 {
     if (m_file) {
-        int nread = m_file->read(process, buffer, count);
+        int nread = m_file->read(*this, buffer, count);
         if (!m_file->is_seekable())
             m_current_offset += nread;
         return nread;
@@ -189,10 +189,10 @@ ssize_t FileDescriptor::read(Process& process, byte* buffer, ssize_t count)
     return nread;
 }
 
-ssize_t FileDescriptor::write(Process& process, const byte* data, ssize_t size)
+ssize_t FileDescriptor::write(const byte* data, ssize_t size)
 {
     if (m_file) {
-        int nwritten = m_file->write(process, data, size);
+        int nwritten = m_file->write(*this, data, size);
         if (m_file->is_seekable())
             m_current_offset += nwritten;
         return nwritten;
@@ -205,25 +205,25 @@ ssize_t FileDescriptor::write(Process& process, const byte* data, ssize_t size)
     return nwritten;
 }
 
-bool FileDescriptor::can_write(Process& process)
+bool FileDescriptor::can_write()
 {
     if (m_file)
-        return m_file->can_write(process);
+        return m_file->can_write(*this);
     if (m_socket)
         return m_socket->can_write(m_socket_role);
     return true;
 }
 
-bool FileDescriptor::can_read(Process& process)
+bool FileDescriptor::can_read()
 {
     if (m_file)
-        return m_file->can_read(process);
+        return m_file->can_read(*this);
     if (m_socket)
         return m_socket->can_read(m_socket_role);
     return true;
 }
 
-ByteBuffer FileDescriptor::read_entire_file(Process& process)
+ByteBuffer FileDescriptor::read_entire_file()
 {
     // HACK ALERT: (This entire function)
 
@@ -231,7 +231,7 @@ ByteBuffer FileDescriptor::read_entire_file(Process& process)
 
     if (m_file) {
         auto buffer = ByteBuffer::create_uninitialized(1024);
-        ssize_t nread = m_file->read(process, buffer.pointer(), buffer.size());
+        ssize_t nread = m_file->read(*this, buffer.pointer(), buffer.size());
         ASSERT(nread >= 0);
         buffer.trim(nread);
         return buffer;

Kernel/FileSystem/FileDescriptor.h

@@ -30,18 +30,18 @@ public:
     int close();
 
     off_t seek(off_t, int whence);
-    ssize_t read(Process&, byte*, ssize_t);
-    ssize_t write(Process&, const byte* data, ssize_t);
+    ssize_t read(byte*, ssize_t);
+    ssize_t write(const byte* data, ssize_t);
     KResult fstat(stat&);
 
     KResult fchmod(mode_t);
 
-    bool can_read(Process&);
-    bool can_write(Process&);
+    bool can_read();
+    bool can_write();
 
     ssize_t get_dir_entries(byte* buffer, ssize_t);
 
-    ByteBuffer read_entire_file(Process&);
+    ByteBuffer read_entire_file();
 
     KResultOr<String> absolute_path();