JehanneOS/newlib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* child_info.h (child_info): Add pppid_handle for closing the parent's of the

Browse Source 
parent handle.
* dcrt0.cc (_dll_crt0): Close parent's parent handle when spawned or forked.
* debug.cc (add_handle): Correct erroneous reference to handle structure when
printing warning.
* exceptions.cc (interrupt_now): Always return 1.
(interrupt_on_return): Accept a sigthread argument.  Check to see if this
argument has been trashed prior to setting up the stack return.
(call_handler): Add a loop around attempts to dispatch signals to detect case
where interrupt_on_return fails.
(_sigdelayed): Set up a temporary frame pointer prior to calling stuff that
could trigger an interrupt or the stack walking code will be very confused.
* fork.cc (fork_parent): Move a lot of the setup of the child process into
proc_subproc.
* spawn.cc (spawn_guts): Ditto.  Use ppid_handle to contact logical parent when
reparenting.
* pinfo.h (_pinfo): Remember the logical handle of the parent process.
* sigproc.cc (proc_subproc): Record most stuff necessary for the _pinfo
structure that is inferrable from myself when adding children.
(wait_sig): Always set 'pending_signals' flag when about to kick off the signal
scanning loop.  Reset it only if there are no pending signals.
This commit is contained in:
Christopher Faylor 2000-11-06 06:36:32 +00:00
parent e0997f5a0f
commit dd11f11fae
9 changed files with 189 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
winsup/cygwin/ChangeLog
View File

@ -1,3 +1,30 @@
Mon Nov 6 01:04:35 2000 Christopher Faylor <cgf@cygnus.com>
* child_info.h (child_info): Add pppid_handle for closing the parent's
of the parent handle.
* dcrt0.cc (_dll_crt0): Close parent's parent handle when spawned or
forked.
* debug.cc (add_handle): Correct erroneous reference to handle
structure when printing warning.
* exceptions.cc (interrupt_now): Always return 1.
(interrupt_on_return): Accept a sigthread argument. Check to see if
this argument has been trashed prior to setting up the stack return.
(call_handler): Add a loop around attempts to dispatch signals to
detect case where interrupt_on_return fails.
(_sigdelayed): Set up a temporary frame pointer prior to calling stuff
that could trigger an interrupt or the stack walking code will be very
confused.
* fork.cc (fork_parent): Move a lot of the setup of the child process
into proc_subproc.
* spawn.cc (spawn_guts): Ditto. Use ppid_handle to contact logical
parent when reparenting.
* pinfo.h (_pinfo): Remember the logical handle of the parent process.
* sigproc.cc (proc_subproc): Record most stuff necessary for the _pinfo
structure that is inferrable from myself when adding children.
(wait_sig): Always set 'pending_signals' flag when about to kick off
the signal scanning loop. Reset it only if there are no pending
signals.
Sun Nov 5 13:46:23 2000 Christopher Faylor <cgf@cygnus.com>
* pinfo (wait_subproc): Son of neverending debug tweaking.

3
winsup/cygwin/child_info.h
View File

@ -12,7 +12,7 @@ details. */
enum
{
PROC_MAGIC = 0xaf09f000,
PROC_MAGIC = 0xaf0af000,
PROC_FORK = PROC_MAGIC + 1,
PROC_EXEC = PROC_MAGIC + 2,
PROC_SPAWN = PROC_MAGIC + 3,
@ -38,6 +38,7 @@ public:
HANDLE console_h;
HANDLE parent_alive; // handle of thread used to track children
HANDLE parent;
HANDLE pppid_handle;
void *cygheap;
void *cygheap_max;
};

3
winsup/cygwin/dcrt0.cc
View File

@ -898,8 +898,9 @@ _dll_crt0 ()
case PROC_FORK:
case PROC_FORK1:
user_data->forkee = fork_info->cygpid;
case PROC_EXEC:
case PROC_SPAWN:
CloseHandle (fork_info->pppid_handle);
case PROC_EXEC:
{
child_proc_info = fork_info;
mypid = child_proc_info->cygpid;

1
winsup/cygwin/debug.cc
View File

@ -248,6 +248,7 @@ add_handle (const char *func, int ln, HANDLE h, const char *name)
if ((hl = find_handle (h)))
{
hl = hl->next;
system_printf ("%s:%d - multiple attempts to add handle %s<%p>", func,
ln, name, h);
system_printf (" previously allocated by %s:%d(%s<%p>)",

77
winsup/cygwin/exceptions.cc
View File

@ -30,6 +30,7 @@ static int handle_exceptions (EXCEPTION_RECORD *, void *, CONTEXT *, void *);
extern void sigreturn ();
extern void sigdelayed ();
extern void siglast ();
extern DWORD __no_sig_start, __no_sig_end;
};
extern DWORD sigtid;
@ -627,12 +628,13 @@ interrupt_setup (int sig, struct sigaction& siga, void *handler,
sigsave.saved_errno = -1; // Flag: no errno to save
}
static void
static bool
interrupt_now (CONTEXT *ctx, int sig, struct sigaction& siga, void *handler)
{
interrupt_setup (sig, siga, handler, ctx->Eip, 0);
ctx->Eip = (DWORD) sigdelayed;
SetThreadContext (myself->getthread2signal (), ctx); /* Restart the thread */
return 1;
}
void __stdcall
@ -662,12 +664,13 @@ signal_fixup_after_exec (bool isspawn)
}
static int
interrupt_on_return (DWORD ebp, int sig, struct sigaction& siga, void *handler)
interrupt_on_return (sigthread *th, int sig, struct sigaction& siga, void *handler)
{
int i;
DWORD ebp = th->frame;
if (sigsave.sig)
return 0; /* Already have a signal stacked up */
if (!ebp)
return 0;
thestack.init (ebp); /* Initialize from the input CONTEXT */
for (i = 0; i < 32 && thestack++ ; i++)
@ -677,12 +680,16 @@ interrupt_on_return (DWORD ebp, int sig, struct sigaction& siga, void *handler)
if (*addr_retaddr == thestack.sf.AddrReturn.Offset)
{
interrupt_setup (sig, siga, handler, *addr_retaddr, addr_retaddr);
if (ebp != th->frame)
{
sigsave.sig = 0;
break;
}
*addr_retaddr = (DWORD) sigdelayed;
}
return 1;
}
api_fatal ("couldn't send signal %d", sig);
return 0;
}
@ -700,11 +707,10 @@ static int
call_handler (int sig, struct sigaction& siga, void *handler)
{
CONTEXT cx;
int interrupted = 1;
bool interrupted = 0;
HANDLE hth = NULL;
DWORD ebp;
int res;
int using_mainthread_frame;
sigthread *th;
#if 0
mainthread.lock->acquire ();
@ -713,15 +719,14 @@ call_handler (int sig, struct sigaction& siga, void *handler)
if (sigsave.sig)
goto set_pending;
if (mainthread.frame)
for (int i = 0; !interrupted && i < 10; i++)
{
ebp = mainthread.frame;
using_mainthread_frame = 1;
}
if (mainthread.frame)
th = &mainthread;
else
{
int i;
using_mainthread_frame = 0;
th = NULL;
#if 0
mainthread.lock->release ();
#endif
@ -742,6 +747,10 @@ call_handler (int sig, struct sigaction& siga, void *handler)
sigproc_printf ("suspending mainthread");
res = SuspendThread (hth);
/* Just set pending if thread is already suspended */
if (res)
goto set_pending;
muto *m;
/* FIXME: Make multi-thread aware */
for (m = muto_start.next; m != NULL; m = m->next)
@ -753,8 +762,7 @@ call_handler (int sig, struct sigaction& siga, void *handler)
#endif
if (mainthread.frame)
{
ebp = mainthread.frame; /* try to avoid a race */
using_mainthread_frame = 1;
th = &mainthread;
goto next;
}
#if 0
@ -778,9 +786,6 @@ call_handler (int sig, struct sigaction& siga, void *handler)
owns_muto:
sigproc_printf ("suspended thread owns a muto (%s)", m->name);
if (res)
goto set_pending;
resume_thread:
ResumeThread (hth);
Sleep (0);
@ -790,21 +795,25 @@ call_handler (int sig, struct sigaction& siga, void *handler)
goto set_pending;
sigproc_printf ("SuspendThread returned %d", res);
ebp = cx.Ebp;
}
next:
if (!using_mainthread_frame && interruptible (cx.Eip))
interrupt_now (&cx, sig, siga, handler);
else if (!interrupt_on_return (ebp, sig, siga, handler))
{
set_pending:
pending_signals = 1; /* FIXME: Probably need to be more tricky here */
sig_set_pending (sig);
interrupted = 0;
if (th)
interrupted = interrupt_on_return (th, sig, siga, handler);
else if (interruptible (cx.Eip))
interrupted = interrupt_now (&cx, sig, siga, handler);
else
break;
}
if (interrupted)
set_pending:
if (!interrupted)
{
pending_signals = 1; /* FIXME: Probably need to be more tricky here */
sig_set_pending (sig);
sigproc_printf ("couldn't send signal %d", sig);
}
else
{
res = SetEvent (signal_arrived); // For an EINTR case
sigproc_printf ("armed signal_arrived %p, res %d", signal_arrived, res);
@ -882,6 +891,9 @@ set_process_mask (sigset_t newmask)
mask_sync->release ();
if (oldmask != newmask && GetCurrentThreadId () != sigtid)
sig_dispatch_pending ();
else
sigproc_printf ("not calling sig_dispatch_pending. sigtid %p current %p",
sigtid, GetCurrentThreadId ());
return;
}
@ -1099,7 +1111,7 @@ __asm__ volatile ("
.text
_sigreturn:
addl $4,%%esp
addl $4,%%esp # Remove argument
movl %%esp,%%ebp
addl $36,%%ebp
call _set_process_mask@4
@ -1118,6 +1130,7 @@ _sigreturn:
popf
ret
__no_sig_start:
_sigdelayed:
pushl %2 # original return address
pushf
@ -1132,6 +1145,8 @@ _sigdelayed:
pushl %3 # oldmask
pushl %4 # signal argument
pushl $_sigreturn
pushl %%ebp
movl %%esp,%%esp
call _reset_signal_arrived@0
movl $0,%0
@ -1141,7 +1156,9 @@ _sigdelayed:
pushl $0
call _sig_dispatch_pending@4
2: jmp *%5
2: popl %%ebp
jmp *%5
__no_sig_end:
" : "=m" (sigsave.sig) : "m" (&_impure_ptr->_errno),
"g" (sigsave.retaddr), "g" (sigsave.oldmask), "g" (sigsave.sig),

27
winsup/cygwin/fork.cc
View File

@ -471,35 +471,12 @@ fork_parent (void *stack_here, HANDLE& hParent, dll *&first_dll, bool& load_dlls
system_printf ("couldn't create last_fork_proc, %E");
/* Fill in fields in the child's process table entry. */
forked->ppid = myself->pid;
forked->hProcess = pi.hProcess;
forked->dwProcessId = pi.dwProcessId;
forked->uid = myself->uid;
forked->gid = myself->gid;
forked->pgid = myself->pgid;
forked->sid = myself->sid;
forked->ctty = myself->ctty;
forked->umask = myself->umask;
forked->copysigs(myself);
forked->process_state |= PID_INITIALIZING |
(myself->process_state & PID_USETTY);
memcpy (forked->username, myself->username, MAX_USER_NAME);
if (myself->use_psid)
{
memcpy (forked->psid, myself->psid, MAX_SID_LEN);
forked->use_psid = 1;
}
memcpy (forked->logsrv, myself->logsrv, MAX_HOST_NAME);
memcpy (forked->domain, myself->domain, MAX_COMPUTERNAME_LENGTH+1);
forked->token = myself->token;
forked->impersonated = myself->impersonated;
forked->orig_uid = myself->orig_uid;
forked->orig_gid = myself->orig_gid;
forked->real_uid = myself->real_uid;
forked->real_gid = myself->real_gid;
strcpy (forked->root, myself->root);
forked->rootlen = myself->rootlen;
set_child_mmap_ptr (forked);
forked.remember ();
/* Wait for subproc to initialize itself. */
if (!sync_with_child(pi, subproc_ready, TRUE, "waiting for longjmp"))
@ -536,8 +513,6 @@ fork_parent (void *stack_here, HANDLE& hParent, dll *&first_dll, bool& load_dlls
goto cleanup;
}
forked.remember ();
/* Start thread, and wait for it to reload dlls. */
if (!resume_child (pi, forker_finished) ||
!sync_with_child (pi, subproc_ready, load_dlls, "child loading dlls"))

3
winsup/cygwin/pinfo.h
View File

@ -44,6 +44,9 @@ public:
/* Handle associated with initial Windows pid which started it all. */
HANDLE pid_handle;
/* Handle to the logical parent of this pid. */
HANDLE ppid_handle;
/* Parent process id. */
pid_t ppid;

55
winsup/cygwin/sigproc.cc
View File

@ -235,7 +235,7 @@ proc_subproc (DWORD what, DWORD val)
if (!get_proc_lock (what, val)) // Serialize access to this function
{
sigproc_printf ("I am not ready");
system_printf ("couldn't get proc lock. Something is wrong.");
goto out1;
}
@ -253,6 +253,33 @@ proc_subproc (DWORD what, DWORD val)
0, 0, DUPLICATE_SAME_ACCESS))
system_printf ("Couldn't duplicate child handle for pid %d, %E", vchild->pid);
ProtectHandle1 (vchild->pid_handle, pid_handle);
if (!DuplicateHandle (hMainProc, hMainProc, vchild->hProcess, &vchild->ppid_handle,
0, TRUE, DUPLICATE_SAME_ACCESS))
system_printf ("Couldn't duplicate my handle<%p> for pid %d, %E", hMainProc, vchild->pid);
vchild->ppid = myself->pid;
vchild->gid = myself->gid;
vchild->pgid = myself->pgid;
vchild->sid = myself->sid;
vchild->ctty = myself->ctty;
vchild->umask = myself->umask;
vchild->orig_uid = myself->orig_uid;
vchild->orig_gid = myself->orig_gid;
vchild->real_uid = myself->real_uid;
vchild->real_gid = myself->real_gid;
vchild->impersonated = myself->impersonated;
if (myself->use_psid)
{
vchild->use_psid = 1;
memcpy (vchild->psid, myself->psid, MAX_SID_LEN);
}
memcpy (vchild->logsrv, myself->logsrv, MAX_HOST_NAME);
memcpy (vchild->domain, myself->domain, MAX_COMPUTERNAME_LENGTH+1);
memcpy (vchild->root, myself->root, MAX_PATH+1);
vchild->token = myself->token;
vchild->rootlen = myself->rootlen;
vchild->process_state |= PID_INITIALIZING | (myself->process_state & PID_USETTY);
sigproc_printf ("added pid %d to wait list, slot %d, winpid %p, handle %p",
vchild->pid, nchildren, vchild->dwProcessId,
vchild->hProcess);
@ -810,6 +837,7 @@ init_child_info (DWORD chtype, child_info *ch, pid_t pid, HANDLE subproc_ready)
ch->shared_h = cygwin_shared_h;
ch->console_h = console_shared_h;
ch->subproc_ready = subproc_ready;
ch->pppid_handle = myself->ppid_handle;
if (chtype != PROC_EXEC || !parent_alive)
ch->parent_alive = hwait_subproc;
else
@ -1100,7 +1128,7 @@ wait_sig (VOID *)
HANDLE catchem[] = {sigcatch_main, sigcatch_nonmain, sigcatch_nosync};
sigproc_printf ("Ready. dwProcessid %d", myself->dwProcessId);
for (;;)
for (int i = 0; ; i++)
{
DWORD rc = WaitForMultipleObjects (3, catchem, FALSE, sig_loop_wait);
@ -1128,7 +1156,8 @@ wait_sig (VOID *)
/* A sigcatch semaphore has been signaled. Scan the sigtodo
* array looking for any unprocessed signals.
*/
pending_signals = 0;
pending_signals = -1;
int saw_pending_signals = 0;
int saw_sigchld = 0;
int dispatched_sigchld = 0;
for (int sig = -__SIGOFFSET; sig < NSIG; sig++)
@ -1179,11 +1208,26 @@ wait_sig (VOID *)
}
/* Decremented too far. */
if (InterlockedIncrement (myself->getsigtodo(sig)) > 0)
pending_signals = 1;
saw_pending_signals = 1;
nextsig:
continue;
}
/* FIXME: The dispatched stuff probably isn't needed anymore. */
if (dispatched >= 0 && pending_signals < 0 && !saw_pending_signals)
{
pending_signals = 0;
/* FIXME FIXME FIXME FIXME FIXME
This is a real kludge designed to handle runaway processes who
missed a signal and never processed a signal handler. We have
to reset signal_arrived or stuff goes crazy. */
if (i >= 20)
{
i = 0;
ResetEvent (signal_arrived);
}
}
if (nzombies && saw_sigchld && !dispatched_sigchld)
proc_subproc (PROC_CLEARWAIT, 0);
/* Signal completion of signal handling depending on which semaphore
@ -1202,8 +1246,6 @@ wait_sig (VOID *)
break;
}
if (dispatched < 0)
pending_signals = 1;
sigproc_printf ("looping");
}
@ -1258,7 +1300,6 @@ wait_subproc (VOID *)
system_printf ("pid %d, dwProcessId %u, hProcess %p, progname '%s'",
pchildren[i - 1]->pid, pchildren[i - 1]->dwProcessId,
pchildren[i - 1]->hProcess, pchildren[i - 1]->progname);
Sleep (10000);
}
break;
}

23
winsup/cygwin/spawn.cc
View File

@ -707,22 +707,6 @@ skip_arg_parsing:
}
child->username[0] = '\0';
child->progname[0] = '\0';
child->ppid = myself->pid;
child->gid = myself->gid;
child->pgid = myself->pgid;
child->sid = myself->sid;
child->ctty = myself->ctty;
child->umask = myself->umask;
child->process_state |= PID_INITIALIZING;
if (myself->use_psid)
{
child->use_psid = 1;
memcpy (child->psid, myself->psid, MAX_SID_LEN);
}
memcpy (child->logsrv, myself->logsrv, MAX_HOST_NAME);
memcpy (child->domain, myself->domain, MAX_COMPUTERNAME_LENGTH+1);
memcpy (child->root, myself->root, MAX_PATH+1);
child->rootlen = myself->rootlen;
child->dwProcessId = pi.dwProcessId;
child->hProcess = pi.hProcess;
child.remember ();
@ -808,20 +792,17 @@ skip_arg_parsing:
{
int rc = 0;
HANDLE oldh = myself->hProcess;
HANDLE h = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
parent->dwProcessId);
HANDLE h = myself->ppid_handle;
sigproc_printf ("parent handle %p, pid %d", h, parent->dwProcessId);
if (h == NULL && GetLastError () == ERROR_INVALID_PARAMETER)
rc = 1;
rc = 0;
else if (h)
{
ProtectHandle (h);
rc = DuplicateHandle (hMainProc, pi.hProcess,
h, &myself->hProcess, 0, FALSE,
DUPLICATE_SAME_ACCESS);
sigproc_printf ("%d = DuplicateHandle, oldh %p, newh %p",
rc, oldh, myself->hProcess);
ForceCloseHandle (h);
}
if (!rc)
{