[lldb][NFC] Inclusive language: replace master/slave names for ptys

[quinnp]

Summary

[NFC] This patch replaces master and slave with primary and secondary
respectively when referring to pseudoterminals/file descriptors.

[teemperor]

LGTM, thanks!

lldb/source/Plugins/Platform/MacOSX/objcxx/PlatformiOSSimulatorCoreSimulatorSupport.mm

if (file_action) {
     case FileAction::eFileActionDuplicate:
       error.SetErrorStringWithFormat(
           "duplication file action for %i not supported", fd);
       break;
 
     case FileAction::eFileActionOpen: {
       FileSpec file_spec = file_action->GetFileSpec();
       if (file_spec) {
-        const int master_fd = launch_info.GetPTY().GetPrimaryFileDescriptor();
-        if (master_fd != PseudoTerminal::invalid_fd) {
+        const int primary_fd = launch_info.GetPTY().GetPrimaryFileDescriptor();
+        if (primary_fd != PseudoTerminal::invalid_fd) {
           // Check in case our file action open wants to open the secondary
           FileSpec secondary_spec(launch_info.GetPTY().GetSecondaryName());
           if (file_spec == secondary_spec) {
             int secondary_fd =
                 launch_info.GetPTY().GetSecondaryFileDescriptor();
             if (secondary_fd == PseudoTerminal::invalid_fd) {
               if (llvm::Error Err = launch_info.GetPTY().OpenSecondary(O_RDWR))
                 return Status(std::move(Err));

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

NativeProcessWindows::Factory::Launch(
   return std::move(process_up);
 }
 
 llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
 NativeProcessWindows::Factory::Attach(
     lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate,
     MainLoop &mainloop) const {
   Error E = Error::success();
-  // Set pty master fd invalid since it is not available.
+  // Set pty primary fd invalid since it is not available.
   auto process_up = std::unique_ptr<NativeProcessWindows>(
       new NativeProcessWindows(pid, -1, native_delegate, E));
   if (E)
     return std::move(E);
   return std::move(process_up);
 }
 } // namespace lldb_private

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

#endif
   // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol as
   // needed. llgs local-process debugging may specify PTY paths, which will
   // make these file actions non-null process launch -i/e/o will also make
   // these file actions non-null nullptr means that the traffic is expected to
   // flow over gdb-remote protocol
   if (should_forward_stdio) {
     // nullptr means it's not redirected to file or pty (in case of LLGS local)
     // at least one of stdio will be transferred pty<->gdb-remote we need to
-    // give the pty master handle to this object to read and/or write
+    // give the pty primary handle to this object to read and/or write
     LLDB_LOG(log,
              "pid = {0}: setting up stdout/stderr redirection via $O "
              "gdb-remote commands",
              m_current_process->GetID());
 
     // Setup stdout/stderr mapping from inferior to $O
     auto terminal_fd = m_current_process->GetTerminalFileDescriptor();
     if (terminal_fd >= 0) {

lldb/source/Target/Platform.cpp

if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
         // Since we attached to the process, it will think it needs to detach
         // if the process object just goes away without an explicit call to
         // Process::Kill() or Process::Detach(), so let it know to kill the
         // process if this happens.
         process_sp->SetShouldDetach(false);
 
         // If we didn't have any file actions, the pseudo terminal might have
         // been used where the secondary side was given as the file to open for
-        // stdin/out/err after we have already opened the master so we can
+        // stdin/out/err after we have already opened the primary so we can
         // read/write stdin/out/err.
         int pty_fd = launch_info.GetPTY().ReleasePrimaryFileDescriptor();
         if (pty_fd != PseudoTerminal::invalid_fd) {
           process_sp->SetSTDIOFileDescriptor(pty_fd);
         }
       } else {
         LLDB_LOGF(log, "Platform::%s Attach() failed: %s", __FUNCTION__,
                   error.AsCString());

lldb/source/Target/Process.cpp

bool Interrupt() override {
     return false;
   }
 
   void GotEOF() override {}
 
 protected:
   Process *m_process;
   NativeFile m_read_file;  // Read from this file (usually actual STDIN for LLDB
-  NativeFile m_write_file; // Write to this file (usually the master pty for
+  NativeFile m_write_file; // Write to this file (usually the primary pty for
                            // getting io to debuggee)
   Pipe m_pipe;
   std::atomic<bool> m_is_running{false};
 };
 
 void Process::SetSTDIOFileDescriptor(int fd) {
   // First set up the Read Thread for reading/handling process I/O
   m_stdio_communication.SetConnection(

lldb/test/API/functionalities/gdb_remote_client/TestPty.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 @skipIfWindows
 class TestPty(GDBRemoteTestBase):
     mydir = TestBase.compute_mydir(__file__)
     server_socket_class = PtyServerSocket
 
     def get_term_attrs(self):
         import termios
-        return termios.tcgetattr(self.server._socket._slave)
+        return termios.tcgetattr(self.server._socket._secondary)
 
     def setUp(self):
         super().setUp()
         self.orig_attr = self.get_term_attrs()
 
     def assert_raw_mode(self, current_attr):
         import termios
         self.assertEqual(current_attr[0] & (termios.BRKINT |

lldb/test/API/functionalities/gdb_remote_client/gdbclientutils.py

def sendall(self, data):
         assert self._connection is not None
         return self._connection.sendall(data)
 
 
 class PtyServerSocket(ServerSocket):
     def __init__(self):
         import pty
         import tty
-        master, slave = pty.openpty()
-        tty.setraw(master)
-        self._master = io.FileIO(master, 'r+b')
-        self._slave = io.FileIO(slave, 'r+b')
+        primary, secondary = pty.openpty()
+        tty.setraw(primary)
+        self._primary = io.FileIO(primary, 'r+b')
+        self._secondary = io.FileIO(secondary, 'r+b')
 
     def get_connect_address(self):
         libc = ctypes.CDLL(None)
         libc.ptsname.argtypes = (ctypes.c_int,)
         libc.ptsname.restype = ctypes.c_char_p
-        return libc.ptsname(self._master.fileno()).decode()
+        return libc.ptsname(self._primary.fileno()).decode()
 
     def get_connect_url(self):
         return "serial://" + self.get_connect_address()
 
     def close_server(self):
-        self._slave.close()
-        self._master.close()
+        self._secondary.close()
+        self._primary.close()
 
     def recv(self):
         try:
-            return self._master.read(4096)
+            return self._primary.read(4096)
         except OSError as e:
             # closing the pty results in EIO on Linux, convert it to EOF
             if e.errno == errno.EIO:
                 return b''
             raise
 
     def sendall(self, data):
-        return self._master.write(data)
+        return self._primary.write(data)
 
 
 class MockGDBServer:
     """
     A simple TCP-based GDB server that can test client behavior by receiving
     commands and issuing custom-tailored responses.
 
     Responses are generated via the .responder property, which should be an

lldb/test/API/tools/lldb-server/TestPtyServer.py

 @skipIfWindows
 class PtyServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         super().setUp()
         import pty
         import tty
-        master, slave = pty.openpty()
-        tty.setraw(master)
-        self._master = io.FileIO(master, 'r+b')
-        self._slave = io.FileIO(slave, 'r+b')
+        primary, secondary = pty.openpty()
+        tty.setraw(primary)
+        self._primary = io.FileIO(primary, 'r+b')
+        self._secondary = io.FileIO(secondary, 'r+b')
 
     def get_debug_monitor_command_line_args(self, attach_pid=None):
         commandline_args = self.debug_monitor_extra_args
         if attach_pid:
             commandline_args += ["--attach=%d" % attach_pid]
 
         libc = ctypes.CDLL(None)
         libc.ptsname.argtypes = (ctypes.c_int,)
         libc.ptsname.restype = ctypes.c_char_p
-        pty_path = libc.ptsname(self._master.fileno()).decode()
+        pty_path = libc.ptsname(self._primary.fileno()).decode()
         commandline_args += ["serial://%s" % (pty_path,)]
         return commandline_args
 
     def connect_to_debug_monitor(self, attach_pid=None):
         self.reverse_connect = False
         server = self.launch_debug_monitor(attach_pid=attach_pid)
         self.assertIsNotNone(server)
 
         # TODO: make it into proper abstraction
         class FakeSocket:
             def __init__(self, fd):
                 self.fd = fd
 
             def sendall(self, frame):
                 self.fd.write(frame)
 
             def recv(self, count):
                 return self.fd.read(count)
 
-        self.sock = FakeSocket(self._master)
+        self.sock = FakeSocket(self._primary)
         self._server = Server(self.sock, server)
         return server
 
     @add_test_categories(["llgs"])
     def test_pty_server(self):
         self.build()
         self.set_inferior_startup_launch()
         self.prep_debug_monitor_and_inferior()

lldb/third_party/Python/module/ptyprocess-0.6.0/ptyprocess/ptyprocess.py

def spawn(
 
         if use_native_pty_fork:
             pid, fd = pty.fork()
         else:
             # Use internal fork_pty, for Solaris
             pid, fd = _fork_pty.fork_pty()
 
         # Some platforms must call setwinsize() and setecho() from the
-        # child process, and others from the master process. We do both,
+        # child process, and others from the primary process. We do both,
         # allowing IOError for either.
 
         if pid == CHILD:
             # set window size
             try:
                 _setwinsize(STDIN_FILENO, *dimensions)
             except IOError as err:
                 if err.args[0] not in (errno.EINVAL, errno.ENOTTY):

lldb/unittests/Editline/EditlineTest.cpp

 
 private:
   bool IsInputComplete(lldb_private::Editline *editline,
                        lldb_private::StringList &lines);
 
   std::unique_ptr<lldb_private::Editline> _editline_sp;
 
   PseudoTerminal _pty;
-  int _pty_master_fd;
+  int _pty_primary_fd;
   int _pty_secondary_fd;
 
   std::unique_ptr<FilePointer> _el_secondary_file;
 };
 
 EditlineAdapter::EditlineAdapter()
-    : _editline_sp(), _pty(), _pty_master_fd(-1), _pty_secondary_fd(-1),
+    : _editline_sp(), _pty(), _pty_primary_fd(-1), _pty_secondary_fd(-1),
       _el_secondary_file() {
   lldb_private::Status error;
 
-  // Open the first master pty available.
+  // Open the first primary pty available.
   EXPECT_THAT_ERROR(_pty.OpenFirstAvailablePrimary(O_RDWR), llvm::Succeeded());
 
-  // Grab the master fd.  This is a file descriptor we will:
+  // Grab the primary fd.  This is a file descriptor we will:
   // (1) write to when we want to send input to editline.
   // (2) read from when we want to see what editline sends back.
-  _pty_master_fd = _pty.GetPrimaryFileDescriptor();
+  _pty_primary_fd = _pty.GetPrimaryFileDescriptor();
 
   // Open the corresponding secondary pty.
   EXPECT_THAT_ERROR(_pty.OpenSecondary(O_RDWR), llvm::Succeeded());
   _pty_secondary_fd = _pty.GetSecondaryFileDescriptor();
 
   _el_secondary_file.reset(new FilePointer(fdopen(_pty_secondary_fd, "rw")));
   EXPECT_FALSE(nullptr == *_el_secondary_file);
   if (*_el_secondary_file == nullptr)

 
 bool EditlineAdapter::SendLine(const std::string &line) {
   // Ensure we're valid before proceeding.
   if (!IsValid())
     return false;
 
   // Write the line out to the pipe connected to editline's input.
   ssize_t input_bytes_written =
-      ::write(_pty_master_fd, line.c_str(),
+      ::write(_pty_primary_fd, line.c_str(),
               line.length() * sizeof(std::string::value_type));
 
   const char *eoln = "\n";
   const size_t eoln_length = strlen(eoln);
   input_bytes_written =
-      ::write(_pty_master_fd, eoln, eoln_length * sizeof(char));
+      ::write(_pty_primary_fd, eoln, eoln_length * sizeof(char));
 
   EXPECT_NE(-1, input_bytes_written) << strerror(errno);
   EXPECT_EQ(eoln_length * sizeof(char), size_t(input_bytes_written));
   return eoln_length * sizeof(char) == size_t(input_bytes_written);
 }
 
 bool EditlineAdapter::SendLines(const std::vector<std::string> &lines) {
   for (auto &line : lines) {
for (auto ch : line) {
         --brace_balance;
     }
   }
 
   return (start_block_count > 0) && (brace_balance == 0);
 }
 
 void EditlineAdapter::ConsumeAllOutput() {
-  FilePointer output_file(fdopen(_pty_master_fd, "r"));
+  FilePointer output_file(fdopen(_pty_primary_fd, "r"));
 
   int ch;
   while ((ch = fgetc(output_file)) != EOF) {
 #if EDITLINE_TEST_DUMP_OUTPUT
     char display_str[] = {0, 0, 0};
     switch (ch) {
     case '\t':
       display_str[0] = '\\';