glibc/sysdeps/mach/hurd/sysd-stdio.c
Roland McGrath 93a470c71a Tue May 7 10:51:52 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>
* wcsmbs/wcwidth.c, wcsmbs/wcswidth.c: Fixed typos.

	* sysdeps/unix/sysv/linux/sys/mman.h: Fixed typo.

	* sysdeps/stub/sched_getp.c: Add missing #include <sys/types.h>.
	* sysdeps/stub/sched_sets.c: Likewise.
	* sysdeps/stub/sched_setp.c: Likewise.
	* sysdeps/stub/sched_rr_gi.c: Likewise.
	* sysdeps/stub/sched_gets.c: Likewise.

	* hurd/hurdsig.c: Use struct hurd_signal_detail.
	* hurd/hurd/fd.h (_hurd_fd_error): Likewise.
	* sysdeps/mach/hurd/sysd-stdio.c (fd_fail): Likewise.
1996-05-07 14:57:38 +00:00

242 lines
6.0 KiB
C

/* 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
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library 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
Library General Public License for more details.
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 <stdio.h>
#include <sys/types.h>
#include <hurd.h>
#include <fcntl.h>
#include <hurd/fd.h>
/* Check ERR for wanting to generate a signal. */
int __stdio_fileno (void *);
static inline int
fd_fail (struct hurd_fd *fd, error_t err)
{
int signo = _hurd_fd_error_signal (err);
if (signo)
{
const struct hurd_signal_detail detail
= { code: __stdio_fileno (fd), error: err, exc: 0 };
_hurd_raise_signal (NULL, signo, &detail);
}
errno = err;
return -1;
}
/* Read up to N chars into BUF from COOKIE.
Return how many chars were read, 0 for EOF or -1 for error. */
ssize_t
DEFUN(__stdio_read, (cookie, buf, n),
PTR cookie AND register char *buf AND size_t n)
{
error_t err;
struct hurd_fd *fd = cookie;
if (! fd)
return __hurd_fail (EBADF);
if (err = _hurd_fd_read (fd, buf, &n))
return fd_fail (fd, err);
return n;
}
/* Write up to N chars from BUF to COOKIE.
Return how many chars were written or -1 for error. */
ssize_t
DEFUN(__stdio_write, (cookie, buf, n),
PTR cookie AND register CONST char *buf AND size_t n)
{
error_t err;
size_t wrote, nleft;
struct hurd_fd *fd = cookie;
if (! fd)
return __hurd_fail (EBADF);
nleft = n;
do
{
wrote = nleft;
if (err = _hurd_fd_write (fd, buf, &wrote))
return fd_fail (fd, err);
buf += wrote;
nleft -= wrote;
} while (nleft > 0);
return wrote;
}
/* Move COOKIE's file position *POS bytes, according to WHENCE.
The current file position is stored in *POS.
Returns zero if successful, nonzero if not. */
int
DEFUN(__stdio_seek, (cookie, pos, whence),
PTR cookie AND fpos_t *pos AND int whence)
{
error_t err;
struct hurd_fd *fd = cookie;
if (! fd)
return __hurd_fail (EBADF);
err = HURD_FD_PORT_USE (fd, __io_seek (port, *pos, whence, pos));
return err ? fd_fail (fd, err) : 0;
}
/* Close the file associated with COOKIE.
Return 0 for success or -1 for failure. */
int
DEFUN(__stdio_close, (cookie), PTR cookie)
{
error_t error = cookie ? _hurd_fd_close (cookie) : EBADF;
return error ? fd_fail (cookie, error) : 0;
}
static inline int
modeflags (__io_mode m)
{
int flags = 0;
if (m.__read)
flags |= O_READ;
if (m.__write)
flags |= O_WRITE;
if (m.__append)
flags |= O_APPEND;
if (m.__create)
flags |= O_CREAT;
if (m.__truncate)
flags |= O_TRUNC;
if (m.__exclusive)
flags |= O_EXCL;
return flags;
}
/* Open FILENAME with the mode in M. */
int
DEFUN(__stdio_open, (filename, m, cookieptr),
CONST char *filename AND __io_mode m AND PTR *cookieptr)
{
int flags;
file_t port;
struct hurd_fd *d;
flags = modeflags (m);
port = __file_name_lookup (filename, flags, 0666 & ~_hurd_umask);
if (port == MACH_PORT_NULL)
return -1;
HURD_CRITICAL_BEGIN;
d = _hurd_alloc_fd (NULL, 0);
if (d != NULL)
{
_hurd_port2fd (d, port, flags);
__spin_unlock (&d->port.lock);
}
HURD_CRITICAL_END;
*cookieptr = d;
return 0;
}
/* Open FILENAME with the mode in M. Use the same magic cookie
already in *COOKIEPTR if possible, closing the old cookie with CLOSEFN. */
int
DEFUN(__stdio_reopen, (filename, m, cookieptr),
CONST char *filename AND __io_mode m AND
PTR *cookieptr AND __io_close_fn closefn)
{
int flags;
file_t port;
struct hurd_fd *d;
if (closefn != __stdio_close)
{
/* The old cookie is Not Of The Body.
Just close it and do a normal open. */
(*closefn) (*cookieptr);
return __stdio_open (filename, m, cookieptr);
}
/* Open a new port on the file. */
flags = modeflags (m);
port = __file_name_lookup (filename, flags, 0666 & ~_hurd_umask);
/* Install the new port in the same file descriptor slot the old cookie
points to. If opening the file failed, PORT will be MACH_PORT_NULL
and installing it in the descriptor will have the effect of closing
the old descriptor. */
d = *cookieptr;
HURD_CRITICAL_BEGIN;
__spin_lock (&d->port.lock);
_hurd_port2fd (d, port, flags);
__spin_unlock (&d->port.lock);
HURD_CRITICAL_END;
return port == MACH_PORT_NULL ? -1 : 0;
}
/* Write a message to the error output.
Try hard to make it really get out. */
void
DEFUN(__stdio_errmsg, (msg, len), CONST char *msg AND size_t len)
{
io_t server;
mach_msg_type_number_t wrote;
server = __getdport (2);
__io_write (server, msg, len, -1, &wrote);
__mach_port_deallocate (__mach_task_self (), server);
}
/* Return the POSIX.1 file descriptor associated with COOKIE,
or -1 for errors. If COOKIE does not relate to any POSIX.1 file
descriptor, this should return -1 with errno set to EOPNOTSUPP. */
int
DEFUN(__stdio_fileno, (cookie), PTR cookie)
{
int fd;
if (! cookie)
return __hurd_fail (EBADF);
__mutex_lock (&_hurd_dtable_lock);
for (fd = 0; fd < _hurd_dtablesize; ++fd)
if (_hurd_dtable[fd] == cookie)
{
__mutex_unlock (&_hurd_dtable_lock);
return fd;
}
__mutex_unlock (&_hurd_dtable_lock);
/* This should never happen, because this function should not be
installed as a stream's __fileno function unless that stream's cookie
points to a file descriptor. */
errno = EGRATUITOUS;
return -1;
}