long int rlimit;
if (first_fd < 0)
- {
- errno = EINVAL;
- return NULL;
- }
+ return __hurd_fail (EINVAL), NULL;
crit = _hurd_critical_section_lock ();
if (size * sizeof (*_hurd_dtable) < size)
{
/* Integer overflow! */
- errno = ENOMEM;
+ __hurd_fail (ENOMEM);
goto out;
}
goto search;
}
else
- errno = ENOMEM;
+ __hurd_fail (ENOMEM);
}
else
- errno = EMFILE;
+ __hurd_fail (EMFILE);
}
else
- errno = EINVAL; /* Bogus FIRST_FD value. */
+ __hurd_fail (EINVAL); /* Bogus FIRST_FD value. */
out:
__mutex_unlock (&_hurd_dtable_lock);
/* Check the access mode. */
if ((pflags & needflags) != needflags)
- {
- errno = EBADF;
- return NULL;
- }
+ return __hurd_fail (EBADF), NULL;
return fopencookie ((void *) (uintptr_t) port,
mode, funcsio);
so we don't bother allocating a real table. */
if (_hurd_init_dtable == NULL)
- {
- /* Never had a descriptor table. */
- errno = EBADF;
- return MACH_PORT_NULL;
- }
+ /* Never had a descriptor table. */
+ return __hurd_fail (EBADF), MACH_PORT_NULL;
if (fd < 0 || (unsigned int) fd > _hurd_init_dtablesize
|| _hurd_init_dtable[fd] == MACH_PORT_NULL)
- {
- errno = EBADF;
- return MACH_PORT_NULL;
- }
+ return __hurd_fail (EBADF), MACH_PORT_NULL;
else
{
__mach_port_mod_refs (__mach_task_self (), _hurd_init_dtable[fd],
struct hurd_sigstate *ss = NULL;
if (nfds < 0 || (pollfds == NULL && nfds > FD_SETSIZE))
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
#define IO_SELECT_REPLY_MSGID (21012 + 100) /* XXX */
#define IO_SELECT_TIMEOUT_REPLY_MSGID (21031 + 100) /* XXX */
struct timespec now;
if (timeout->tv_sec < 0 || ! valid_nanoseconds (timeout->tv_nsec))
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
err = __clock_gettime (CLOCK_REALTIME, &now);
if (err)
{
if (sigmask)
__sigprocmask (SIG_SETMASK, &oset, NULL);
- errno = EBADF;
- return -1;
+ return __hurd_fail (EBADF);
}
if (nfds > _hurd_dtablesize)
socket_t server;
if (domain < 0)
- {
- errno = EAFNOSUPPORT;
- return MACH_PORT_NULL;
- }
+ return __hurd_fail (EAFNOSUPPORT), MACH_PORT_NULL;
retry:
HURD_CRITICAL_BEGIN;
if (server == MACH_PORT_NULL && errno == ENOENT)
/* If the server node is absent, we don't support that protocol. */
- errno = EAFNOSUPPORT;
+ __hurd_fail (EAFNOSUPPORT);
__mutex_unlock (&lock);
HURD_CRITICAL_END;
__mutex_unlock (&_hurd_rlimit_lock);
if (addr - brk_start > rlimit)
- {
- /* Need to increase the resource limit. */
- errno = ENOMEM;
- return -1;
- }
+ /* Need to increase the resource limit. */
+ return __hurd_fail (ENOMEM);
if (pagend > _hurd_data_end)
{
error_t err;
if (dirp == NULL)
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
__libc_lock_lock (dirp->__lock);
err = __vm_deallocate (__mach_task_self (),
#include <libc-lock.h>
#include <errno.h>
+#include <hurd.h>
#include <stdlib.h>
#include <pthreadP.h>
weak_function
__cthread_keycreate (__cthread_key_t *key)
{
- __set_errno (ENOSYS);
- *key = -1;
- return -1;
+ *key = -1;
+ return __hurd_fail (ENOSYS);
}
/* Placeholder for key retrieval routine from Hurd cthreads library. */
__cthread_getspecific (__cthread_key_t key, void **pval)
{
*pval = NULL;
- __set_errno (ENOSYS);
- return -1;
+ return __hurd_fail (ENOSYS);
}
/* Placeholder for key setting routine from Hurd cthreads library. */
weak_function
__cthread_setspecific (__cthread_key_t key, void *val)
{
- __set_errno (ENOSYS);
- return -1;
+ return __hurd_fail (ENOSYS);
}
#include <dirent.h>
#include <dirstream.h>
+#include <hurd.h>
#include <hurd/fd.h>
#include <errno.h>
if (_hurd_dtable[fd] == dirp->__fd)
break;
if (fd == _hurd_dtablesize)
- {
- errno = EINVAL;
- fd = -1;
- }
+ fd = __hurd_fail (EINVAL);
__mutex_unlock (&_hurd_dtable_lock);
HURD_CRITICAL_END;
MACH_PORT_RIGHT_SEND, +1);
return _dl_hurd_data->dtable[fd];
}
- errno = EBADF;
- return MACH_PORT_NULL;
+ return __hurd_fail (EBADF), MACH_PORT_NULL;
}
assert (!(flags & ~(O_READ | O_EXEC | O_CLOEXEC | O_IGNORE_CTTY)));
__writev (int fd, const struct iovec *iov, int niov)
{
if (fd >= _hurd_init_dtablesize)
- {
- errno = EBADF;
- return -1;
- }
+ return __hurd_fail (EBADF);
int i;
size_t total = 0;
int weak_function
__access (const char *file, int type)
{
- errno = ENOSYS;
- return -1;
+ return __hurd_fail (ENOSYS);
}
check_no_hidden(__access_noerrno);
int weak_function
char *weak_function
__getcwd (char *buf, size_t size)
{
- errno = ENOSYS;
- return NULL;
+ return __hurd_fail (ENOSYS), NULL;
}
/* This is used by dl-tunables.c to strdup strings. We can just make this a
{
fd2 = -1;
if (errno == EINVAL)
- errno = EBADF; /* POSIX.1-1990 6.2.1.2 ll 54-55. */
+ __hurd_fail (EBADF); /* POSIX.1-1990 6.2.1.2 ll 54-55. */
}
else
{
#include <sys/types.h>
#include <sys/file.h>
#include <fcntl.h>
+#include <hurd.h>
#include <unistd.h>
#include <errno.h>
case F_WRLCK: cmd = LOCK_EX; break;
case F_UNLCK: cmd = LOCK_UN; break;
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
if (cmd != LOCK_UN && wait == 0)
/* FALLTHROUGH */
case SEEK_CUR:
case SEEK_END:
- errno = ENOTSUP;
- return -1;
+ return __hurd_fail (ENOTSUP);
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
return __flock (fd, cmd);
error_t err;
default: /* Bad command. */
- errno = EINVAL;
- result = -1;
+ result = __hurd_fail (EINVAL);
break;
/* First the descriptor-based commands, which do no RPCs. */
cmd = F_SETLKW64;
break;
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
struct flock64 fl64 = {
switch (cmd)
{
case F_GETLK64:
- errno = ENOSYS;
- return -1;
+ return __hurd_fail (ENOSYS);
case F_SETLKW64:
wait = 1;
/* FALLTHROUGH */
return __f_setlk (fd, fl->l_type, fl->l_whence,
fl->l_start, fl->l_len, wait);
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
}
else if (cmd == F_GETLK64)
&& fl->l_start != fl64.l_start)
|| (sizeof fl->l_len != sizeof fl64.l_len
&& fl->l_len != fl64.l_len))
- {
- errno = EOVERFLOW;
- return -1;
- }
+ return __hurd_fail (EOVERFLOW);
}
result = err ? __hurd_dfail (fd, err) : 0;
switch (cmd)
{
case F_GETLK64:
- errno = ENOSYS;
- return -1;
+ return __hurd_fail (ENOSYS);
case F_SETLKW64:
wait = 1;
/* FALLTHROUGH */
return __f_setlk (fd, fl->l_type, fl->l_whence,
fl->l_start, fl->l_len, wait);
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
}
struct hurd_fd *d = _hurd_fd_get (fd);
if (d == NULL)
- {
- errno = EBADF;
- return NULL;
- }
+ return __hurd_fail (EBADF), NULL;
/* Ensure that it's a directory. */
error_t err = HURD_FD_PORT_USE
}));
if (err)
- {
- errno = err;
- return NULL;
- }
+ return __hurd_dfail (fd, err), NULL;
return _hurd_fd_opendir (d);
}
if (size <= 0)
{
if (buf != NULL)
- {
- errno = EINVAL;
- return NULL;
- }
+ return __hurd_fail (EINVAL), NULL;
size = FILENAME_MAX * 4 + 1; /* Good starting guess. */
}
if (offset < d->d_namlen + 1)
{
if (orig_size > 0)
- {
- errno = ERANGE;
- return NULL;
- }
+ return __hurd_fail (ERANGE), NULL;
else
{
size *= 2;
__mutex_lock (&_hurd_id.lock);
if (err = _hurd_check_ids ())
- {
- errno = err;
- egid = -1;
- }
+ egid = __hurd_fail (err);
else if (_hurd_id.gen.ngids >= 1)
egid = _hurd_id.gen.gids[0];
else if (_hurd_id.aux.ngids >= 1)
/* We have no effective gids. Return the real gid. */
egid = _hurd_id.aux.gids[0];
else
- {
- /* We do not even have a real gid. */
- errno = EGRATUITOUS;
- egid = -1;
- }
+ /* We do not even have a real gid. */
+ egid = __hurd_fail (EGRATUITOUS);
__mutex_unlock (&_hurd_id.lock);
HURD_CRITICAL_END;
#include <assert.h>
#include <errno.h>
#include <unistd.h>
+#include <hurd.h>
/* Write LENGTH bytes of randomness starting at BUFFER. Return 0 on
success and -1 on failure. */
/* The interface is documented to return EIO for buffer lengths
longer than 256 bytes. */
if (length > 256)
- {
- __set_errno (EIO);
- return -1;
- }
+ return __hurd_fail (EIO);
/* Try to fill the buffer completely. Even with the 256 byte limit
above, we might still receive an EINTR error (when blocking
return -1;
}
if (bytes == 0)
- {
- /* No more bytes available. This should not happen under
- normal circumstances. */
- __set_errno (EIO);
- return -1;
- }
+ /* No more bytes available. This should not happen under
+ normal circumstances. */
+ return __hurd_fail (EIO);
/* Try again in case of a short read. */
buffer += bytes;
}
__mutex_lock (&_hurd_id.lock);
if (err = _hurd_check_ids ())
- {
- errno = err;
- euid = -1;
- }
+ euid = __hurd_fail (err);
else if (_hurd_id.gen.nuids >= 1)
euid = _hurd_id.gen.uids[0];
else if (_hurd_id.aux.nuids >= 1)
/* We have no effective uids. Return the real uid. */
euid = _hurd_id.aux.uids[0];
else
- {
- /* We do not even have a real uid. */
- errno = EGRATUITOUS;
- euid = -1;
- }
+ /* We do not even have a real uid. */
+ euid = __hurd_fail (EGRATUITOUS);
__mutex_unlock (&_hurd_id.lock);
HURD_CRITICAL_END;
__mutex_lock (&_hurd_id.lock);
if (err = _hurd_check_ids ())
- {
- errno = err;
- gid = -1;
- }
+ gid = __hurd_fail (err);
else if (_hurd_id.aux.ngids >= 1)
gid = _hurd_id.aux.gids[0];
else
- {
- /* We do not even have a real gid. */
- errno = EGRATUITOUS;
- gid = -1;
- }
+ /* We do not even have a real gid. */
+ gid = __hurd_fail (EGRATUITOUS);
__mutex_unlock (&_hurd_id.lock);
HURD_CRITICAL_END;
error_t err;
if (err = __USEPORT (PROC, __proc_getlogin (port, login)))
- {
- errno = err;
- return NULL;
- }
+ return __hurd_fail (err), NULL;
return login;
}
error_t err;
if (err = __USEPORT (PROC, __proc_getlogin (port, login)))
- return errno = err;
+ return __hurd_fail (err), err;
size_t len = __strnlen (login, sizeof login - 1) + 1;
if (len > name_len)
- {
- errno = ERANGE;
- return errno;
- }
+ return __hurd_fail (ERANGE), ERANGE;
memcpy (name, login, len);
return 0;
struct rlimit lim;
if (rlimits == NULL || (unsigned int) resource >= RLIMIT_NLIMITS)
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
HURD_CRITICAL_BEGIN;
__mutex_lock (&_hurd_rlimit_lock);
__mutex_lock (&_hurd_id.lock);
if (err = _hurd_check_ids ())
- {
- errno = err;
- uid = -1;
- }
+ uid = __hurd_fail (err);
else if (_hurd_id.aux.nuids >= 1)
uid = _hurd_id.aux.uids[0];
else
- {
- /* We do not even have a real uid. */
- errno = EGRATUITOUS;
- uid = -1;
- }
+ /* We do not even have a real uid. */
+ uid = __hurd_fail (EGRATUITOUS);
__mutex_unlock (&_hurd_id.lock);
HURD_CRITICAL_END;
struct hurd_userlink *link = (void *) &scp[1];
if (__glibc_unlikely (scp == NULL || (scp->sc_mask & _SIG_CANT_MASK)))
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
ss = _hurd_self_sigstate ();
_hurd_sigstate_lock (ss);
return 0;
if (strlen (ifname) >= IFNAMSIZ)
- {
- __set_errno (ENODEV);
- return 0;
- }
+ return __hurd_fail (ENODEV), 0;
strncpy (ifr.ifr_name, ifname, IFNAMSIZ);
if (__ioctl (fd, SIOCGIFINDEX, &ifr) < 0)
int saved_errno = errno;
__close (fd);
if (saved_errno == EINVAL || saved_errno == ENOTTY)
- __set_errno (ENOSYS);
+ __hurd_fail (ENOSYS);
return 0;
}
__close (fd);
int saved_errno = errno;
__close (fd);
if (saved_errno == EINVAL || saved_errno == ENOTTY)
- __set_errno (ENOSYS);
+ __hurd_fail (ENOSYS);
else if (saved_errno == ENODEV)
- __set_errno (ENXIO);
+ __hurd_fail (ENXIO);
return NULL;
}
__close (fd);
if (len % sizeof (struct ifreq) != 0)
{
__munmap (data, len);
- errno = EGRATUITOUS;
+ __hurd_fail (EGRATUITOUS);
goto out;
}
*num_ifs = len / sizeof (struct ifreq);
if (act != NULL && act->sa_handler != SIG_DFL
&& ((__sigmask (sig) & _SIG_CANT_MASK) || act->sa_handler == SIG_ERR))
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
/* Copy so we fault before taking locks. */
if (act != NULL)
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
+#include <hurd.h>
/* Seek to OFFSET on FD, starting from WHENCE. */
off_t
off_t res = (off_t) res64;
if (sizeof res != sizeof res64 && res != res64)
- {
- __set_errno (EOVERFLOW);
- return (off_t) -1;
- }
+ return (off_t) __hurd_fail (EOVERFLOW);
return res;
}
len = 0;
}
else
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
if (translator != NULL && ! S_ISFIFO (mode))
{
#include <sys/mman.h>
#include <sys/types.h>
#include <mach/port.h>
+#include <hurd.h>
/* Map addresses starting near ADDR and extending for LEN bytes. From
OFFSET into the file FD describes according to PROT and FLAGS. If ADDR
vm_offset_t small_offset = (vm_offset_t) offset;
if (small_offset != offset)
- {
- /* We cannot do this since the offset is too large. */
- __set_errno (EOVERFLOW);
- return MAP_FAILED;
- }
+ /* We cannot do this since the offset is too large. */
+ return __hurd_fail (EOVERFLOW), MAP_FAILED;
return __mmap (addr, len, prot, flags, fd, small_offset);
}
DIR *dirp;
if (d == NULL)
- {
- errno = EBADF;
- return NULL;
- }
+ return __hurd_fail (EBADF), NULL;
dirp = (DIR *) malloc (sizeof (DIR));
if (dirp == NULL)
__opendirat (int dfd, const char *name)
{
if (name[0] == '\0')
- {
- /* POSIX.1-1990 says an empty name gets ENOENT;
- but `open' might like it fine. */
- __set_errno (ENOENT);
- return NULL;
- }
+ /* POSIX.1-1990 says an empty name gets ENOENT;
+ but `open' might like it fine. */
+ return __hurd_fail (ENOENT), NULL;
int flags = O_RDONLY | O_NONBLOCK | O_DIRECTORY | O_CLOEXEC;
int fd;
return __opendirat (AT_FDCWD, name);
#else
if (name[0] == '\0')
- {
- /* POSIX.1-1990 says an empty name gets ENOENT;
- but `open' might like it fine. */
- __set_errno (ENOENT);
- return NULL;
- }
+ /* POSIX.1-1990 says an empty name gets ENOENT;
+ but `open' might like it fine. */
+ return __hurd_fail (ENOENT), NULL;
int fd = __open (name, O_RDONLY | O_NONBLOCK | O_DIRECTORY);
if (fd < 0)
}
default:
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
return 0;
int ttype;
if (HURD_DPORT_USE (fd, __term_get_bottom_type (port, &ttype)) == 0)
- {
- /* get_bottom_type suceeded, this is the slave side. */
- errno = ENOTTY;
- return ENOTTY;
- }
+ /* get_bottom_type suceeded, this is the slave side. */
+ return __hurd_fail (ENOTTY), ENOTTY;
if (err = HURD_DPORT_USE (fd, __term_get_peername (port, peername)))
{
len = __strnlen (peername, sizeof peername - 1) + 1;
if (len > buflen)
- {
- errno = ERANGE;
- return ERANGE;
- }
+ return __hurd_fail (ERANGE), ERANGE;
if (stp)
{
#include <unistd.h>
#include <endian.h>
#include <assert.h>
+#include <hurd.h>
/* Read a directory entry from DIRP. */
struct dirent *
- sizeof entry->d_ino);
const ino_t d_ino = entry64->d_ino;
if (d_ino != entry64->d_ino)
- {
- __set_errno (EOVERFLOW);
- return NULL;
- }
+ return __hurd_fail (EOVERFLOW), NULL;
# if BYTE_ORDER != BIG_ENDIAN /* We just skipped over the zero high word. */
entry->d_ino = d_ino; /* ... or the nonzero low word, swap it. */
# endif
struct dirent64 *dp;
if (dirp == NULL)
- {
- errno = EINVAL;
- return NULL;
- }
+ return __hurd_fail (EINVAL), NULL;
__libc_lock_lock (dirp->__lock);
error_t err = 0;
if (dirp == NULL)
- {
- errno = EINVAL;
- return errno;
- }
+ return __hurd_fail (EINVAL), EINVAL;
__libc_lock_lock (dirp->__lock);
{
err = __vm_allocate (__mach_task_self (), &data.addr, len, 1);
if (err)
- {
- __set_errno (err);
- return -1;
- }
+ return __hurd_fail (err);
dealloc = 1;
}
else
struct rlimit lim;
if (rlimits == NULL || (unsigned int) resource >= RLIMIT_NLIMITS)
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
lim = *rlimits;
{
/* Can't disable a stack that is in use. */
__spin_unlock (&s->lock);
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
old = s->sigaltstack;
sigset_t pending;
if (set == NULL)
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
ss = _hurd_self_sigstate ();
_hurd_sigstate_lock (ss);
default:
_hurd_sigstate_unlock (ss);
- errno = EINVAL;
- return -1;
+ return __hurd_fail (EINVAL);
}
ss->blocked &= ~_SIG_CANT_MASK;
/* We've been interrupted! And a good thing, too.
Otherwise we'd never return.
That's right; this function always returns an error. */
- errno = EINTR;
- return -1;
+ return __hurd_fail (EINTR);
}
libc_hidden_def (__sigsuspend)
weak_alias (__sigsuspend, sigsuspend)
MACH_PORT_RIGHT_SEND, +1);
return dtable[fd];
}
- errno = EBADF;
- return MACH_PORT_NULL;
+ return __hurd_fail (EBADF), MACH_PORT_NULL;
}
inline error_t child_lookup (const char *file, int oflag, mode_t mode,
file_t *result)
#include <errno.h>
#include <sys/stat.h>
+#include <hurd.h>
static inline int
stat64_conv (struct stat *buf, const struct stat64 *buf64)
&& buf->st_size != buf64->st_size)
|| (sizeof buf->st_blocks != sizeof buf64->st_blocks
&& buf->st_blocks != buf64->st_blocks))
- {
- __set_errno (EOVERFLOW);
- return -1;
- }
+ return __hurd_fail (EOVERFLOW);
return 0;
}
#include <sys/statfs.h>
#include <errno.h>
+#include <hurd.h>
static inline int
statfs64_conv (struct statfs *buf, const struct statfs64 *buf64)
# define DO(memb) \
buf->memb = buf64->memb; \
if (sizeof buf->memb != sizeof buf64->memb && buf->memb != buf64->memb) \
- { \
- __set_errno (EOVERFLOW); \
- return -1; \
- }
+ return __hurd_fail (EOVERFLOW);
DO (f_type);
DO (f_bsize);
len = strlen (nodename) + 1;
if (len > buflen)
- {
- errno = ERANGE;
- return errno;
- }
+ return __hurd_fail (ERANGE), ERANGE;
memcpy (buf, nodename, len);
return 0;
const char *file;
if ((flag &~ AT_REMOVEDIR) != 0)
- {
- __set_errno (EINVAL);
- return -1;
- }
+ return __hurd_fail (EINVAL);
dir = __directory_name_split_at (fd, name, (char **) &file);
if (dir == MACH_PORT_NULL)
break;
default:
invalid:
- __set_errno (EINVAL);
- return -1;
+ return __hurd_fail (EINVAL);
}
/* Technically we're supposed to return EFAULT if infop is bogus,
We just check for a null pointer. */
if (infop == NULL)
- {
- __set_errno (EFAULT);
- return -1;
- }
+ return __hurd_fail (EFAULT);
cancel_oldtype = LIBC_CANCEL_ASYNC();
#if HURD_INTERFACE_VERSION >= 20201227
struct hurd_userlink *link = (void *) &scp[1];
if (__glibc_unlikely (scp == NULL || (scp->sc_mask & _SIG_CANT_MASK)))
- {
- errno = EINVAL;
- return -1;
- }
+ return __hurd_fail (EINVAL);
ss = _hurd_self_sigstate ();
_hurd_sigstate_lock (ss);
projects / thirdparty / glibc.git / commitdiff
