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 SmapDisabler disabler;
80 if (is_fifo()) {
81 memset(&buffer, 0, sizeof(buffer));
82 buffer.st_mode = 001000;
83 return KSuccess;
84 }
85 if (is_socket()) {
86 memset(&buffer, 0, sizeof(buffer));
87 buffer.st_mode = 0140000;
88 return KSuccess;
89 }
90
91 if (!m_inode)
92 return KResult(-EBADF);
93 return metadata().stat(buffer);
94}
95
96off_t FileDescription::seek(off_t offset, int whence)
97{
98 LOCKER(m_lock);
99 if (!m_file->is_seekable())
100 return -EINVAL;
101
102 auto metadata = this->metadata();
103 if (!metadata.is_valid())
104 return -EIO;
105
106 if (metadata.is_socket() || metadata.is_fifo())
107 return -ESPIPE;
108
109 off_t new_offset;
110
111 switch (whence) {
112 case SEEK_SET:
113 new_offset = offset;
114 break;
115 case SEEK_CUR:
116 new_offset = m_current_offset + offset;
117 break;
118 case SEEK_END:
119 new_offset = metadata.size;
120 break;
121 default:
122 return -EINVAL;
123 }
124
125 if (new_offset < 0)
126 return -EINVAL;
127 // FIXME: Return -EINVAL if attempting to seek past the end of a seekable device.
128
129 m_current_offset = new_offset;
130 return m_current_offset;
131}
132
133ssize_t FileDescription::read(u8* buffer, ssize_t count)
134{
135 LOCKER(m_lock);
136 if ((m_current_offset + count) < 0)
137 return -EOVERFLOW;
138 SmapDisabler disabler;
139 int nread = m_file->read(*this, buffer, count);
140 if (nread > 0 && m_file->is_seekable())
141 m_current_offset += nread;
142 return nread;
143}
144
145ssize_t FileDescription::write(const u8* data, ssize_t size)
146{
147 LOCKER(m_lock);
148 if ((m_current_offset + size) < 0)
149 return -EOVERFLOW;
150 SmapDisabler disabler;
151 int nwritten = m_file->write(*this, data, size);
152 if (nwritten > 0 && m_file->is_seekable())
153 m_current_offset += nwritten;
154 return nwritten;
155}
156
157bool FileDescription::can_write() const
158{
159 return m_file->can_write(*this);
160}
161
162bool FileDescription::can_read() const
163{
164 return m_file->can_read(*this);
165}
166
167ByteBuffer FileDescription::read_entire_file()
168{
169 // HACK ALERT: (This entire function)
170 ASSERT(m_file->is_inode());
171 ASSERT(m_inode);
172 return m_inode->read_entire(this);
173}
174
175ssize_t FileDescription::get_dir_entries(u8* buffer, ssize_t size)
176{
177 LOCKER(m_lock);
178 if (!is_directory())
179 return -ENOTDIR;
180
181 auto metadata = this->metadata();
182 if (!metadata.is_valid())
183 return -EIO;
184
185 if (size < 0)
186 return -EINVAL;
187
188 size_t size_to_allocate = max(PAGE_SIZE, metadata.size);
189
190 auto temp_buffer = ByteBuffer::create_uninitialized(size_to_allocate);
191 BufferStream stream(temp_buffer);
192 VFS::the().traverse_directory_inode(*m_inode, [&stream](auto& entry) {
193 stream << (u32)entry.inode.index();
194 stream << (u8)entry.file_type;
195 stream << (u32)entry.name_length;
196 stream << entry.name;
197 return true;
198 });
199 stream.snip();
200
201 if (static_cast<size_t>(size) < temp_buffer.size())
202 return -EINVAL;
203
204 copy_to_user(buffer, temp_buffer.data(), temp_buffer.size());
205 return stream.offset();
206}
207
208bool FileDescription::is_device() const
209{
210 return m_file->is_device();
211}
212
213const Device* FileDescription::device() const
214{
215 if (!is_device())
216 return nullptr;
217 return static_cast<const Device*>(m_file.ptr());
218}
219
220Device* FileDescription::device()
221{
222 if (!is_device())
223 return nullptr;
224 return static_cast<Device*>(m_file.ptr());
225}
226
227bool FileDescription::is_tty() const
228{
229 return m_file->is_tty();
230}
231
232const TTY* FileDescription::tty() const
233{
234 if (!is_tty())
235 return nullptr;
236 return static_cast<const TTY*>(m_file.ptr());
237}
238
239TTY* FileDescription::tty()
240{
241 if (!is_tty())
242 return nullptr;
243 return static_cast<TTY*>(m_file.ptr());
244}
245
246bool FileDescription::is_master_pty() const
247{
248 return m_file->is_master_pty();
249}
250
251const MasterPTY* FileDescription::master_pty() const
252{
253 if (!is_master_pty())
254 return nullptr;
255 return static_cast<const MasterPTY*>(m_file.ptr());
256}
257
258MasterPTY* FileDescription::master_pty()
259{
260 if (!is_master_pty())
261 return nullptr;
262 return static_cast<MasterPTY*>(m_file.ptr());
263}
264
265int FileDescription::close()
266{
267 return 0;
268}
269
270String FileDescription::absolute_path() const
271{
272 if (m_custody)
273 return m_custody->absolute_path();
274 return m_file->absolute_path(*this);
275}
276
277InodeMetadata FileDescription::metadata() const
278{
279 if (m_inode)
280 return m_inode->metadata();
281 return {};
282}
283
284KResultOr<Region*> FileDescription::mmap(Process& process, VirtualAddress vaddr, size_t offset, size_t size, int prot)
285{
286 LOCKER(m_lock);
287 return m_file->mmap(process, *this, vaddr, offset, size, prot);
288}
289
290KResult FileDescription::truncate(u64 length)
291{
292 LOCKER(m_lock);
293 return m_file->truncate(length);
294}
295
296bool FileDescription::is_fifo() const
297{
298 return m_file->is_fifo();
299}
300
301FIFO* FileDescription::fifo()
302{
303 if (!is_fifo())
304 return nullptr;
305 return static_cast<FIFO*>(m_file.ptr());
306}
307
308bool FileDescription::is_socket() const
309{
310 return m_file->is_socket();
311}
312
313Socket* FileDescription::socket()
314{
315 if (!is_socket())
316 return nullptr;
317 return static_cast<Socket*>(m_file.ptr());
318}
319
320const Socket* FileDescription::socket() const
321{
322 if (!is_socket())
323 return nullptr;
324 return static_cast<const Socket*>(m_file.ptr());
325}
326
327void FileDescription::set_file_flags(u32 flags)
328{
329 LOCKER(m_lock);
330 m_is_blocking = !(flags & O_NONBLOCK);
331 m_should_append = flags & O_APPEND;
332 m_direct = flags & O_DIRECT;
333 m_file_flags = flags;
334}
335
336KResult FileDescription::chmod(mode_t mode)
337{
338 LOCKER(m_lock);
339 return m_file->chmod(mode);
340}
341
342KResult FileDescription::chown(uid_t uid, gid_t gid)
343{
344 LOCKER(m_lock);
345 return m_file->chown(uid, gid);
346}
347
348}