RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 20:58:11 +00:00
Code Issues Activity Actions

Kernel: Remove various other uses of ssize_t

Browse source
This commit is contained in:
Gunnar Beutner 2021-06-16 16:44:15 +02:00 • committed by Andreas Kling
parent ca3cae81eb
commit bc3076f894
33 changed files with 123 additions and 129 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Kernel/Syscalls/anon_create.cpp
View file

@ -21,6 +21,9 @@ KResultOr<int> Process::sys$anon_create(size_t size, int options)
if (size % PAGE_SIZE)
return EINVAL;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
int new_fd = alloc_fd();
if (new_fd < 0)
return new_fd;

3
Kernel/Syscalls/chdir.cpp
View file

@ -45,6 +45,9 @@ KResultOr<int> Process::sys$getcwd(Userspace<char*> buffer, size_t size)
{
REQUIRE_PROMISE(rpath);
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
auto path = current_directory().absolute_path();
size_t ideal_size = path.length() + 1;

11
Kernel/Syscalls/debug.cpp
View file

@ -23,15 +23,18 @@ KResultOr<int> Process::sys$dbgputch(u8 ch)
return 0;
}
KResultOr<size_t> Process::sys$dbgputstr(Userspace<const u8*> characters, int length)
KResultOr<size_t> Process::sys$dbgputstr(Userspace<const u8*> characters, size_t size)
{
if (length <= 0)
if (size <= 0)
return 0;
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, length);
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
auto buffer = UserOrKernelBuffer::for_user_buffer(characters, size);
if (!buffer.has_value())
return EFAULT;
return buffer.value().read_buffered<1024>(length, [&](u8 const* buffer, size_t buffer_size) {
return buffer.value().read_buffered<1024>(size, [&](u8 const* buffer, size_t buffer_size) {
for (size_t i = 0; i < buffer_size; ++i)
IO::out8(IO::BOCHS_DEBUG_PORT, buffer[i]);
return buffer_size;

4
Kernel/Syscalls/get_dir_entries.cpp
View file

@ -9,10 +9,10 @@
namespace Kernel {
KResultOr<ssize_t> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, ssize_t user_size)
KResultOr<size_t> Process::sys$get_dir_entries(int fd, Userspace<void*> user_buffer, size_t user_size)
{
REQUIRE_PROMISE(stdio);
if (user_size < 0)
if (user_size > NumericLimits<ssize_t>::max())
return EINVAL;
auto description = file_description(fd);
if (!description)

2
Kernel/Syscalls/getrandom.cpp
View file

@ -16,7 +16,7 @@ namespace Kernel {
KResultOr<size_t> Process::sys$getrandom(Userspace<void*> buffer, size_t buffer_size, [[maybe_unused]] unsigned flags)
{
REQUIRE_PROMISE(stdio);
if (buffer_size <= 0)
if (buffer_size > NumericLimits<ssize_t>::max())
return EINVAL;
auto data_buffer = UserOrKernelBuffer::for_user_buffer(buffer, buffer_size);

6
Kernel/Syscalls/getuid.cpp
View file

@ -48,14 +48,12 @@ KResultOr<int> Process::sys$getresgid(Userspace<gid_t*> rgid, Userspace<gid_t*>
return 0;
}
KResultOr<int> Process::sys$getgroups(ssize_t count, Userspace<gid_t*> user_gids)
KResultOr<int> Process::sys$getgroups(size_t count, Userspace<gid_t*> user_gids)
{
REQUIRE_PROMISE(stdio);
if (count < 0)
return EINVAL;
if (!count)
return extra_gids().size();
if (count != (int)extra_gids().size())
if (count != extra_gids().size())
return EINVAL;
if (!copy_to_user(user_gids, extra_gids().data(), sizeof(gid_t) * count))

8
Kernel/Syscalls/hostname.cpp
View file

@ -11,10 +11,10 @@ namespace Kernel {
extern String* g_hostname;
extern Lock* g_hostname_lock;
KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, ssize_t size)
KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
Locker locker(*g_hostname_lock, Lock::Mode::Shared);
if ((size_t)size < (g_hostname->length() + 1))
@ -24,13 +24,11 @@ KResultOr<int> Process::sys$gethostname(Userspace<char*> buffer, ssize_t size)
return 0;
}
KResultOr<int> Process::sys$sethostname(Userspace<const char*> hostname, ssize_t length)
KResultOr<int> Process::sys$sethostname(Userspace<const char*> hostname, size_t length)
{
REQUIRE_NO_PROMISES;
if (!is_superuser())
return EPERM;
if (length < 0)
return EINVAL;
Locker locker(*g_hostname_lock, Lock::Mode::Exclusive);
if (length > 64)
return ENAMETOOLONG;

8
Kernel/Syscalls/read.cpp
View file

@ -12,7 +12,7 @@ namespace Kernel {
using BlockFlags = Thread::FileBlocker::BlockFlags;
KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
KResultOr<size_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
REQUIRE_PROMISE(stdio);
if (iov_count < 0)
@ -68,13 +68,13 @@ KResultOr<ssize_t> Process::sys$readv(int fd, Userspace<const struct iovec*> iov
return nread;
}
KResultOr<ssize_t> Process::sys$read(int fd, Userspace<u8*> buffer, ssize_t size)
KResultOr<size_t> Process::sys$read(int fd, Userspace<u8*> buffer, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
return EINVAL;
if (size == 0)
return 0;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
dbgln_if(IO_DEBUG, "sys$read({}, {}, {})", fd, buffer.ptr(), size);
auto description = file_description(fd);
if (!description)

4
Kernel/Syscalls/setuid.cpp
View file

@ -148,11 +148,9 @@ KResultOr<int> Process::sys$setresgid(gid_t new_rgid, gid_t new_egid, gid_t new_
return 0;
}
KResultOr<int> Process::sys$setgroups(ssize_t count, Userspace<const gid_t*> user_gids)
KResultOr<int> Process::sys$setgroups(size_t count, Userspace<const gid_t*> user_gids)
{
REQUIRE_PROMISE(id);
if (count < 0)
return EINVAL;
if (!is_superuser())
return EPERM;

11
Kernel/Syscalls/socket.cpp
View file

@ -179,7 +179,7 @@ KResultOr<int> Process::sys$shutdown(int sockfd, int how)
return socket.shutdown(how);
}
KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
KResultOr<size_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghdr*> user_msg, int flags)
{
REQUIRE_PROMISE(stdio);
struct msghdr msg;
@ -193,6 +193,8 @@ KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
return ENOMEM;
if (!copy_n_from_user(iovs.data(), msg.msg_iov, msg.msg_iovlen))
return EFAULT;
if (iovs[0].iov_len > NumericLimits<ssize_t>::max())
return EINVAL;
Userspace<const sockaddr*> user_addr((FlatPtr)msg.msg_name);
socklen_t addr_length = msg.msg_namelen;
@ -208,13 +210,10 @@ KResultOr<ssize_t> Process::sys$sendmsg(int sockfd, Userspace<const struct msghd
auto data_buffer = UserOrKernelBuffer::for_user_buffer((u8*)iovs[0].iov_base, iovs[0].iov_len);
if (!data_buffer.has_value())
return EFAULT;
auto result = socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
if (result.is_error())
return result.error();
return result.value();
return socket.sendto(*description, data_buffer.value(), iovs[0].iov_len, flags, user_addr, addr_length);
}
KResultOr<ssize_t> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
KResultOr<size_t> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user_msg, int flags)
{
REQUIRE_PROMISE(stdio);

12
Kernel/Syscalls/write.cpp
View file

@ -11,7 +11,7 @@
namespace Kernel {
KResultOr<ssize_t> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
KResultOr<size_t> Process::sys$writev(int fd, Userspace<const struct iovec*> iov, int iov_count)
{
REQUIRE_PROMISE(stdio);
if (iov_count < 0)
@ -57,9 +57,9 @@ KResultOr<ssize_t> Process::sys$writev(int fd, Userspace<const struct iovec*> io
return nwritten;
}
KResultOr<ssize_t> Process::do_write(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
KResultOr<size_t> Process::do_write(FileDescription& description, const UserOrKernelBuffer& data, size_t data_size)
{
ssize_t total_nwritten = 0;
size_t total_nwritten = 0;
if (description.should_append() && description.file().is_seekable()) {
auto seek_result = description.seek(0, SEEK_END);
@ -96,13 +96,13 @@ KResultOr<ssize_t> Process::do_write(FileDescription& description, const UserOrK
return total_nwritten;
}
KResultOr<ssize_t> Process::sys$write(int fd, Userspace<const u8*> data, ssize_t size)
KResultOr<size_t> Process::sys$write(int fd, Userspace<const u8*> data, size_t size)
{
REQUIRE_PROMISE(stdio);
if (size < 0)
return EINVAL;
if (size == 0)
return 0;
if (size > NumericLimits<ssize_t>::max())
return EINVAL;
dbgln_if(IO_DEBUG, "sys$write({}, {}, {})", fd, data.ptr(), size);
auto description = file_description(fd);