jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this
9 * list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice,
12 * this list of conditions and the following disclaimer in the documentation
13 * and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
21 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
22 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include <AK/BufferStream.h>
28#include <Kernel/Devices/BlockDevice.h>
29#include <Kernel/Devices/CharacterDevice.h>
30#include <Kernel/FileSystem/Custody.h>
31#include <Kernel/FileSystem/FIFO.h>
32#include <Kernel/FileSystem/FileDescription.h>
33#include <Kernel/FileSystem/FileSystem.h>
34#include <Kernel/FileSystem/InodeFile.h>
35#include <Kernel/Net/Socket.h>
36#include <Kernel/Process.h>
37#include <Kernel/TTY/MasterPTY.h>
38#include <Kernel/TTY/TTY.h>
39#include <Kernel/UnixTypes.h>
40#include <Kernel/VM/MemoryManager.h>
41#include <LibC/errno_numbers.h>
42
43namespace Kernel {
44
45NonnullRefPtr<FileDescription> FileDescription::create(Custody& custody)
46{
47 auto description = adopt(*new FileDescription(InodeFile::create(custody.inode())));
48 description->m_custody = custody;
49 return description;
50}
51
52NonnullRefPtr<FileDescription> FileDescription::create(File& file)
53{
54 return adopt(*new FileDescription(file));
55}
56
57FileDescription::FileDescription(File& file)
58 : m_file(file)
59{
60 if (file.is_inode())
61 m_inode = static_cast<InodeFile&>(file).inode();
62 if (is_socket())
63 socket()->attach(*this);
64 m_is_directory = metadata().is_directory();
65}
66
67FileDescription::~FileDescription()
68{
69 if (is_socket())
70 socket()->detach(*this);
71 if (is_fifo())
72 static_cast<FIFO*>(m_file.ptr())->detach(m_fifo_direction);
73 m_file->close();
74 m_inode = nullptr;
75}
76
77KResult FileDescription::fstat(stat& buffer)
78{
79 if (is_fifo()) {
80 memset(&buffer, 0, sizeof(buffer));
81 buffer.st_mode = 001000;
82 return KSuccess;
83 }
84 if (is_socket()) {
85 memset(&buffer, 0, sizeof(buffer));
86 buffer.st_mode = 0140000;
87 return KSuccess;
88 }
89
90 if (!m_inode)
91 return KResult(-EBADF);
92 return metadata().stat(buffer);
93}
94
95off_t FileDescription::seek(off_t offset, int whence)
96{
97 LOCKER(m_lock);
98 if (!m_file->is_seekable())
99 return -EINVAL;
100
101 off_t new_offset;
102
103 switch (whence) {
104 case SEEK_SET:
105 new_offset = offset;
106 break;
107 case SEEK_CUR:
108 new_offset = m_current_offset + offset;
109 break;
110 case SEEK_END:
111 if (!metadata().is_valid())
112 return -EIO;
113 new_offset = metadata().size;
114 break;
115 default:
116 return -EINVAL;
117 }
118
119 if (new_offset < 0)
120 return -EINVAL;
121 // FIXME: Return -EINVAL if attempting to seek past the end of a seekable device.
122
123 m_current_offset = new_offset;
124 return m_current_offset;
125}
126
127ssize_t FileDescription::read(u8* buffer, ssize_t count)
128{
129 LOCKER(m_lock);
130 if ((m_current_offset + count) < 0)
131 return -EOVERFLOW;
132 SmapDisabler disabler;
133 int nread = m_file->read(*this, buffer, count);
134 if (nread > 0 && m_file->is_seekable())
135 m_current_offset += nread;
136 return nread;
137}
138
139ssize_t FileDescription::write(const u8* data, ssize_t size)
140{
141 LOCKER(m_lock);
142 if ((m_current_offset + size) < 0)
143 return -EOVERFLOW;
144 SmapDisabler disabler;
145 int nwritten = m_file->write(*this, data, size);
146 if (nwritten > 0 && m_file->is_seekable())
147 m_current_offset += nwritten;
148 return nwritten;
149}
150
151bool FileDescription::can_write() const
152{
153 return m_file->can_write(*this);
154}
155
156bool FileDescription::can_read() const
157{
158 return m_file->can_read(*this);
159}
160
161ByteBuffer FileDescription::read_entire_file()
162{
163 // HACK ALERT: (This entire function)
164 ASSERT(m_file->is_inode());
165 ASSERT(m_inode);
166 return m_inode->read_entire(this);
167}
168
169ssize_t FileDescription::get_dir_entries(u8* buffer, ssize_t size)
170{
171 LOCKER(m_lock);
172 if (!is_directory())
173 return -ENOTDIR;
174
175 auto metadata = this->metadata();
176 if (!metadata.is_valid())
177 return -EIO;
178
179 if (size < 0)
180 return -EINVAL;
181
182 size_t size_to_allocate = max(PAGE_SIZE, metadata.size);
183
184 auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
185 BufferStream stream(temp_buffer);
186 VFS::the().traverse_directory_inode(*m_inode, [&stream](auto& entry) {
187 stream << (u32)entry.inode.index();
188 stream << (u8)entry.file_type;
189 stream << (u32)entry.name_length;
190 stream << entry.name;
191 return true;
192 });
193 stream.snip();
194
195 if (static_cast<size_t>(size) < temp_buffer.size())
196 return -EINVAL;
197
198 copy_to_user(buffer, temp_buffer.data(), temp_buffer.size());
199 return stream.offset();
200}
201
202bool FileDescription::is_device() const
203{
204 return m_file->is_device();
205}
206
207const Device* FileDescription::device() const
208{
209 if (!is_device())
210 return nullptr;
211 return static_cast<const Device*>(m_file.ptr());
212}
213
214Device* FileDescription::device()
215{
216 if (!is_device())
217 return nullptr;
218 return static_cast<Device*>(m_file.ptr());
219}
220
221bool FileDescription::is_tty() const
222{
223 return m_file->is_tty();
224}
225
226const TTY* FileDescription::tty() const
227{
228 if (!is_tty())
229 return nullptr;
230 return static_cast<const TTY*>(m_file.ptr());
231}
232
233TTY* FileDescription::tty()
234{
235 if (!is_tty())
236 return nullptr;
237 return static_cast<TTY*>(m_file.ptr());
238}
239
240bool FileDescription::is_master_pty() const
241{
242 return m_file->is_master_pty();
243}
244
245const MasterPTY* FileDescription::master_pty() const
246{
247 if (!is_master_pty())
248 return nullptr;
249 return static_cast<const MasterPTY*>(m_file.ptr());
250}
251
252MasterPTY* FileDescription::master_pty()
253{
254 if (!is_master_pty())
255 return nullptr;
256 return static_cast<MasterPTY*>(m_file.ptr());
257}
258
259int FileDescription::close()
260{
261 return 0;
262}
263
264String FileDescription::absolute_path() const
265{
266 if (m_custody)
267 return m_custody->absolute_path();
268 return m_file->absolute_path(*this);
269}
270
271InodeMetadata FileDescription::metadata() const
272{
273 if (m_inode)
274 return m_inode->metadata();
275 return {};
276}
277
278KResultOr<Region*> FileDescription::mmap(Process& process, VirtualAddress vaddr, size_t offset, size_t size, int prot, bool shared)
279{
280 LOCKER(m_lock);
281 return m_file->mmap(process, *this, vaddr, offset, size, prot, shared);
282}
283
284KResult FileDescription::truncate(u64 length)
285{
286 LOCKER(m_lock);
287 return m_file->truncate(length);
288}
289
290bool FileDescription::is_fifo() const
291{
292 return m_file->is_fifo();
293}
294
295FIFO* FileDescription::fifo()
296{
297 if (!is_fifo())
298 return nullptr;
299 return static_cast<FIFO*>(m_file.ptr());
300}
301
302bool FileDescription::is_socket() const
303{
304 return m_file->is_socket();
305}
306
307Socket* FileDescription::socket()
308{
309 if (!is_socket())
310 return nullptr;
311 return static_cast<Socket*>(m_file.ptr());
312}
313
314const Socket* FileDescription::socket() const
315{
316 if (!is_socket())
317 return nullptr;
318 return static_cast<const Socket*>(m_file.ptr());
319}
320
321void FileDescription::set_file_flags(u32 flags)
322{
323 LOCKER(m_lock);
324 m_is_blocking = !(flags & O_NONBLOCK);
325 m_should_append = flags & O_APPEND;
326 m_direct = flags & O_DIRECT;
327 m_file_flags = flags;
328}
329
330KResult FileDescription::chmod(mode_t mode)
331{
332 LOCKER(m_lock);
333 return m_file->chmod(mode);
334}
335
336KResult FileDescription::chown(uid_t uid, gid_t gid)
337{
338 LOCKER(m_lock);
339 return m_file->chown(uid, gid);
340}
341
342}