/* Called by MiG to get a reply port. */ mach_port_t __mig_get_reply_port (void) { if (reply_port == MACH_PORT_NULL) reply_port = __mach_reply_port (); return reply_port; }
/* This function must be very careful not to depend on Hurd threadvar variables. We arrange that by using special stubs arranged for at the end of this file. */ static void profile_waiter (void) { mach_msg_header_t msg; mach_port_t timeout_reply_port; profil_reply_port = __mach_reply_port (); timeout_reply_port = __mach_reply_port (); while (1) { __spin_lock (&lock); fetch_samples (); __spin_unlock (&lock); __mach_msg (&msg, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof msg, timeout_reply_port, collector_timeout, MACH_PORT_NULL); } }
error_t __hurd_file_name_lookup_retry (error_t (*use_init_port) (int which, error_t (*operate) (file_t)), file_t (*get_dtable_port) (int fd), error_t (*lookup) (file_t dir, char *name, int flags, mode_t mode, retry_type *do_retry, string_t retry_name, mach_port_t *result), enum retry_type doretry, char retryname[1024], int flags, mode_t mode, file_t *result) { error_t err; char *file_name; int nloops; error_t lookup_op (file_t startdir) { if (file_name[0] == '/' && file_name[1] != '\0') { while (file_name[1] == '/') /* Remove double leading slash. */ file_name++; if (file_name[1] != '\0') /* Remove leading slash when we have more than the slash. */ file_name++; } return lookup_error ((*lookup) (startdir, file_name, flags, mode, &doretry, retryname, result)); } error_t reauthenticate (file_t unauth) { error_t err; mach_port_t ref = __mach_reply_port (); error_t reauth (auth_t auth) { return __auth_user_authenticate (auth, ref, MACH_MSG_TYPE_MAKE_SEND, result); } err = __io_reauthenticate (unauth, ref, MACH_MSG_TYPE_MAKE_SEND); if (! err) err = (*use_init_port) (INIT_PORT_AUTH, &reauth); __mach_port_destroy (__mach_task_self (), ref); __mach_port_deallocate (__mach_task_self (), unauth); return err; }
/* Make the process sleep for SECONDS seconds, or until a signal arrives and is not ignored. The function returns the number of seconds less than SECONDS which it actually slept (zero if it slept the full time). There is no return value to indicate error, but if `sleep' returns SECONDS, it probably didn't work. */ unsigned int __sleep (unsigned int seconds) { time_t before, after; mach_port_t recv; recv = __mach_reply_port (); before = time ((time_t *) NULL); (void) __mach_msg (NULL, MACH_RCV_MSG|MACH_RCV_TIMEOUT|MACH_RCV_INTERRUPT, 0, 0, recv, seconds * 1000, MACH_PORT_NULL); after = time ((time_t *) NULL); __mach_port_destroy (__mach_task_self (), recv); return seconds - (after - before); }
/* Sleep USECONDS microseconds, or until a previously set timer goes off. */ int usleep (useconds_t useconds) { mach_port_t recv; struct timeval before, after; recv = __mach_reply_port (); if (__gettimeofday (&before, NULL) < 0) return -1; (void) __mach_msg (NULL, MACH_RCV_MSG|MACH_RCV_TIMEOUT|MACH_RCV_INTERRUPT, 0, 0, recv, (useconds + 999) / 1000, MACH_PORT_NULL); __mach_port_destroy (mach_task_self (), recv); if (__gettimeofday (&after, NULL) < 0) return -1; return 0; }
int __libc_nanosleep (const struct timespec *requested_time, struct timespec *remaining) { mach_port_t recv; struct timeval before, after; if (requested_time->tv_sec < 0 || requested_time->tv_nsec < 0 || requested_time->tv_nsec >= 1000000000) { errno = EINVAL; return -1; } const mach_msg_timeout_t ms = requested_time->tv_sec * 1000 + (requested_time->tv_nsec + 999999) / 1000000; recv = __mach_reply_port (); if (remaining && __gettimeofday (&before, NULL) < 0) return -1; error_t err = __mach_msg (NULL, MACH_RCV_MSG|MACH_RCV_TIMEOUT|MACH_RCV_INTERRUPT, 0, 0, recv, ms, MACH_PORT_NULL); __mach_port_destroy (mach_task_self (), recv); if (err == EMACH_RCV_INTERRUPTED) { if (remaining && __gettimeofday (&after, NULL) >= 0) { struct timeval req_time, elapsed, rem; TIMESPEC_TO_TIMEVAL (&req_time, requested_time); timersub (&after, &before, &elapsed); timersub (&req_time, &elapsed, &rem); TIMEVAL_TO_TIMESPEC (&rem, remaining); } errno = EINTR; return -1; } return 0; }
/* Check the first NFDS descriptors either in POLLFDS (if nonnnull) or in each of READFDS, WRITEFDS, EXCEPTFDS that is nonnull. If TIMEOUT is not NULL, time out after waiting the interval specified therein. Returns the number of ready descriptors, or -1 for errors. */ int _hurd_select (int nfds, struct pollfd *pollfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask) { int i; mach_port_t portset; int got; error_t err; fd_set rfds, wfds, xfds; int firstfd, lastfd; mach_msg_timeout_t to = 0; struct { struct hurd_userlink ulink; struct hurd_fd *cell; mach_port_t io_port; int type; mach_port_t reply_port; } d[nfds]; sigset_t oset; union typeword /* Use this to avoid unkosher casts. */ { mach_msg_type_t type; uint32_t word; }; assert (sizeof (union typeword) == sizeof (mach_msg_type_t)); assert (sizeof (uint32_t) == sizeof (mach_msg_type_t)); if (nfds < 0 || (pollfds == NULL && nfds > FD_SETSIZE)) { errno = EINVAL; return -1; } if (timeout != NULL) { if (timeout->tv_sec < 0 || timeout->tv_nsec < 0) { errno = EINVAL; return -1; } to = (timeout->tv_sec * 1000 + (timeout->tv_nsec + 999999) / 1000000); } if (sigmask && __sigprocmask (SIG_SETMASK, sigmask, &oset)) return -1; if (pollfds) { /* Collect interesting descriptors from the user's `pollfd' array. We do a first pass that reads the user's array before taking any locks. The second pass then only touches our own stack, and gets the port references. */ for (i = 0; i < nfds; ++i) if (pollfds[i].fd >= 0) { int type = 0; if (pollfds[i].events & POLLIN) type |= SELECT_READ; if (pollfds[i].events & POLLOUT) type |= SELECT_WRITE; if (pollfds[i].events & POLLPRI) type |= SELECT_URG; d[i].io_port = pollfds[i].fd; d[i].type = type; } else d[i].type = 0; HURD_CRITICAL_BEGIN; __mutex_lock (&_hurd_dtable_lock); for (i = 0; i < nfds; ++i) if (d[i].type != 0) { const int fd = (int) d[i].io_port; if (fd < _hurd_dtablesize) { d[i].cell = _hurd_dtable[fd]; d[i].io_port = _hurd_port_get (&d[i].cell->port, &d[i].ulink); if (d[i].io_port != MACH_PORT_NULL) continue; } /* If one descriptor is bogus, we fail completely. */ while (i-- > 0) if (d[i].type != 0) _hurd_port_free (&d[i].cell->port, &d[i].ulink, d[i].io_port); break; } __mutex_unlock (&_hurd_dtable_lock); HURD_CRITICAL_END; if (i < nfds) { if (sigmask) __sigprocmask (SIG_SETMASK, &oset, NULL); errno = EBADF; return -1; } lastfd = i - 1; firstfd = i == 0 ? lastfd : 0; } else { /* Collect interested descriptors from the user's fd_set arguments. Use local copies so we can't crash from user bogosity. */ if (readfds == NULL) FD_ZERO (&rfds); else rfds = *readfds; if (writefds == NULL) FD_ZERO (&wfds); else wfds = *writefds; if (exceptfds == NULL) FD_ZERO (&xfds); else xfds = *exceptfds; HURD_CRITICAL_BEGIN; __mutex_lock (&_hurd_dtable_lock); if (nfds > _hurd_dtablesize) nfds = _hurd_dtablesize; /* Collect the ports for interesting FDs. */ firstfd = lastfd = -1; for (i = 0; i < nfds; ++i) { int type = 0; if (readfds != NULL && FD_ISSET (i, &rfds)) type |= SELECT_READ; if (writefds != NULL && FD_ISSET (i, &wfds)) type |= SELECT_WRITE; if (exceptfds != NULL && FD_ISSET (i, &xfds)) type |= SELECT_URG; d[i].type = type; if (type) { 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) if (d[i].type != 0) _hurd_port_free (&d[i].cell->port, &d[i].ulink, d[i].io_port); break; } lastfd = i; if (firstfd == -1) firstfd = i; } } __mutex_unlock (&_hurd_dtable_lock); HURD_CRITICAL_END; if (i < nfds) { if (sigmask) __sigprocmask (SIG_SETMASK, &oset, NULL); errno = EBADF; return -1; } } err = 0; got = 0; /* Send them all io_select request messages. */ if (firstfd == -1) /* But not if there were no ports to deal with at all. We are just a pure timeout. */ portset = __mach_reply_port (); else { portset = MACH_PORT_NULL; for (i = firstfd; i <= lastfd; ++i) if (d[i].type) { int type = d[i].type; d[i].reply_port = __mach_reply_port (); err = __io_select (d[i].io_port, d[i].reply_port, /* Poll only if there's a single descriptor. */ (firstfd == lastfd) ? to : 0, &type); switch (err) { case MACH_RCV_TIMED_OUT: /* No immediate response. This is normal. */ err = 0; if (firstfd == lastfd) /* When there's a single descriptor, we don't need a portset, so just pretend we have one, but really use the single reply port. */ portset = d[i].reply_port; else if (got == 0) /* We've got multiple reply ports, so we need a port set to multiplex them. */ { /* 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 (&d[i].cell->port, &d[i].ulink, d[i].io_port); } } /* Now wait for reply messages. */ if (!err && got == 0) { /* Now wait for io_select_reply messages on PORT, timing out as appropriate. */ union { mach_msg_header_t head; #ifdef MACH_MSG_TRAILER_MINIMUM_SIZE struct { mach_msg_header_t head; NDR_record_t ndr; error_t err; } error; struct { mach_msg_header_t head; NDR_record_t ndr; error_t err; int result; mach_msg_trailer_t trailer; } success; #else struct { mach_msg_header_t head; union typeword err_type; error_t err; } error; struct { mach_msg_header_t head; union typeword err_type; error_t err; union typeword result_type; int result; } success; #endif } msg; mach_msg_option_t options = (timeout == NULL ? 0 : MACH_RCV_TIMEOUT); error_t msgerr; while ((msgerr = __mach_msg (&msg.head, MACH_RCV_MSG | MACH_RCV_INTERRUPT | options, 0, sizeof msg, portset, to, MACH_PORT_NULL)) == MACH_MSG_SUCCESS) { /* We got a message. Decode it. */ #define IO_SELECT_REPLY_MSGID (21012 + 100) /* XXX */ #ifdef MACH_MSG_TYPE_BIT const union typeword inttype = { type: { MACH_MSG_TYPE_INTEGER_T, sizeof (integer_t) * 8, 1, 1, 0, 0 } }; #endif if (msg.head.msgh_id == IO_SELECT_REPLY_MSGID && msg.head.msgh_size >= sizeof msg.error && !(msg.head.msgh_bits & MACH_MSGH_BITS_COMPLEX) && #ifdef MACH_MSG_TYPE_BIT msg.error.err_type.word == inttype.word #endif ) { /* This is a properly formatted message so far. See if it is a success or a failure. */ if (msg.error.err == EINTR && msg.head.msgh_size == sizeof msg.error) { /* EINTR response; poll for further responses and then return quickly. */ err = EINTR; goto poll; } if (msg.error.err || msg.head.msgh_size != sizeof msg.success || #ifdef MACH_MSG_TYPE_BIT msg.success.result_type.word != inttype.word || #endif (msg.success.result & SELECT_ALL) == 0) { /* Error or bogus reply. Simulate readiness. */ __mach_msg_destroy (&msg.head); msg.success.result = SELECT_ALL; } /* Look up the respondent's reply port and record its readiness. */ { int had = got; if (firstfd != -1) 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) poll: { /* Poll for another message. */ to = 0; options |= MACH_RCV_TIMEOUT; } } if (msgerr == MACH_RCV_INTERRUPTED) /* Interruption on our side (e.g. signal reception). */ err = EINTR; if (got) /* At least one descriptor is known to be ready now, so we will return success. */ err = 0; }
You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include <ansidecl.h> #include <errno.h> #include <mach.h> #include <sys/time.h> /* Sleep USECONDS microseconds, or until a previously set timer goes off. */ unsigned int DEFUN(usleep, (useconds), unsigned int useconds) { mach_port_t recv; struct timeval before, after; recv = __mach_reply_port (); if (__gettimeofday (&before, NULL) < 0) return useconds; (void) __mach_msg (NULL, MACH_RCV_MSG|MACH_RCV_TIMEOUT|MACH_RCV_INTERRUPT, 0, 0, recv, (useconds + 999) / 1000, MACH_PORT_NULL); __mach_port_destroy (mach_task_self (), recv); if (__gettimeofday (&after, NULL) < 0) return 0; return useconds - (((after.tv_sec - before.tv_sec) * 1000000) + (after.tv_usec - before.tv_usec)); }
assert (__sigismember (&mask, signo)); /* Make sure this signal is unblocked */ __sigdelset (&ss->blocked, signo); return pe->handler; } void handler (int sig) { assert (sig == signo); longjmp (buf, 1); } wait = __mach_reply_port (); if (set != NULL) /* Crash before locking */ mask = *set; else __sigemptyset (&mask); ss = _hurd_self_sigstate (); __spin_lock (&ss->lock); /* See if one of these signals is currently pending. */ __sigandset (&ready, &ss->pending, &mask); if (! __sigisemptyset (&ready)) { for (signo = 1; signo < NSIG; signo++)