* cygerrno.h (__set_errno): Modify debugging output to make searching strace
logs easier. Throughout, change /dev/tty* to /dev/pty*. Throughout, add flags argument to fhandler_*::dup methods. * devices.in: Rename (temporarily?) /dev/ttyN to /dev/ptyN. Add /dev/ptymN devices for pty masters. * devices.cc: Regenerate. * devices.h (MAX_CONSOLES): Set to max number supported by devices.in. (fh_devices::FH_PTMX): Rename from FH_PTYM. (device::operator int): Return by reference. * dtable.cc (fh_alloc): Take pc as an argument rather than just the device. This makes debugging easier since more information is available. Actually implement handling for already-allocated pty master devices. Make different decisions when generating fhandler for not-opened devices. Add kludge to deal with opening /dev/tty. (cnew_no_ctor): New macro. (build_fh_pc): Make debugging output more verbose. Use new clone() fhandler interface to duplicate archetypes. Reset last term opened. (dtable::dup_worker): Use Use new clone() fhandler interface to duplicate archetypes. Pass flags to child dup handler. (dtable::dup3): Set O_NOCTTY flag if newfd is not stdin/stdout/stderr. * fhandler.cc (fhandler_base::reset): Rename from operator =() and reduce functionality and sense of copy direction. (fhandler_base::open_with_arch): Use published interface to query io_handle(). Use new copyto() fhandler method to copy from/to found archetype. * fhandler.h: Throughout, delete size(), add copyout, clone, and fhandler_* (void *) methods. (fhandler_base::reset): Rename from operator =(). (fhandler_termios::is_dev_tty): Delete. (fhandler_termios): change "protected" region to "private". (fhandler_termios::is_dev_tty): Delete. (fhandler_termios): Rearrange protected/public. (fhandler_termios::fhandler_termios): Remember last fhandler_termios "opened". (fhandler_termios::~fhandler_termios): Forget last fhandler_termios opened. (ioctl): Rename from ioctl_termios. Take a void * argument. Reflect argument change in pinfo::set_ctty. (fhandler_console::dup): Declare new function. Set ctty here if appropriate. (fhandler_pty_master::from_master): Privatize. (fhandler_pty_master::to_master): Ditto. (fhandler_pty_master::dwProcessId): Ditto. (fhandler_pty_master::fhandler_pty_master): Add an `int' argument. (fhandler_pty_master::open_setup): Declare new function. (fhandler_pty_master::~fhandler_pty_master): Declare new method. (fhandler_nodevice): Remove commented out function declaration. * fhandler_console.cc: Use get_ttyp() instead of tc() throughout. (fhandler_console::dup): Define new function to set controlling ctty on dup, as appropriate. (fhandler_console::ioctl): Reflect ioctl_termios name change. (fhandler_console::setup): Rename from get_tty_stuff. (fhandler_console::open_setup): Reflect argument change in pinfo::set_ctty. (fhandler_console::fhandler_console): Set _tc here. * fhandler_termios.cc (handler_termios::ioctl): Rename. Take a void * arg like other ioctl functions. * fhandler_tty.cc (fhandler_pty_slave::dup): Call myself->set_ctty to potentially reset the controlling terminal. (fhandler_pty_slave::ioctl): Reflect name/arg change for ioctl_termios. (fhandler_pty_slave::fhandler_pty_slave): Take a "unit" argument. Call setup() here so that we will know the unit number of this fhandler as soon as possible. Set the unit as appropriate. (handler_pty_master::open): Move most stuff to constructor and open_setup. (handler_pty_slave::open_setup): Reflect argument change in pinfo::set_ctty. (handler_pty_master::open_setup): Define new function. (fhandler_pty_master::cleanup): Clear handles as a flag that the destructor does not have to do "close" operations. (fhandler_pty_master::close): Ditto. (fhandler_pty_master::~fhandler_pty_master): Define new method. (fhandler_pty_master::ioctl): Reflect name/arg change for ioctl_termios. (fhandler_pty_master::setup): Allocate tty here. Rely on handles being returned from allocated test rather than opening them here. Avoid setting _need_nl here since it is already zeroed in the constructor. Set up device information with DEV_TTYM_MAJOR. * path.h (path_conv &operator =): Take a const argument. (path_conv::dup): Ditto. (pathconv_arg::PC_OPEN): New enum. (pathconv_arg::PC_CTTY): Ditto. (path_types::PATH_CTTY): Ditto. (path_types::PATH_OPEN): Ditto. (path_conv::isopen): New method. (path_conv::isctty_capable): Ditto. * path.cc (path_conv::check): Set PATH_OPEN and PATH_CTTY as appropriate. * pipe.cc (fhandler_pipe::open): Use copyto to copy pipe handle. * syscall.cc (open): Reinstate fd > 2 check to disallow resetting ctty on non-std* handles. * tty.cc (tty_list::allocate): Pass out handles for allocated tty. use `not_allocated' to find unallocated ttys. Avoid keeping the lock since the allocation of the tty should be sufficient to prevent multiple access. (tty::not_allocated): Clarify comment. Rename. Return handles when an unused tty is found. Simply test for existing tty. (tty::exists): Rewrite to use `not_allocated'. * tty.h (NTTYS): Reset down to actual number supported by devices.in. (tty::not_allocated): Declare new function. (tty_list::allocate): Pass out read/write tty handles. Zero them when not found. * fhandler_proc.cc: Reflect name change from FH_PTYM -> FH_PTMX. * pinfo.h (pinfo::set_ctty): Reduce/reorder arguments passed in. * pinfo.cc (pinfo::set_ctty): Ditto. Just use tc() built into the passed-in fhandler_termios pointer. Return true if ctty is assigned. * syscalls.cc (open): Call build_fh_pc with PC_OPEN flag. Set PC_CTTY if appropriate. (stat_worker): Remove is_dev_tty () stuff.
This commit is contained in:
@@ -113,7 +113,7 @@ dtable::get_debugger_info ()
|
||||
extern bool jit_debug;
|
||||
if (!jit_debug && being_debugged ())
|
||||
{
|
||||
char std[3][sizeof ("/dev/ttyNNNN")];
|
||||
char std[3][sizeof ("/dev/ptyNNNN")];
|
||||
std[0][0] = std[1][0] = std [2][0] = '\0';
|
||||
char buf[sizeof ("cYgstd %x") + 32];
|
||||
sprintf (buf, "cYgstd %x %x %x", (unsigned) &std, sizeof (std[0]), 3);
|
||||
@@ -401,6 +401,12 @@ dtable::init_std_file_from_handle (int fd, HANDLE handle)
|
||||
ptr ? new (ptr) name (__VA_ARGS__) : NULL; \
|
||||
})
|
||||
|
||||
#define cnew_no_ctor(name, ...) \
|
||||
({ \
|
||||
void* ptr = (void*) ccalloc (HEAP_FHANDLER, 1, sizeof (name)); \
|
||||
ptr ? new (ptr) name (ptr) : NULL; \
|
||||
})
|
||||
|
||||
fhandler_base *
|
||||
build_fh_name (const char *name, unsigned opt, suffix_info *si)
|
||||
{
|
||||
@@ -429,15 +435,20 @@ build_fh_dev (const device& dev, const char *unix_name)
|
||||
}
|
||||
|
||||
#define fh_unset ((fhandler_base *) 1)
|
||||
|
||||
static fhandler_base *
|
||||
fh_alloc (device dev)
|
||||
fh_alloc (path_conv& pc)
|
||||
{
|
||||
fhandler_base *fh = fh_unset;
|
||||
fhandler_base *fhraw = NULL;
|
||||
|
||||
switch (dev.get_major ())
|
||||
switch (pc.dev.get_major ())
|
||||
{
|
||||
case DEV_TTYS_MAJOR:
|
||||
fh = cnew (fhandler_pty_slave, dev.get_minor ());
|
||||
fh = cnew (fhandler_pty_slave, pc.dev.get_minor ());
|
||||
break;
|
||||
case DEV_TTYM_MAJOR:
|
||||
fh = cnew (fhandler_pty_master, pc.dev.get_minor ());
|
||||
break;
|
||||
case DEV_CYGDRIVE_MAJOR:
|
||||
fh = cnew (fhandler_cygdrive);
|
||||
@@ -461,18 +472,21 @@ fh_alloc (device dev)
|
||||
fh = cnew (fhandler_serial);
|
||||
break;
|
||||
case DEV_CONS_MAJOR:
|
||||
fh = cnew (fhandler_console, dev);
|
||||
fh = cnew (fhandler_console, pc.dev);
|
||||
break;
|
||||
default:
|
||||
switch ((int) dev)
|
||||
switch ((int) pc.dev)
|
||||
{
|
||||
case FH_CONSOLE:
|
||||
case FH_CONIN:
|
||||
case FH_CONOUT:
|
||||
fh = cnew (fhandler_console, dev);
|
||||
fh = cnew (fhandler_console, pc.dev);
|
||||
break;
|
||||
case FH_PTYM:
|
||||
fh = cnew (fhandler_pty_master);
|
||||
case FH_PTMX:
|
||||
if (pc.isopen ())
|
||||
fh = cnew (fhandler_pty_master, -1);
|
||||
else
|
||||
fhraw = cnew_no_ctor (fhandler_pty_master, -1);
|
||||
break;
|
||||
case FH_WINDOWS:
|
||||
fh = cnew (fhandler_windows);
|
||||
@@ -540,40 +554,52 @@ fh_alloc (device dev)
|
||||
fh = cnew (fhandler_netdrive);
|
||||
break;
|
||||
case FH_TTY:
|
||||
{
|
||||
if (myself->ctty > 0)
|
||||
{
|
||||
if (iscons_dev (myself->ctty))
|
||||
fh = cnew (fhandler_console, dev);
|
||||
else
|
||||
fh = cnew (fhandler_pty_slave, myself->ctty);
|
||||
}
|
||||
((fhandler_termios *) fh)->is_dev_tty (true);
|
||||
break;
|
||||
}
|
||||
if (!pc.isopen ())
|
||||
fhraw = cnew_no_ctor (fhandler_console, -1);
|
||||
else if (myself->ctty <= 0
|
||||
&& !myself->set_ctty (fhandler_termios::last, 0))
|
||||
/* no tty assigned */;
|
||||
else if (iscons_dev (myself->ctty))
|
||||
fh = cnew (fhandler_console, pc.dev);
|
||||
else
|
||||
fh = cnew (fhandler_pty_slave, myself->ctty);
|
||||
break;
|
||||
case FH_KMSG:
|
||||
fh = cnew (fhandler_mailslot);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If `fhraw' is set that means that this fhandler is just a dummy
|
||||
set up for stat(). Mock it up for use by stat without actually
|
||||
trying to do any real initialization. */
|
||||
if (fhraw)
|
||||
{
|
||||
fh = fhraw;
|
||||
fh->set_name (pc);
|
||||
if (fh->use_archetype ())
|
||||
fh->archetype = fh;
|
||||
}
|
||||
if (fh == fh_unset)
|
||||
fh = cnew (fhandler_nodevice);
|
||||
else if (fh->dev () == FH_ERROR)
|
||||
{
|
||||
delete fh;
|
||||
fh = NULL;
|
||||
}
|
||||
return fh;
|
||||
}
|
||||
|
||||
fhandler_base *
|
||||
build_fh_pc (path_conv& pc, bool set_name)
|
||||
{
|
||||
fhandler_base *fh = fh_alloc (pc.dev);
|
||||
fhandler_base *fh = fh_alloc (pc);
|
||||
|
||||
if (!fh)
|
||||
{
|
||||
set_errno (EMFILE);
|
||||
set_errno (ENXIO);
|
||||
goto out;
|
||||
}
|
||||
else if (fh->dev () == FH_ERROR)
|
||||
goto out;
|
||||
else if (fh->dev () != FH_NADA)
|
||||
fh->set_name (fh->dev ().name);
|
||||
else if (set_name)
|
||||
@@ -582,18 +608,25 @@ build_fh_pc (path_conv& pc, bool set_name)
|
||||
if (!fh->use_archetype ())
|
||||
/* doesn't use archetypes */;
|
||||
else if ((fh->archetype = cygheap->fdtab.find_archetype (fh->dev ())))
|
||||
debug_printf ("found an archetype for %s(%d/%d)", fh->get_name (), fh->dev ().get_major (), fh->dev ().get_minor ());
|
||||
debug_printf ("found an archetype for %s(%d/%d) io_handle %p", fh->get_name (), fh->dev ().get_major (), fh->dev ().get_minor (),
|
||||
fh->archetype->get_io_handle ());
|
||||
else
|
||||
{
|
||||
debug_printf ("creating an archetype for %s(%d/%d)", fh->get_name (), fh->dev ().get_major (), fh->dev ().get_minor ());
|
||||
fh->archetype = fh_alloc (fh->pc.dev);
|
||||
*fh->archetype = *fh;
|
||||
fh->archetype = fh->clone ();
|
||||
debug_printf ("created an archetype (%p) for %s(%d/%d)", fh->archetype, fh->get_name (), fh->dev ().get_major (), fh->dev ().get_minor ());
|
||||
fh->archetype->archetype = NULL;
|
||||
*cygheap->fdtab.add_archetype () = fh->archetype;
|
||||
}
|
||||
|
||||
/* The fhandler_termios constructor keeps track of the last tty-like thing
|
||||
opened but we're only interested in this if we don't have a controlling
|
||||
terminal since we could potentially want to open it if /dev/tty is
|
||||
referenced. */
|
||||
if (myself->ctty > 0 || !fh->is_tty () || !pc.isctty_capable ())
|
||||
fhandler_termios::last = NULL;
|
||||
|
||||
out:
|
||||
debug_printf ("fh %p", fh);
|
||||
debug_printf ("fh %p, dev %p", fh, (DWORD) fh->dev ());
|
||||
return fh;
|
||||
}
|
||||
|
||||
@@ -603,16 +636,16 @@ dtable::dup_worker (fhandler_base *oldfh, int flags)
|
||||
/* Don't call set_name in build_fh_pc. It will be called in
|
||||
fhandler_base::operator= below. Calling it twice will result
|
||||
in double allocation. */
|
||||
fhandler_base *newfh = build_fh_pc (oldfh->pc, false);
|
||||
fhandler_base *newfh = oldfh->clone ();
|
||||
if (!newfh)
|
||||
debug_printf ("build_fh_pc failed");
|
||||
else
|
||||
{
|
||||
*newfh = *oldfh;
|
||||
if (!oldfh->archetype)
|
||||
newfh->set_io_handle (NULL);
|
||||
|
||||
newfh->pc.reset_conv_handle ();
|
||||
if (oldfh->dup (newfh))
|
||||
if (oldfh->dup (newfh, flags))
|
||||
{
|
||||
delete newfh;
|
||||
newfh = NULL;
|
||||
@@ -625,6 +658,14 @@ dtable::dup_worker (fhandler_base *oldfh, int flags)
|
||||
/* The O_CLOEXEC flag enforces close-on-exec behaviour. */
|
||||
newfh->set_close_on_exec (!!(flags & O_CLOEXEC));
|
||||
debug_printf ("duped '%s' old %p, new %p", oldfh->get_name (), oldfh->get_io_handle (), newfh->get_io_handle ());
|
||||
#ifdef DEBUGGING
|
||||
debug_printf ("duped output_handles old %p, new %p",
|
||||
oldfh->get_output_handle (),
|
||||
newfh->get_output_handle ());
|
||||
debug_printf ("duped output_handles archetype old %p, archetype new %p",
|
||||
oldfh->archetype->get_output_handle (),
|
||||
newfh->archetype->get_output_handle ());
|
||||
#endif /*DEBUGGING*/
|
||||
}
|
||||
}
|
||||
return newfh;
|
||||
@@ -659,6 +700,13 @@ dtable::dup3 (int oldfd, int newfd, int flags)
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This is a temporary kludge until all utilities can catch up with
|
||||
a change in behavior that implements linux functionality: opening
|
||||
a tty should not automatically cause it to become the controlling
|
||||
tty for the process. */
|
||||
if (newfd > 2)
|
||||
flags |= O_NOCTTY;
|
||||
|
||||
if ((newfh = dup_worker (fds[oldfd], flags)) == NULL)
|
||||
{
|
||||
res = -1;
|
||||
@@ -817,7 +865,7 @@ static void
|
||||
decode_tty (char *buf, WCHAR *w32)
|
||||
{
|
||||
int ttyn = wcstol (w32, NULL, 10);
|
||||
__small_sprintf (buf, "/dev/tty%d", ttyn);
|
||||
__small_sprintf (buf, "/dev/pty%d", ttyn);
|
||||
}
|
||||
|
||||
/* Try to derive posix filename from given handle. Return true if
|
||||
|
Reference in New Issue
Block a user