1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <Kernel/API/Ioctl.h>
#include <Kernel/API/POSIX/errno.h>
#include <Kernel/API/POSIX/signal_numbers.h>
#include <Kernel/Debug.h>
#include <Kernel/Interrupts/InterruptDisabler.h>
#include <Kernel/TTY/MasterPTY.h>
#include <Kernel/TTY/PTYMultiplexer.h>
#include <Kernel/TTY/SlavePTY.h>
#include <Kernel/Tasks/Process.h>
namespace Kernel {
ErrorOr<NonnullLockRefPtr<MasterPTY>> MasterPTY::try_create(unsigned int index)
{
auto buffer = TRY(DoubleBuffer::try_create("MasterPTY: Buffer"sv));
auto master_pty = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) MasterPTY(index, move(buffer))));
auto slave_pty = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) SlavePTY(*master_pty, index)));
master_pty->m_slave = slave_pty;
TRY(master_pty->after_inserting());
TRY(slave_pty->after_inserting());
return master_pty;
}
MasterPTY::MasterPTY(unsigned index, NonnullOwnPtr<DoubleBuffer> buffer)
: CharacterDevice(200, index)
, m_index(index)
, m_buffer(move(buffer))
{
auto& process = Process::current();
auto credentials = process.credentials();
set_uid(credentials->uid());
set_gid(credentials->gid());
m_buffer->set_unblock_callback([this]() {
if (m_slave)
evaluate_block_conditions();
});
}
MasterPTY::~MasterPTY()
{
dbgln_if(MASTERPTY_DEBUG, "~MasterPTY({})", m_index);
PTYMultiplexer::the().notify_master_destroyed({}, m_index);
}
ErrorOr<size_t> MasterPTY::read(OpenFileDescription&, u64, UserOrKernelBuffer& buffer, size_t size)
{
if (!m_slave && m_buffer->is_empty())
return 0;
return m_buffer->read(buffer, size);
}
ErrorOr<size_t> MasterPTY::write(OpenFileDescription&, u64, UserOrKernelBuffer const& buffer, size_t size)
{
if (!m_slave)
return EIO;
m_slave->on_master_write(buffer, size);
return size;
}
bool MasterPTY::can_read(OpenFileDescription const&, u64) const
{
if (!m_slave)
return true;
return !m_buffer->is_empty();
}
bool MasterPTY::can_write(OpenFileDescription const&, u64) const
{
return true;
}
void MasterPTY::notify_slave_closed(Badge<SlavePTY>)
{
dbgln_if(MASTERPTY_DEBUG, "MasterPTY({}): slave closed, my retains: {}, slave retains: {}", m_index, ref_count(), m_slave->ref_count());
// +1 ref for my MasterPTY::m_slave
// +1 ref for OpenFileDescription::m_device
if (m_slave->ref_count() == 2)
m_slave = nullptr;
}
ErrorOr<size_t> MasterPTY::on_slave_write(UserOrKernelBuffer const& data, size_t size)
{
if (m_closed)
return EIO;
return m_buffer->write(data, size);
}
bool MasterPTY::can_write_from_slave() const
{
if (m_closed)
return true;
return m_buffer->space_for_writing();
}
ErrorOr<void> MasterPTY::close()
{
InterruptDisabler disabler;
// After the closing OpenFileDescription dies, slave is the only thing keeping me alive.
// From this point, let's consider ourselves closed.
m_closed = true;
if (m_slave)
m_slave->hang_up();
return {};
}
ErrorOr<void> MasterPTY::ioctl(OpenFileDescription& description, unsigned request, Userspace<void*> arg)
{
TRY(Process::current().require_promise(Pledge::tty));
if (!m_slave)
return EIO;
switch (request) {
case TIOCGPTN: {
int master_pty_index = index();
return copy_to_user(static_ptr_cast<int*>(arg), &master_pty_index);
}
case TIOCSWINSZ:
case TIOCGPGRP:
return m_slave->ioctl(description, request, arg);
default:
return EINVAL;
}
}
ErrorOr<NonnullOwnPtr<KString>> MasterPTY::pseudo_path(OpenFileDescription const&) const
{
return KString::formatted("ptm:{}", m_index);
}
}
|
