+Sat May 4 05:44:25 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
+
+ * hurd/hurd-raise.c (_hurd_raise_signal): Pass sigcode in msg_sig_post
+ rpc.
+
+ * hurd/hurdmsg.c (_S_msg_set_environment): Use argz.h functions
+ instead of _hurd_split_args.
+ (_S_msg_*_exec_flags): Functions removed.
+ (_S_msg_startup_dosync): Stub removed.
+
+Sat May 4 02:11:55 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
+
+ * sysdeps/mach/hurd/ptrace.c: Set _hurdsig_traced instead of
+ EXEC_TRACED bit in _hurd_exec_flags.
+ Pass sigcode arg in msg_sig_post_untraced rpc.
+
+ * sysdeps/mach/hurd/access.c: Don't pass io port in
+ auth_user_authenticate rpc.
+
+ * posix/sched.h: Fix typos.
+
+ * sysdeps/mach/hurd/fork.c: Use new critical section lock.
+ Clear _hurdsig_traced instead of EXEC_TRACED.
+
+ * sysdeps/stub/nanosleep.c (nanosleep): Fix typo.
+
+ * wcsmbs/wcstol.c: Find strtol.c in ../stdlib.
+ * wcsmbs/wcstof.c: Find strtod.c in ../stdlib.
+ * wcsmbs/wcstod.c: Likewise.
+ * wcsmbs/wcstold.c: Likewise.
+
+ * wcsmbs/wcwidth.h: Find cname-lookup.h in ../wctype.
+
+ * string/envz.c (envz_entry): Use const.
+ (envz_get, envz_remove): Likewise.
+ (envz_entry): Return char *, not const char *.
+
+ * string/envz.h: Fix decl.
+
+ * string/argz-create.c: Use const in prototype.
+ * string/argz-next.c: Likewise.
+
Fri May 3 13:32:08 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
+ * sysdeps/mach/hurd/sigprocmask.c: Pass sigcode arg to msg_sig_post.
+ * sysdeps/mach/hurd/i386/sigreturn.c: Likewise.
+ * sysdeps/mach/hurd/sigsuspend.c: Likewise.
+ * sysdeps/mach/hurd/kill.c: Likewise.
+
+ * hurd/hurdexec.c (_hurd_exec): Use new critical section lock.
+ * hurd/catch-exc.c (_S_catch_exception_raise): Likewise.
+ * hurd/sigunwind.c (_hurdsig_longjmp_from_handler): Likewise.
+ * hurd/thread-cancel.c (hurd_thread_cancel, hurd_check_cancel):
+ Likewise.
+ * sysdeps/mach/hurd/jmp-unwind.c (_longjmp_unwind): Likewise.
+ * sysdeps/mach/hurd/sigaction.c: Likewise.
+
+ * sysdeps/mach/hurd/errnos.awk: Don't use ARGV in comment; it can
+ change meaninglessly.
+
+ * hurd/hurd/signal.h (struct hurd_sigstate): Replace critical section
+ flag with a spin lock.
+ (_hurd_critical_section_lock): Use spin_try_lock on that to see if we
+ get it. No need to take SS->lock at all.
+ (_hurd_critical_section_unlock): Unlock SS->critical_section_lock
+ instead of clearing the old flag member.
+ * hurd/hurdsig.c (_hurd_internal_post_signal): Use spin_lock_locked to
+ test the critical section state.
+
+ * hurd/hurdinit.c (_hurd_init): Set _hurdsig_traced from the intarray.
+
+ * hurd/hurdkill.c (_hurd_sig_post): Pass 0 sigcode in msg_sig_post.
+
+ * hurd/hurdsig.c (_hurd_internal_post_signal): Test _hurdsig_traced
+ instead of testing (_hurd_exec_flags & EXEC_TRACED).
+ (_S_msg_sig_post): Take sigcode arg and pass it through.
+ (_S_msg_sig_post_untraced): Likewise.
+ (reauth_proc): Don't pass proc port in auth_user_authenticate.
+
+ * hurd/setauth.c (_hurd_setauth): Don't pass object ports in
+ auth_user_authenticate RPCs, just the one-off rendezvous port.
+ * hurd/dtable.c (reauth_dtable): Likewise.
+ * hurd/hurdlookup.c (__hurd_file_name_lookup_retry): Likewise.
+
+ * hurd/hurdexec.c (_hurd_exec): Pass 0 flags to file_exec.
+ Pass sigcode arg to msg_sig_post.
+
+ * string/argz.h (argz_create): Use const in prototype.
+
+ * hurd/hurdinit.c (_hurd_proc_init): Test _hurdsig_traced instead of
+ testing (_hurd_exec_flags & EXEC_TRACED).
+ Pass sigcode arg to msg_sig_post.
+
+ * hurd/hurd.h: Declare _hurdsig_traced.
+
+ * string/argz.h (__argz_next): Cast ENTRY before returning it.
+
+ * hurd/hurd/signal.h (_hurd_critical_section_unlock): Pass sigcode arg
+ to msg_sig_post.
+
+ * hurd/path-lookup.c: New file.
+ * hurd/Makefile (routines): Add path-lookup.
+ * hurd/hurd/lookup.h: Declare file_name_path_scan,
+ hurd_file_name_path_lookup.
+ * hurd/hurd.h: Declare file_name_path_lookup.
+
+ * sysdeps/mach/hurd/select.c: The io_select rpc no longer has a TAG_ID
+ argument. Instead, use a separate reply port for each RPC and put them
+ all in a port set to wait for slow replies.
+
* intl/Makefile (CPPFLAGS): Change $(nlsdir) to $(i18ndir) in
LOCALE_ALIAS_PATH.
routines = hurdstartup hurdinit \
hurdid hurdlookup hurdpid hurdrlimit hurdprio hurdexec \
+ path-lookup \
setauth \
pid2task task2pid \
getuids setuids getumask fchroot \
-/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
no code should do anything that can fault while holding the
sigstate lock. */
- ss->critical_section = 0;
+ __spin_unlock (&ss->critical_section_lock);
ss->context = NULL;
__spin_unlock (&ss->lock);
}
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
ctty_new_pgrp (void)
{
int i;
-
+
HURD_CRITICAL_BEGIN;
__mutex_lock (&_hurd_dtable_lock);
{
struct hurd_fd *const d = _hurd_dtable[i];
mach_port_t new, newctty, ref;
-
+
if (d == NULL)
/* Nothing to do for an unused descriptor cell. */
continue;
/* Take the descriptor cell's lock. */
__spin_lock (&d->port.lock);
-
+
/* Reauthenticate the descriptor's port. */
if (d->port.port != MACH_PORT_NULL &&
! __io_reauthenticate (d->port.port,
ref, MACH_MSG_TYPE_MAKE_SEND) &&
! __USEPORT (AUTH, __auth_user_authenticate
(port,
- d->port.port,
ref, MACH_MSG_TYPE_MAKE_SEND,
&new)))
{
ref, MACH_MSG_TYPE_MAKE_SEND) &&
! __USEPORT (AUTH, __auth_user_authenticate
(port,
- d->ctty.port,
ref, MACH_MSG_TYPE_MAKE_SEND,
&newctty)))
_hurd_port_set (&d->ctty, newctty);
-/* Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
/* Send a message to the signal thread so it
will wake up and check for pending signals. */
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, signo, sigcode, __mach_task_self ());
}
extern struct hurd_port *_hurd_ports;
extern unsigned int _hurd_nports;
extern volatile mode_t _hurd_umask;
+extern sigset_t _hurdsig_traced;
/* Shorthand macro for internal library code referencing _hurd_ports (see
<hurd/port.h>). */
int flags, mode_t mode);
+/* Lookup FILE_NAME and return the node opened with FLAGS & MODE
+ (see hurd_file_name_lookup for details), but a simple file name (without
+ any directory prefixes) will be consecutively prefixed with the pathnames
+ in the `:' separated list PATH until one succeeds in a successful lookup.
+ If none succeed, then the first error that wasn't ENOENT is returned, or
+ ENOENT if no other errors were returned. If PREFIXED_NAME is non-NULL,
+ then if the result is looked up directly, *PREFIXED_NAME is set to NULL, and
+ if it is looked up using a prefix from PATH, *PREFIXED_NAME is set to
+ malloc'd storage containing the prefixed name. */
+extern file_t file_name_path_lookup (const char *file_name, const char *path,
+ int flags, mode_t mode,
+ char **prefixed_name);
+
+
+
/* Open a file descriptor on a port. FLAGS are as for `open'; flags
affected by io_set_openmodes are not changed by this. If successful,
this consumes a user reference for PORT (which will be deallocated on
/* Declarations of file name translation functions for the GNU Hurd.
-Copyright (C) 1995 Free Software Foundation, Inc.
+Copyright (C) 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
file_t *result);
+/* If FILE_NAME contains a '/', or PATH is NULL, call FUN with FILE_NAME, and
+ return the result (if PREFIXED_NAME is non-NULL, setting *PREFIXED_NAME to
+ NULL). Otherwise, call FUN repeatedly with FILE_NAME prefixed with each
+ successive `:' separated element of PATH, returning whenever FUN returns
+ 0 (if PREFIXED_NAME is non-NULL, setting *PREFIXED_NAME to the resulting
+ prefixed path). If FUN never returns 0, return the first non-ENOENT
+ return value, or ENOENT if there is none. */
+error_t file_name_path_scan (const char *file_name, const char *path,
+ error_t (*fun)(const char *name),
+ char **prefixed_name);
+
+/* Lookup FILE_NAME and return the node opened with FLAGS & MODE in result
+ (see hurd_file_name_lookup for details), but a simple filename (without
+ any directory prefixes) will be consectutively prefixed with the pathnames
+ in the `:' separated list PATH until one succeeds in a successful lookup.
+ If none succeed, then the first error that wasn't ENOENT is returned, or
+ ENOENT if no other errors were returned. If PREFIXED_NAME is non-NULL,
+ then if RESULT is looked up directly, *PREFIXED_NAME is set to NULL, and
+ if it is looked up using a prefix from PATH, *PREFIXED_NAME is set to
+ malloced storage containing the prefixed name. */
+error_t hurd_file_name_path_lookup (error_t (*use_init_port)
+ (int which,
+ error_t (*operate) (mach_port_t)),
+ file_t (*get_dtable_port) (int fd),
+ const char *file_name, const char *path,
+ int flags, mode_t mode,
+ file_t *result, char **prefixed_name);
+
+
#endif /* hurd/lookup.h */
struct hurd_sigstate
{
- spin_lock_t lock; /* Locks most of the rest of the structure. */
+ spin_lock_t critical_section_lock; /* Held if in critical section. */
- int critical_section; /* Nonzero if in critical section. */
+ spin_lock_t lock; /* Locks most of the rest of the structure. */
thread_t thread;
struct hurd_sigstate *next; /* Linked-list of thread sigstates. */
(void *) __hurd_threadvar_location (_HURD_THREADVAR_SIGSTATE);
struct hurd_sigstate *ss = *location;
if (ss == NULL)
- /* The thread variable is unset; this must be the first time we've
- asked for it. In this case, the critical section flag cannot
- possible already be set. Look up our sigstate structure the slow
- way; this locks the sigstate lock. */
- ss = *location = _hurd_thread_sigstate (__mach_thread_self ());
- else
- __spin_lock (&ss->lock);
-
- if (ss->critical_section)
{
- /* We are already in a critical section, so do nothing. */
+ /* The thread variable is unset; this must be the first time we've
+ asked for it. In this case, the critical section flag cannot
+ possible already be set. Look up our sigstate structure the slow
+ way; this locks the sigstate lock. */
+ ss = *location = _hurd_thread_sigstate (__mach_thread_self ());
__spin_unlock (&ss->lock);
- return NULL;
}
- /* Set the critical section flag so no signal handler will run. */
- ss->critical_section = 1;
- __spin_unlock (&ss->lock);
+ if (! __spin_try_lock (&ss->critical_section_lock))
+ /* We are already in a critical section, so do nothing. */
+ return NULL;
- /* Return our sigstate pointer; this will be passed to
- _hurd_critical_section_unlock to clear the critical section flag. */
+ /* With the critical section lock held no signal handler will run.
+ Return our sigstate pointer; this will be passed to
+ _hurd_critical_section_unlock to unlock it. */
return ss;
}
return;
else
{
- /* It was us who acquired the critical section lock. Clear the
- critical section flag. */
+ /* It was us who acquired the critical section lock. Unlock it. */
struct hurd_sigstate *ss = our_lock;
sigset_t pending;
__spin_lock (&ss->lock);
- ss->critical_section = 0;
+ __spin_unlock (&ss->critical_section_lock);
pending = ss->pending & ~ss->blocked;
__spin_unlock (&ss->lock);
if (pending)
/* There are unblocked signals pending, which weren't
delivered because we were in the critical section.
Tell the signal thread to deliver them now. */
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
}
}
#include <hurd.h>
#include <hurd/fd.h>
#include <hurd/signal.h>
+#include <assert.h>
#include <argz.h>
/* Overlay TASK, executing FILE with arguments ARGV and environment ENVP.
char *const argv[], char *const envp[])
{
error_t err;
- char *args, *env, *ap;
+ char *args, *env;
size_t argslen, envlen;
int ints[INIT_INT_MAX];
mach_port_t ports[_hurd_nports];
unsigned int dtablesize, i;
struct hurd_port **dtable_cells;
struct hurd_userlink *ulink_dtable;
- char *const *p;
struct hurd_sigstate *ss;
mach_port_t *please_dealloc, *pdp;
+ /* XXX needs to be hurdmalloc XXX */
if (err = __argz_create (argv, &args, &argslen))
return err;
if (err = __argz_create (envp, &env, &envlen))
}
ss = _hurd_self_sigstate ();
+
+ assert (! __spin_lock_locked (&ss->critical_section_lock));
+ __spin_lock (&ss->critical_section_lock);
+
__spin_lock (&ss->lock);
ints[INIT_SIGMASK] = ss->blocked;
ints[INIT_SIGPENDING] = ss->pending;
critical section flag avoids anything we call trying to acquire the
sigstate lock. */
- ss->critical_section = 1;
__spin_unlock (&ss->lock);
/* Pack up the descriptor table to give the new program. */
*pdp++ = dtable[i];
}
- err = __file_exec (file, task,
- _hurd_exec_flags & EXEC_INHERITED,
+ err = __file_exec (file, task, 0,
args, argslen, env, envlen,
dtable, MACH_MSG_TYPE_COPY_SEND, dtablesize,
ports, MACH_MSG_TYPE_COPY_SEND, _hurd_nports,
__mutex_unlock (&_hurd_dtable_lock);
/* Safe to let signals happen now. */
- {
- sigset_t pending;
- __spin_lock (&ss->lock);
- ss->critical_section = 0;
- pending = ss->pending & ~ss->blocked;
- __spin_unlock (&ss->lock);
- if (pending)
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
- }
+ _hurd_critical_section_unlock (ss);
outargs:
free (args);
struct hurd_port *_hurd_ports;
unsigned int _hurd_nports;
mode_t _hurd_umask;
+sigset_t _hurdsig_traced;
error_t
_hurd_ports_use (int which, error_t (*operate) (mach_port_t))
else
_hurd_umask = CMASK;
+ if (intarraysize > INIT_TRACEMASK)
+ _hurdsig_traced = intarray[INIT_TRACEMASK];
+
/* All done with init ints and ports. */
__vm_deallocate (__mach_task_self (),
(vm_address_t) intarray,
here, like _hurd_pid, are already initialized. */
RUN_HOOK (_hurd_proc_subinit, ());
- if (_hurd_exec_flags & EXEC_TRACED)
+ if (_hurdsig_traced)
/* This process is "traced", meaning it should stop on signals or exec.
We are all set up now to handle signals. Stop ourselves, to inform
our parent (presumably a debugger) that the exec has completed. */
- __msg_sig_post (_hurd_msgport, SIGTRAP, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, SIGTRAP, 0, __mach_task_self ());
}
\f
/* Called when we get a message telling us to change our proc server port. */
(refport = arg_refport, 0), 0,
/* If no message port we cannot send signals. */
msgport == MACH_PORT_NULL ? EPERM :
- __msg_sig_post (msgport, sig, refport));
+ __msg_sig_post (msgport, sig, 0, refport));
if (! err)
delivered = 1;
}
mach_port_t ref = __mach_reply_port ();
error_t reauth (auth_t auth)
{
- return __auth_user_authenticate (auth, unauth, ref,
+ return __auth_user_authenticate (auth, ref,
MACH_MSG_TYPE_MAKE_SEND,
result);
}
-/* Copyright (C) 1992, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1992, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#include <unistd.h>
#include <limits.h>
#include <string.h>
+#include <argz.h>
#define AUTHCHECK \
AUTHCHECK;
- envc = _hurd_split_args (data, datalen, NULL);
+ envc = __argz_count (data, datalen);
envp = malloc ((envc + 1) * sizeof (char *));
if (envp == NULL)
return errno;
- _hurd_split_args (data, datalen, envp);
+ __argz_extract (data, datalen, envp);
__environ = envp; /* XXX cooperate with loadenv et al */
return 0;
}
\f
-/* Get and frob the exec flags. */
-
-kern_return_t
-_S_msg_get_exec_flags (mach_port_t process, mach_port_t auth,
- int *flags)
-{
- AUTHCHECK;
-
- *flags = _hurd_exec_flags;
- return 0;
-}
-
-kern_return_t
-_S_msg_set_all_exec_flags (mach_port_t process, mach_port_t auth,
- int flags)
-{
- AUTHCHECK;
-
- _hurd_exec_flags = flags;
- return 0;
-}
-
-kern_return_t
-_S_msg_set_some_exec_flags (mach_port_t process, mach_port_t auth,
- int flags)
-{
- AUTHCHECK;
-
- _hurd_exec_flags |= flags;
- return 0;
-}
-
-kern_return_t
-_S_msg_clear_some_exec_flags (mach_port_t process, mach_port_t auth,
- int flags)
-{
- AUTHCHECK;
-
- _hurd_exec_flags &= ~flags;
- return 0;
-}
-\f
/* XXX */
portarray_t dtable,
mach_msg_type_number_t dtableCnt)
{ return EOPNOTSUPP; }
-
-kern_return_t
-_S_msg_startup_dosync (mach_port_t process)
-{ return EOPNOTSUPP; }
{
/* No preemption. Do normal handling. */
- if (!untraced && (_hurd_exec_flags & EXEC_TRACED))
+ if (!untraced && __sigismember (&_hurdsig_traced, signo))
{
/* We are being traced. Stop to tell the debugger of the signal. */
if (_hurd_stopped)
/* The thread was in sigreturn, not in any interruptible RPC. */
wait_for_reply = 0;
- assert (! ss->critical_section);
+ assert (! __spin_lock_locked (&ss->critical_section_lock));
}
else
{
&reply)
!= MACH_PORT_NULL);
- if (ss->critical_section)
+ if (__spin_lock_locked (&ss->critical_section_lock))
{
/* The thread is in a critical section. Mark the signal as
pending. When it finishes the critical section, it will
thread finishes its critical section. */
inline int signals_pending (void)
{
- if (_hurd_stopped || ss->critical_section)
+ if (_hurd_stopped || __spin_lock_locked (&ss->critical_section_lock))
return 0;
return pending = ss->pending & ~ss->blocked;
}
kern_return_t
_S_msg_sig_post (mach_port_t me,
mach_port_t reply_port, mach_msg_type_name_t reply_port_type,
- int signo,
+ int signo, natural_t sigcode,
mach_port_t refport)
{
error_t err;
/* Post the signal to the designated signal-receiving thread. This will
reply when the signal can be considered delivered. */
_hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
- signo, 0, 0, reply_port, reply_port_type,
+ signo, sigcode, 0, reply_port, reply_port_type,
0); /* Stop if traced. */
return MIG_NO_REPLY; /* Already replied. */
_S_msg_sig_post_untraced (mach_port_t me,
mach_port_t reply_port,
mach_msg_type_name_t reply_port_type,
- int signo,
+ int signo, natural_t sigcode,
mach_port_t refport)
{
error_t err;
/* Post the signal to the designated signal-receiving thread. This will
reply when the signal can be considered delivered. */
_hurd_internal_post_signal (_hurd_thread_sigstate (_hurd_sigthread),
- signo, 0, 0, reply_port, reply_port_type,
+ signo, sigcode, 0, reply_port, reply_port_type,
1); /* Untraced flag. */
return MIG_NO_REPLY; /* Already replied. */
if (! HURD_PORT_USE (&_hurd_ports[INIT_PORT_PROC],
__proc_reauthenticate (port, ref,
MACH_MSG_TYPE_MAKE_SEND) ||
- __auth_user_authenticate (new, port, ref,
+ __auth_user_authenticate (new, ref,
MACH_MSG_TYPE_MAKE_SEND,
&ignore))
&& ignore != MACH_PORT_NULL)
--- /dev/null
+/* Filename lookup using a search path
+
+ Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+ Written by Miles Bader <miles@gnu.ai.mit.edu>
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2, or (at
+ your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <string.h>
+#include <hurd.h>
+#include <hurd/lookup.h>
+
+/* If FILE_NAME contains a '/', or PATH is NULL, call FUN with FILE_NAME, and
+ return the result (if PREFIXED_NAME is non-NULL, setting *PREFIXED_NAME to
+ NULL). Otherwise, call FUN repeatedly with FILE_NAME prefixed with each
+ successive `:' separated element of PATH, returning whenever FUN returns
+ 0 (if PREFIXED_NAME is non-NULL, setting *PREFIXED_NAME to the resulting
+ prefixed path). If FUN never returns 0, return the first non-ENOENT
+ return value, or ENOENT if there is none. */
+error_t
+file_name_path_scan (const char *file_name, const char *path,
+ error_t (*fun)(const char *name),
+ char **prefixed_name)
+{
+ if (path == NULL || index (file_name, '/'))
+ {
+ if (prefixed_name)
+ *prefixed_name = 0;
+ return (*fun)(file_name);
+ }
+ else
+ {
+ error_t real_err = 0;
+ size_t file_name_len = strlen (file_name);
+
+ for (;;)
+ {
+ error_t err;
+ const char *next = index (path, ':') ?: path + strlen (path);
+ size_t pfx_len = next - path;
+ char pfxed_name[pfx_len + 2 + file_name_len + 1];
+
+ if (pfx_len == 0)
+ pfxed_name[pfx_len++] = '.';
+ else
+ bcopy (path, pfxed_name, pfx_len);
+ if (pfxed_name[pfx_len - 1] != '/')
+ pfxed_name[pfx_len++] = '/';
+ bcopy (file_name, pfxed_name + pfx_len, file_name_len + 1);
+
+ err = (*fun)(pfxed_name);
+ if (err == 0)
+ {
+ if (prefixed_name)
+ *prefixed_name = strdup (pfxed_name);
+ return 0;
+ }
+ if (!real_err && err != ENOENT)
+ real_err = err;
+
+ if (*next == '\0')
+ return real_err ?: ENOENT;
+ else
+ path = next + 1;
+ }
+ }
+}
+
+/* Lookup FILE_NAME and return the node opened with FLAGS & MODE in result
+ (see hurd_file_name_lookup for details), but a simple filename (without
+ any directory prefixes) will be consectutively prefixed with the pathnames
+ in the `:' separated list PATH until one succeeds in a successful lookup.
+ If none succeed, then the first error that wasn't ENOENT is returned, or
+ ENOENT if no other errors were returned. If PREFIXED_NAME is non-NULL,
+ then if RESULT is looked up directly, *PREFIXED_NAME is set to NULL, and
+ if it is looked up using a prefix from PATH, *PREFIXED_NAME is set to
+ malloced storage containing the prefixed name. */
+error_t
+hurd_file_name_path_lookup (error_t (*use_init_port)
+ (int which,
+ error_t (*operate) (mach_port_t)),
+ file_t (*get_dtable_port) (int fd),
+ const char *file_name, const char *path,
+ int flags, mode_t mode,
+ file_t *result, char **prefixed_name)
+{
+ error_t lookup (const char *name)
+ {
+ return
+ __hurd_file_name_lookup (use_init_port, get_dtable_port,
+ name, flags, mode, result);
+ }
+ return file_name_path_scan (file_name, path, lookup, prefixed_name);
+}
+
+file_t
+file_name_path_lookup (const char *file_name, const char *path,
+ int flags, mode_t mode, char **prefixed_name)
+{
+ error_t err;
+ file_t result;
+
+ err = hurd_file_name_path_lookup (&_hurd_ports_use, &__getdport,
+ file_name, path, flags, mode,
+ &result, prefixed_name);
+
+ return err ? (__hurd_fail (err), MACH_PORT_NULL) : result;
+}
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
! HURD_PORT_USE (&_hurd_ports[INIT_PORT_AUTH],
__auth_user_authenticate
(port,
- _hurd_init_dtable[d],
ref, MACH_MSG_TYPE_MAKE_SEND,
&new)))
{
if (__USEPORT (CRDIR,
! __io_reauthenticate (port,
ref, MACH_MSG_TYPE_MAKE_SEND) &&
- ! __auth_user_authenticate (new, port,
+ ! __auth_user_authenticate (new,
ref, MACH_MSG_TYPE_MAKE_SEND,
&newport)))
_hurd_port_set (&_hurd_ports[INIT_PORT_CRDIR], newport);
if (__USEPORT (CWDIR,
! __io_reauthenticate (port,
ref, MACH_MSG_TYPE_MAKE_SEND) &&
- ! __auth_user_authenticate (new, port,
+ ! __auth_user_authenticate (new,
ref, MACH_MSG_TYPE_MAKE_SEND,
&newport)))
_hurd_port_set (&_hurd_ports[INIT_PORT_CWDIR], newport);
__spin_lock (&ss->lock);
/* We should only ever be called from _longjmp_unwind (in jmp-unwind.c),
which calls us inside a critical section. */
- assert (ss->critical_section);
+ assert (__spin_lock_locked (&ss->critical_section_lock));
/* Are we on the alternate signal stack now? */
onstack = (ss->sigaltstack.ss_flags & SA_ONSTACK);
__spin_unlock (&ss->lock);
having run all the unwind forms back to ENV's frame, but our SP is
still inside those unwound frames. */
__spin_lock (&ss->lock);
- ss->critical_section = 0;
+ __spin_unlock (&ss->critical_section_lock);
ss->blocked = ~(sigset_t) 0 & ~_SIG_CANT_MASK;
__spin_unlock (&ss->lock);
/* Thread cancellation support.
-Copyright (C) 1995 Free Software Foundation, Inc.
+Copyright (C) 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
/* See hurdsig.c. */
extern mach_port_t _hurdsig_abort_rpcs (struct hurd_sigstate *ss,
- int signo, int sigthread,
+ int signo, int sigthread,
struct machine_thread_all_state *,
int *state_change,
mach_port_t *reply_port,
if (ss == _hurd_self_sigstate ())
return EINTR; /* Bozo. */
+ assert (! __spin_lock_locked (&ss->critical_section_lock));
+ __spin_lock (&ss->critical_section_lock);
__spin_lock (&ss->lock);
- assert (! ss->critical_section);
- ss->critical_section = 1;
err = __thread_suspend (thread);
__spin_unlock (&ss->lock);
/* Interrupt any interruptible RPC now in progress. */
state.set = 0;
_hurdsig_abort_rpcs (ss, 0, 0, &state, &state_change, NULL, 0, 0);
- if (state_change)
+ if (state_change)
err = __thread_set_state (thread, MACHINE_THREAD_STATE_FLAVOR,
(natural_t *) &state.basic,
MACHINE_THREAD_STATE_COUNT);
int cancel;
__spin_lock (&ss->lock);
- assert (! ss->critical_section);
+ assert (! __spin_lock_locked (&ss->critical_section_lock));
cancel = ss->cancel;
ss->cancel = 0;
__spin_unlock (&ss->lock);
/* Set scheduling parameters for a process. */
extern int __sched_setparam __P ((__pid_t __pid,
- __const struct sched_param *__param));
+ __const struct sched_params *__param));
extern int sched_setparam __P ((__pid_t __pid,
- __const struct sched_param *__param));
+ __const struct sched_params *__param));
/* Retrieve scheduling parameters for a particular process. */
-extern int __sched_getparam __P ((__pid_t __pid, struct sched_param *__param));
-extern int sched_getparam __P ((__pid_t __pid, struct sched_param *__param));
+extern int __sched_getparam __P ((__pid_t __pid, struct sched_params *__param));
+extern int sched_getparam __P ((__pid_t __pid, struct sched_params *__param));
/* Set scheduling algorithm and/or parameters for a process. */
extern int __sched_setscheduler __P ((__pid_t __pid, int __policy,
- __const struct sched_param *__param));
+ __const struct sched_params *__param));
extern int sched_setscheduler __P ((__pid_t __pid, int __policy,
- __const struct sched_param *__param));
+ __const struct sched_params *__param));
/* Retrieve scheduling algorithm for a particular purpose. */
extern int __sched_getscheduler __P ((__pid_t __pid));
ARGZ, and the total length in LEN. If a memory allocation error occurs,
ENOMEM is returned, otherwise 0. */
error_t
-__argz_create (char **argv, char **argz, size_t *len)
+__argz_create (char *const argv[], char **argz, size_t *len)
{
int argc;
size_t tlen = 0;
- char *p, **ap;
+ char *const *ap;
+ char *p;
for (argc = 0; argv[argc] != NULL; ++argc)
tlen += strlen (argv[argc]);
if (entry < argz + argz_len)
entry = strchr (entry, '\0') + 1;
- return entry >= argz + argz_len ? NULL : entry;
+ return entry >= argz + argz_len ? NULL : (char *) entry;
}
else
if (argz_len > 0)
/* Make a '\0' separated arg vector from a unix argv vector, returning it in
ARGZ, and the total length in LEN. If a memory allocation error occurs,
ENOMEM is returned, otherwise 0. The result can be destroyed using free. */
-error_t __argz_create __P ((char **__argv, char **__argz, size_t *__len));
-error_t argz_create __P ((char **__argv, char **__argz, size_t *__len));
+error_t __argz_create __P ((char *const argv[], char **argz, size_t *len));
+error_t argz_create __P ((char *const *argv[], char **argz, size_t *len));
/* Make a '\0' separated arg vector from a SEP separated list in
STRING, returning it in ARGZ, and the total length in LEN. If a
memory allocation error occurs, ENOMEM is returned, otherwise 0.
The result can be destroyed using free. */
-error_t __argz_create_sep __P ((__const char *__string, int __sep,
- char **__argz, size_t *__len));
-error_t argz_create_sep __P ((__const char *__string, int __sep,
- char **__argz, size_t *__len));
+error_t __argz_create_sep __P ((__const char *string, int sep,
+ char **argz, size_t *len));
+error_t argz_create_sep __P ((__const char *string, int sep,
+ char **argz, size_t *len));
/* Returns the number of strings in ARGZ. */
-size_t __argz_count __P ((__const char *__argz, size_t __len));
-size_t argz_count __P ((__const char *__argz, size_t __len));
+size_t __argz_count __P ((__const char *argz, size_t len));
+size_t argz_count __P ((__const char *argz, size_t len));
/* Puts pointers to each string in ARGZ into ARGV, which must be large enough
to hold them all. */
-void __argz_extract __P ((__const char *__argz, size_t __len, char **__argv));
-void argz_extract __P ((__const char *__argz, size_t __len, char **__argv));
+void __argz_extract __P ((__const char *argz, size_t len, char **argv));
+void argz_extract __P ((__const char *argz, size_t len, char **argv));
/* Make '\0' separated arg vector ARGZ printable by converting all the '\0's
except the last into the character SEP. */
-void __argz_stringify __P ((char *__argz, size_t __len, int __sep));
-void argz_stringify __P ((char *__argz, size_t __len, int __sep));
+void __argz_stringify __P ((char *argz, size_t len, int sep));
+void argz_stringify __P ((char *argz, size_t len, int sep));
/* Append BUF, of length BUF_LEN to the argz vector in ARGZ & ARGZ_LEN. */
-error_t __argz_append __P ((char **__argz, size_t *__argz_len,
- __const char *__buf, size_t __buf_len));
-error_t argz_append __P ((char **__argz, size_t *__argz_len,
- __const char *__buf, size_t __buf_len));
+error_t __argz_append __P ((char **argz, size_t *argz_len,
+ __const char *buf, size_t buf_len));
+error_t argz_append __P ((char **argz, size_t *argz_len,
+ __const char *buf, size_t buf_len));
/* Append STR to the argz vector in ARGZ & ARGZ_LEN. */
-error_t __argz_add __P ((char **__argz, size_t *__argz_len,
- __const char *__str));
-error_t argz_add __P ((char **__argz, size_t *__argz_len,
- __const char *__str));
+error_t __argz_add __P ((char **argz, size_t *argz_len,
+ __const char *str));
+error_t argz_add __P ((char **argz, size_t *argz_len,
+ __const char *str));
/* Delete ENTRY from ARGZ & ARGZ_LEN, if it appears there. */
-void __argz_delete __P ((char **__argz, size_t *__argz_len, char *__entry));
-void argz_delete __P ((char **__argz, size_t *__argz_len, char *__entry));
+void __argz_delete __P ((char **argz, size_t *argz_len, char *entry));
+void argz_delete __P ((char **argz, size_t *argz_len, char *entry));
/* Insert ENTRY into ARGZ & ARGZ_LEN before BEFORE, which should be an
existing entry in ARGZ; if BEFORE is NULL, ENTRY is appended to the end.
ARGZ, ENTRY) will insert ENTRY at the beginning of ARGZ. If BEFORE is not
in ARGZ, EINVAL is returned, else if memory can't be allocated for the new
ARGZ, ENOMEM is returned, else 0. */
-error_t __argz_insert __P ((char **__argz, size_t *__argz_len,
- char *__before, __const char *__entry));
-error_t argz_insert __P ((char **__argz, size_t *__argz_len,
- char *__before, __const char *__entry));
+error_t __argz_insert __P ((char **argz, size_t *argz_len,
+ char *before, __const char *entry));
+error_t argz_insert __P ((char **argz, size_t *argz_len,
+ char *before, __const char *entry));
\f
/* Returns the next entry in ARGZ & ARGZ_LEN after ENTRY, or NULL if there
are no more. If entry is NULL, then the first entry is returned. This
for (entry = argz; entry; entry = argz_next (argz, argz_len, entry))
...;
*/
-extern char *__argz_next __P ((char *__argz, size_t __argz_len,
- __const char *__entry));
-extern char *argz_next __P ((char *__argz, size_t __argz_len,
- __const char *__entry));
+extern char *__argz_next __P ((char *argz, size_t __argz_len,
+ __const char *entry));
+extern char *argz_next __P ((char *argz, size_t __argz_len,
+ __const char *entry));
#if defined (__OPTIMIZE__) && __GNUC__ >= 2
extern inline char *
if (entry < argz + argz_len)
entry = strchr (entry, '\0') + 1;
- return entry >= argz + argz_len ? NULL : entry;
+ return entry >= argz + argz_len ? NULL : (char *) entry;
}
else
if (argz_len > 0)
/* Returns a pointer to the entry in ENVZ for NAME, or 0 if there is none.
If NAME contains the separator character, only the portion before it is
used in the comparison. */
-const char *
+char *
envz_entry (const char *envz, size_t envz_len, const char *name)
{
while (envz_len)
{
- char *p = name;
- char *entry = envz; /* Start of this entry. */
+ const char *p = name;
+ const char *entry = envz; /* Start of this entry. */
/* See how far NAME and ENTRY match. */
while (envz_len && *p == *envz && *p && *p != SEP)
if ((*envz == '\0' || *envz == SEP) && (*p == '\0' || *p == SEP))
/* Bingo! */
- return entry;
+ return (char *) entry;
/* No match, skip to the next entry. */
while (envz_len && *envz)
const char *
envz_get (const char *envz, size_t envz_len, const char *name)
{
- char *entry = envz_entry (envz, envz_len, name);
+ const char *entry = envz_entry (envz, envz_len, name);
if (entry)
{
while (*entry && *entry != SEP)
\f
/* Remove the entry for NAME from ENVZ & ENVZ_LEN, if any. */
void
-envz_remove (char **envz, size_t *envz_len, char *name)
+envz_remove (char **envz, size_t *envz_len, const char *name)
{
char *entry = envz_entry (*envz, *envz_len, name);
if (entry)
#include <argz.h>
/* Returns a pointer to the entry in ENVZ for NAME, or 0 if there is none. */
-const char *envz_entry __P ((__const char *__envz, size_t __envz_len,
- __const char *__name));
+char *envz_entry __P ((__const char *__envz, size_t __envz_len,
+ __const char *__name));
/* Returns a pointer to the value portion of the entry in ENVZ for NAME, or 0
if there is none. */
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
err = __io_reauthenticate (port, ref, MACH_MSG_TYPE_MAKE_SEND);
if (!err)
err = __auth_user_authenticate (_hurd_id.rid_auth,
- port,
ref, MACH_MSG_TYPE_MAKE_SEND,
result);
err;
&_hurd_id.rid_auth)))
goto lose;
}
-
+
if (!err)
/* Look up the file name using the modified init ports. */
err = __hurd_file_name_lookup (&init_port, &__getdport,
# @comment errno 123
BEGIN {
- printf "/* This file generated by";
- for (i = 0; i < ARGC; ++i)
- printf " %s", ARGV[i];
- printf ". */\n";
+ print "/* This file generated by errnos.awk. */";
print "";
print "/* The Hurd uses Mach error system 0x10, currently only subsystem 0. */";
print "#ifndef _HURD_ERRNO";
-/* This file generated by gawk ../manual/errno.texi ../../mach/mach/message.h ../../mach/mach/kern_return.h ../../mach/mach/mig_errors.h ../../mach/device/device_types.h. */
+/* This file generated by errnos.awk. */
/* The Hurd uses Mach error system 0x10, currently only subsystem 0. */
#ifndef _HURD_ERRNO
struct hurd_sigstate *volatile ss;
ss = _hurd_self_sigstate ();
- __spin_lock (&ss->lock);
- ss->critical_section = 1;
- __spin_unlock (&ss->lock);
+ __spin_lock (&ss->critical_section_lock);
#undef LOSE
#define LOSE assert_perror (err) /* XXX */
&_hurd_orphaned));
/* Forking clears the trace flag. */
- _hurd_exec_flags &= ~EXEC_TRACED;
+ __sigemptyset (&_hurdsig_traced);
/* Run things that want to run in the child task to set up. */
RUN_HOOK (_hurd_fork_child_hook, ());
arrange to have us called over again in the new reality. */
ss->context = scp;
__spin_unlock (&ss->lock);
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
/* If a pending signal was handled, sig_post never returned.
If it did return, the pending signal didn't run a handler;
proceed as usual. */
/* All access to SS->active_resources must take place inside a critical
section where signal handlers cannot run. */
__spin_lock (&ss->lock);
- assert (! ss->critical_section);
- ss->critical_section = 1;
+ assert (! __spin_lock_locked (&ss->critical_section_lock));
+ __spin_lock (&ss->critical_section_lock);
/* Remove local signal preempters being unwound past. */
while (ss->preempters &&
_JMPBUF_UNWINDS (env[0].__jmpbuf, ss->preempters))
ss->preempters = ss->preempters->next;
+ __spin_unlock (&ss->critical_section_lock);
__spin_unlock (&ss->lock);
/* Iterate over the current thread's list of active resources.
{
if (msgport != MACH_PORT_NULL)
/* Send a signal message to his message port. */
- return __msg_sig_post (msgport, sig, refport);
+ return __msg_sig_post (msgport, sig, 0, refport);
/* The process has no message port. Perhaps try direct
frobnication of the task. */
/* Process tracing interface `ptrace' for GNU Hurd.
-Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
+Copyright (C) 1991, 1992, 1993, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
{
case PTRACE_TRACEME:
/* Make this process be traced. */
- _hurd_exec_flags |= EXEC_TRACED;
+ __sigfillset (&_hurdsig_traced);
__USEPORT (PROC, __proc_mark_traced (port));
break;
/* Tell the process to take the signal (or just resume if 0). */
err = HURD_MSGPORT_RPC
(__USEPORT (PROC, __proc_getmsgport (port, pid, &msgport)),
- 0, 0, __msg_sig_post_untraced (msgport, data, task));
+ 0, 0, __msg_sig_post_untraced (msgport, data, 0, task));
}
__mach_port_deallocate (__mach_task_self (), task);
return err ? __hurd_fail (err) : 0;
err = __USEPORT (PROC, __proc_getmsgport (port, pid, &msgport));
if (! err)
{
- err = (request == PTRACE_ATTACH ?
- __msg_set_some_exec_flags :
- __msg_clear_some_exec_flags) (msgport, task, EXEC_TRACED);
-#ifdef notyet /* XXX */
- if (! err)
- /* Request (or request an end to) SIGCHLD notification
- when PID stops or dies, and proc_wait working on PID. */
- err = __USEPORT (PROC,
- __proc_trace_pid (port, pid,
- request == PTRACE_ATTACH));
-#endif
+ err = __msg_set_init_int (msgport, task, INIT_TRACEMASK,
+ request == PTRACE_DETACH ? 0 :
+ ~(sigset_t) 0);
if (! err)
{
if (request == PTRACE_ATTACH)
/* Now stop the process. */
- err = __msg_sig_post (msgport, SIGSTOP, task);
+ err = __msg_sig_post (msgport, SIGSTOP, 0, task);
else
/* Resume the process from tracing stop. */
- err = __msg_sig_post_untraced (msgport, 0, task);
+ err = __msg_sig_post_untraced (msgport, 0, 0, task);
}
__mach_port_deallocate (__mach_task_self (), msgport);
}
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#include <hurd/fd.h>
#include <stdlib.h>
#include <string.h>
+#include <assert.h>
/* All user select types. */
#define SELECT_ALL (SELECT_READ | SELECT_WRITE | SELECT_URG)
fd_set *exceptfds AND struct timeval *timeout)
{
int i;
- mach_port_t port;
+ mach_port_t portset;
int got;
- int *types;
- struct hurd_userlink *ulink;
- mach_port_t *ports;
- struct hurd_fd **cells;
error_t err;
fd_set rfds, wfds, xfds;
int firstfd, lastfd;
(timeout->tv_sec * 1000 +
timeout->tv_usec / 1000) :
0);
+ struct
+ {
+ struct hurd_userlink ulink;
+ struct hurd_fd *cell;
+ mach_port_t io_port;
+ int type;
+ mach_port_t reply_port;
+ } d[nfds];
/* Use local copies so we can't crash from user bogosity. */
if (readfds == NULL)
nfds = _hurd_dtablesize;
/* Collect the ports for interesting FDs. */
- cells = __alloca (nfds * sizeof (*cells));
- ports = __alloca (nfds * sizeof (*ports));
- types = __alloca (nfds * sizeof (*types));
- ulink = __alloca (nfds * sizeof (*ulink));
firstfd = lastfd = -1;
for (i = 0; i < nfds; ++i)
{
type |= SELECT_WRITE;
if (exceptfds != NULL && FD_ISSET (i, &xfds))
type |= SELECT_URG;
- types[i] = type;
+ d[i].type = type;
if (type)
{
- cells[i] = _hurd_dtable[i];
- ports[i] = _hurd_port_get (&cells[i]->port, &ulink[i]);
- if (ports[i] == MACH_PORT_NULL)
+ d[i].cell = _hurd_dtable[i];
+ d[i].io_port = _hurd_port_get (&d[i].cell->port, &d[i].ulink);
+ if (d[i].io_port == MACH_PORT_NULL)
{
/* If one descriptor is bogus, we fail completely. */
while (i-- > 0)
- _hurd_port_free (&cells[i]->port, &ulink[i], ports[i]);
+ _hurd_port_free (&d[i].cell->port, &d[i].ulink, d[i].io_port);
errno = EBADF;
break;
}
if (i < nfds)
return -1;
- /* Get a port to receive the io_select_reply messages on. */
- port = __mach_reply_port ();
-
/* Send them all io_select request messages. */
- got = 0;
err = 0;
+ got = 0;
+ portset = MACH_PORT_NULL;
for (i = firstfd; i <= lastfd; ++i)
- if (types[i])
+ if (d[i].type)
{
- if (!err)
+ int type = d[i].type;
+ d[i].reply_port = __mach_reply_port ();
+ err = __io_select (d[i].io_port, d[i].reply_port,
+ /* Poll for each but the last. */
+ (i == lastfd && got == 0) ? to : 0,
+ &type);
+ switch (err)
{
- int tag = i;
- int type = types[i];
- err = __io_select (ports[i], port,
- /* Poll for each but the last. */
- (i == lastfd && got == 0) ? to : 0,
- &type, &tag);
- switch (err)
+ case MACH_RCV_TIMED_OUT:
+ /* No immediate response. This is normal. */
+ err = 0;
+ if (got == 0)
{
- case MACH_RCV_TIMED_OUT:
- /* No immediate response. This is normal. */
- err = 0;
- break;
-
- case 0:
- /* We got an answer. This is not necessarily the answer to
- the query we sent just now. It may correspond to any
- prior query which timed out before its answer arrived. */
- if (tag < 0 || tag > i || (type & SELECT_ALL) == 0)
- /* This is not a proper answer to any query we have yet
- made. */
- err = EGRATUITOUS;
- else
- {
- /* Some port is ready. TAG tells us which. */
- types[tag] &= type;
- types[tag] |= SELECT_RETURNED;
- ++got;
- }
- break;
-
- default:
- /* Any other error kills us.
- But we must continue to loop to free the ports. */
- break;
+ /* We will wait again for a reply later. */
+ if (portset == MACH_PORT_NULL)
+ /* Create the portset to receive all the replies on. */
+ err = __mach_port_allocate (__mach_task_self (),
+ MACH_PORT_RIGHT_PORT_SET,
+ &portset);
+ if (! err)
+ /* Put this reply port in the port set. */
+ __mach_port_move_member (__mach_task_self (),
+ d[i].reply_port, portset);
}
+ break;
+
+ default:
+ /* No other error should happen. Callers of select don't
+ expect to see errors, so we simulate readiness of the erring
+ object and the next call hopefully will get the error again. */
+ type = SELECT_ALL;
+ /* FALLTHROUGH */
+
+ case 0:
+ /* We got an answer. */
+ if ((type & SELECT_ALL) == 0)
+ /* Bogus answer; treat like an error, as a fake positive. */
+ type = SELECT_ALL;
+
+ /* This port is already ready already. */
+ d[i].type &= type;
+ d[i].type |= SELECT_RETURNED;
+ ++got;
+ break;
}
- _hurd_port_free (&cells[i]->port, &ulink[i], ports[i]);
+ _hurd_port_free (&d[i].cell->port, &d[i].ulink, d[i].io_port);
}
/* Now wait for reply messages. */
- if (!err && got == 0 && port != MACH_PORT_NULL)
+ if (!err && got == 0)
{
/* Now wait for io_select_reply messages on PORT,
timing out as appropriate. */
error_t err;
mach_msg_type_t result_type;
int result;
- mach_msg_type_t tag_type;
- int tag;
} success;
} msg;
mach_msg_option_t options = (timeout == NULL ? 0 : MACH_RCV_TIMEOUT);
error_t msgerr;
while ((msgerr = __mach_msg (&msg.head,
MACH_RCV_MSG | options,
- 0, sizeof msg, port, to,
+ 0, sizeof msg, portset, to,
MACH_PORT_NULL)) == MACH_MSG_SUCCESS)
{
/* We got a message. Decode it. */
{
/* This is a properly formatted message so far.
See if it is a success or a failure. */
- if (msg.error.err)
+ if (msg.error.err == EINTR &&
+ msg.head.msgh_size == sizeof msg.error)
{
- err = msg.error.err;
- if (msg.head.msgh_size != sizeof msg.error)
- __mach_msg_destroy (&msg);
+ /* EINTR response; poll for further responses
+ and then return quickly. */
+ err = EINTR;
+ goto poll;
}
- else if (msg.head.msgh_size != sizeof msg.success ||
- *(int *) &msg.success.tag_type != *(int *) &inttype ||
- *(int *) &msg.success.result_type != *(int *) &inttype)
- __mach_msg_destroy (&msg);
- else if ((msg.success.result & SELECT_ALL) == 0 ||
- msg.success.tag < firstfd || msg.success.tag > lastfd)
- err = EGRATUITOUS;
- else
+ if (msg.error.err ||
+ msg.head.msgh_size != sizeof msg.success ||
+ *(int *) &msg.success.result_type != *(int *) &inttype ||
+ (msg.success.result & SELECT_ALL) == 0)
{
- /* This is a winning io_select_reply message!
- Record the readiness it indicates and send a reply. */
- types[msg.success.tag] &= msg.success.result;
- types[msg.success.tag] |= SELECT_RETURNED;
- ++got;
+ /* Error or bogus reply. Simulate readiness. */
+ __mach_msg_destroy (&msg);
+ msg.success.result = SELECT_ALL;
}
+
+ /* Look up the respondant's reply port and record its
+ readiness. */
+ {
+ int had = got;
+ for (i = firstfd; i <= lastfd; ++i)
+ if (d[i].type && d[i].reply_port == msg.head.msgh_local_port)
+ {
+ d[i].type &= msg.success.result;
+ d[i].type |= SELECT_RETURNED;
+ ++got;
+ }
+ assert (got > had);
+ }
}
if (msg.head.msgh_remote_port != MACH_PORT_NULL)
__mach_port_deallocate (__mach_task_self (),
msg.head.msgh_remote_port);
- if (got || err == EINTR)
+ if (got)
+ poll:
{
/* Poll for another message. */
to = 0;
message waiting. */
err = 0;
- if (got && err == EINTR)
- /* Some calls were interrupted, but at least one descriptor
- is known to be ready now, so we will return success. */
+ if (got)
+ /* At least one descriptor is known to be ready now, so we will
+ return success. */
err = 0;
}
- if (port != MACH_PORT_NULL)
- /* We must destroy the port if we made some select requests
- that might send notification on that port after we no longer care.
- If the port were reused, that notification could confuse the next
- select call to use the port. The notification might be valid,
- but the descriptor may have changed to a different server. */
- __mach_port_destroy (__mach_task_self (), port);
+ for (i = firstfd; i <= lastfd; ++i)
+ if (d[i].type)
+ __mach_port_destroy (__mach_task_self (), d[i].reply_port);
+ if (portset != MACH_PORT_NULL)
+ __mach_port_destroy (__mach_task_self (), portset);
if (err)
return __hurd_fail (err);
ones are initially set. */
for (i = firstfd; i <= lastfd; ++i)
{
- int type = types[i];
+ int type = d[i].type;
if ((type & SELECT_RETURNED) == 0)
type = 0;
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
ss = _hurd_self_sigstate ();
+ __spin_lock (&ss->critical_section_lock);
__spin_lock (&ss->lock);
old = ss->actions[sig];
if (act != NULL)
if (act != NULL && sig == SIGCHLD &&
(a.sa_flags & SA_NOCLDSTOP) != (old.sa_flags & SA_NOCLDSTOP))
{
- ss->critical_section = 1;
__spin_unlock (&ss->lock);
/* Inform the proc server whether or not it should send us SIGCHLD for
__proc_mod_stopchild (port, !(a.sa_flags & SA_NOCLDSTOP)));
__spin_lock (&ss->lock);
- ss->critical_section = 0;
pending = ss->pending & ~ss->blocked;
}
else
pending = 0;
__spin_unlock (&ss->lock);
+ __spin_unlock (&ss->critical_section_lock);
if (pending)
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
if (oact != NULL)
*oact = old;
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
if (pending)
/* Send a message to the signal thread so it
will wake up and check for pending signals. */
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
return 0;
}
-/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
if (pending)
/* Tell the signal thread to check for pending signals. */
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
/* Wait for the signal thread's message. */
__mach_msg (&msg, MACH_RCV_MSG, 0, sizeof (msg), wait,
if (pending)
/* Tell the signal thread to check for pending signals. */
- __msg_sig_post (_hurd_msgport, 0, __mach_task_self ());
-
+ __msg_sig_post (_hurd_msgport, 0, 0, __mach_task_self ());
+
/* We've been interrupted! And a good thing, too.
Otherwise we'd never return.
That's right; this function always returns an error. */
/* Pause execution for a number of nanoseconds. */
int
-nanosleep (const struct timespec *requested_time, struct time_spec *remaining)
+nanosleep (const struct timespec *requested_time, struct timespec *remaining)
{
errno = ENOSYS;
return -1;
#define USE_WIDE_CHAR 1
-#include "strtod.c"
+#include "../stdlib/strtod.c"
#define FLOAT_HUGE_VAL HUGE_VALf
#define USE_WIDE_CHAR 1
-#include "strtod.c"
+#include "../stdlib/strtod.c"
#define USE_WIDE_CHAR 1
-#include "strtol.c"
+#include "../stdlib/strtol.c"
#define FLOAT_HUGE_VAL HUGE_VALl
#define USE_WIDE_CHAR 1
-#include "strtod.c"
+#include "../stdlib/strtod.c"
/* Internal header containing implementation of wcwidth() function.
Copyright (C) 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
-Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edi>, 1996.
+Contributed by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1996.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
Boston, MA 02111-1307, USA. */
#include <wchar.h>
-#include "cname-lookup.h"
+#include "../wctype/cname-lookup.h"
/* Array containing width information. */
extern unsigned char *__ctype_width;
projects / thirdparty / glibc.git / commitdiff
