ladybird/Kernel/Syscalls/ioctl.cpp

/*
 * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <Kernel/FileSystem/FileDescription.h>
#include <Kernel/Process.h>
#include <LibC/sys/ioctl_numbers.h>

namespace Kernel {

KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)
{
    VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)
    auto description = fds().file_description(fd);
    if (!description)
        return EBADF;
    if (request == FIONBIO) {
        description->set_blocking(arg == 0);
        return KSuccess;
    }
    return description->file().ioctl(*description, request, arg);
}

}
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00			`/*`
			`* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>`
			`*`
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt * 2021-04-22 08:24:48 +00:00			`* SPDX-License-Identifier: BSD-2-Clause`
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00			`*/`

			`#include <Kernel/FileSystem/FileDescription.h>`
			`#include <Kernel/Process.h>`
Kernel+LibC: Implement sys$ioctl() FIONBIO This is another (older) way of making a file descriptor non-blocking. 2021-03-28 15:50:08 +00:00			`#include <LibC/sys/ioctl_numbers.h>`
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00
			`namespace Kernel {`

Kernel: Fix the return type for syscalls The Process::Handler type has KResultOr<FlatPtr> as its return type. Using a different return type with an equally-sized template parameter sort of works but breaks once that condition is no longer true, e.g. for KResultOr<int> on x86_64. Ideally the syscall handlers would also take FlatPtrs as their args so we can get rid of the reinterpret_cast for the function pointer but I didn't quite feel like cleaning that up as well. 2021-06-28 18:59:35 +00:00			`KResultOr<FlatPtr> Process::sys$ioctl(int fd, unsigned request, FlatPtr arg)`
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00			`{`
Kernel: Annotate all syscalls with VERIFY_PROCESS_BIG_LOCK_ACQUIRED Before we start disabling acquisition of the big process lock for specific syscalls, make sure to document and assert that all the lock is held during all syscalls. 2021-07-18 18:20:12 +00:00			`VERIFY_PROCESS_BIG_LOCK_ACQUIRED(this)`
Kernel: Don't copy a Vector<FileDescriptionAndFlags> Instead of copying a Vector everytime we need to enumerate a Process' file descriptions, we can just temporarily lock so it won't change. 2021-06-22 18:22:17 +00:00			`auto description = fds().file_description(fd);`
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00			`if (!description)`
Kernel: Make all syscall functions return KResultOr<T> This makes it a lot easier to return errors since we no longer have to worry about negating EFOO errors and can just return them flat. 2021-03-01 12:49:16 +00:00			`return EBADF;`
Kernel: Let's allow unsetting non-blocking mode with FIONBIO as well Thanks to almightyhydra for pointing this out! :^) 2021-03-29 06:57:11 +00:00			`if (request == FIONBIO) {`
Kernel: Let's also not reverse the blocking flag for FIONBIO.. 2021-03-29 06:59:22 +00:00			`description->set_blocking(arg == 0);`
Kernel+LibC: Implement sys$ioctl() FIONBIO This is another (older) way of making a file descriptor non-blocking. 2021-03-28 15:50:08 +00:00			`return KSuccess;`
			`}`
Kernel: Move syscall implementations out of Process.cpp This is something I've been meaning to do for a long time, and here we finally go. This patch moves all sys$foo functions out of Process.cpp and into files in Kernel/Syscalls/. It's not exactly one syscall per file (although it could be, but I got a bit tired of the repetitive work here..) This makes hacking on individual syscalls a lot less painful since you don't have to rebuild nearly as much code every time. I'm also hopeful that this makes it easier to understand individual syscalls. :^) 2020-07-30 21:38:15 +00:00			`return description->file().ioctl(*description, request, arg);`
			`}`

			`}`