fcntl_os1.h

Go to the documentation of this file.

/*--------------------------------------------------------
 * /
 * / apeNEXT fcntl.h for OS1
 * /
 * / $Id: fcntl_os1.h,v 1.8 2005/10/27 20:04:57 morinl Exp $
 * /
 * /--------------------------------------------------------*/
#ifndef __ANEXT_OS1_FCNTL_H__
#define __ANEXT_OS1_FCNTL_H__

#include <nlibc.h>

#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <os1/defs_os1.h>
#include <errno.h>

// open/fcntl mode values
// (same as in glibc 2.3)
#define O_RDONLY             00
#define O_WRONLY             01
#define O_RDWR               02
#define O_CREAT            0100
#define O_TRUNC           01000
#define O_APPEND          02000

typedef int ssize_t;

/*----------------------------------------------------------------------
| NAME
| 
|  open, creat - open and possibly create a file or device 
| 
| SYNOPSIS
| 
| 
| #include <sys/types.h>
| #include <sys/stat.h>
| #include <fcntl.h>
| 
| int open(const char *pathname, int flags);
| int open(const char *pathname, int flags, mode_t mode);
| int creat(const char *pathname, mode_t mode);
| 
| 
| DESCRIPTION
| 
| The open() system call is used to convert a pathname into a file
| descriptor (a small, non-negative integer for use in subsequent I/O as
| with read, write, etc.). When the call is successful, the file
| descriptor returned will be the lowest file descriptor not currently
| open for the process. This call creates a new open file, not shared
| with any other process. (But shared open files may arise via the
| fork(2) system call.) The file offset is set to the
| beginning of the file. 
| 
| The parameter flags is one of O_RDONLY, O_WRONLY or O_RDWR which
| request opening the file read-only, write-only or read/write,
| respectively. When opening a file for writing, the flag O_APPEND
| will cause the file pointer to be positioned at the end of the
| file.
|
| apeNEXT-specific changes:
| - The flag O_CREAT is silently ignored.
| - The mode parameter is silently ignored.
|
| creat() is equivalent to open with flags equal to 
| O_CREAT|O_WRONLY|O_TRUNC. 
+----------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern int open(const char *pathname, int flags, ...);
#else
#if !defined(__cflow_processed) || defined(_uses_open_fcntl_os1_h)
int open(const char *pathname, int flags, ...)
{       int modebits = 0, fi, fileno;
        #pragma localmem

        asm("\t!! start open()\n");
        /* check if number of open files exceeded */
        if( __n_files == __NLCC_OS1_MAX_FILES__ ) {
                errno = EMFILE;
                return -1;
        }
        for( fi=0; fi<__NLCC_OS1_MAX_FILES__; fi++ ) {
                if( __files[fi].fd == 0 ) {
                        fileno = __NLCC_BASE_FD + fi;
                        break;
                }
        }
        // unless we miscounted, fi _is_ now < __NLCC_OS1_MAX_FILES__

        // convert mode flags into OS1 mode value
        // return -1 for invalid mode
        {       int flags3 = (flags & 0x3);
                where( flags3==O_RDONLY )
                        asm("\t$io_setmode(%0, $SYS_IOMODE_R)" : "=r" (modebits) );
                where( flags3==O_WRONLY ) {
                        where( flags & O_APPEND )  {
                                asm("\t$io_setmode(%0, $SYS_IOMODE_A)" : "=r" (modebits) );
                        } else {
                                asm("\t$io_setmode(%0, $SYS_IOMODE_W)" : "=r" (modebits) );
                        }
                }
                where( flags3==O_RDWR ) {
                        where( flags & O_APPEND ) {
                                asm("\t$io_setmode(%0, $SYS_IOMODE_APLUS)" : "=r" (modebits) );
                        } else {
                                asm("\t$io_setmode(%0, $SYS_IOMODE_WPLUS)" : "=r" (modebits) );
                        }
                }
        }

        if( ! modebits ) {
                errno = EINVAL;
                return (-1);
        }

        
        asm("\t$io_start\n");
        asm("\t$io_fopenp( 0.%0, %1, 0.%2, $SYS_IODEV_MEM , \"\")\n"
            : : "r" (fileno), "r" (modebits), "r" (pathname) );
        asm("\t$io_end\n");

        // check OS return code and set errno if necessary
        {       vector int sys_rval;

                asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (sys_rval) );
                asm("\t!! end open()\n");
                if( sys_rval.lo ) {
                        errno = sys_rval.hi;
                        return (-1);
                } else {
                        __n_files++;
                        __files[fi].fd = fileno;
                        __files[fi].mode = modebits;
                        return fileno;
                }
        }
}
#endif // open()
#endif

#if !defined(__cflow_processed) || defined(_uses_creat_fcntl_os1_h)
inline 
int creat(const char *pathname, mode_t mode)
{
        return open(pathname, O_CREAT|O_WRONLY|O_TRUNC );
}
#endif // creat()

/*---------------------------------------------------------------------
| NAME
|        read - read from a file descriptor
| 
| SYNOPSIS
|        #include <unistd.h>
| 
|        ssize_t read(int fd, void *buf, size_t count);
| 
| DESCRIPTION
|        read()  attempts  to  read  up  to  count  bytes from file
|        descriptor fd into the buffer starting at buf.
| 
|        If count is zero, read() returns zero  and  has  no  other
|        results.   If  count is greater than SSIZE_MAX, the result
|        is unspecified.
| 
| 
| RETURN VALUE
|        On success, the number of bytes  read  is  returned  (zero
|        indicates  end of file), and the file position is advanced
|        by this number.  It is not an  error  if  this  number  is
|        smaller  than the number of bytes requested; this may hap-
|        pen for example because fewer bytes are actually available
|        right  now (maybe because we were close to end-of-file, or
|        because we are reading from a pipe, or from  a  terminal),
|        or  because read() was interrupted by a signal.  On error,
|        -1 is returned, and errno is set  appropriately.  In  this
|        case  it is left unspecified whether the file position (if
|        any) changes.
| 
| ERRORS
|        EINTR  The call was interrupted by  a  signal  before  any
|               data was read.
| 
|        EAGAIN Non-blocking I/O has been selected using O_NONBLOCK
|               and no data was immediately available for  reading.
| 
|        EIO    I/O  error.  This  will happen for example when the
|               process is in a background process group, tries  to
|               read  from  its  controlling  tty, and either it is
|               ignoring or blocking SIGTTIN or its  process  group
|               is  orphaned.   It  may  also occur when there is a
|               low-level I/O error while reading from  a  disk  or
|               tape.
| 
|        EISDIR fd refers to a directory.
| 
|        EBADF  fd  is  not  a valid file descriptor or is not open
|               for reading.
| 
|        EINVAL fd is attached to an object which is unsuitable for
|               reading.
| 
|        EFAULT buf is outside your accessible address space.
| 
|        Other  errors may occur, depending on the object connected
|        to fd.  POSIX allows a  read  that  is  interrupted  after
|        reading  some  data to return -1 (with errno set to EINTR)
|        or to return the number of bytes already read.
+----------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern ssize_t read(int fd, void *buf, size_t count);
#else
#if !defined(__cflow_processed) || defined(_uses_read_fcntl_os1_h)
ssize_t read(int fd, void *buf, size_t count)
{
        vector int sys_rval;
        ssize_t result;

        asm("\t!! start read()\n");

        asm("\t$io_start\n"
            "\t\\equ $cmd   $SYS_IOCMD_BRD\n"
            "\t\\equ $fmt   $SYS_IOFMT_BIN\n"
            "\t\\equ $sep   $SYS_IOPSEP_NOP\n"
            "\t\\equ $rdflg $SYS_IORDFLG_NOP\n"
            "\t\\equ $dev   $SYS_IODEV_MEM\n"
            "\t\\equ $l     %1>>4\n"
            "\t\\equ $bs    $SYS_IOBS_V\n"
            "\t$io_fd( 0.%2 )\n"
            "\t$io_slice_all\n"
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%3)\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            "\t!! end read()\n"
            : "=r" (sys_rval)
            : "r" (count), "r" (fd), "r" (buf) );

        result = sys_rval.hi << 4;      // number of bytes
        where (sys_rval.lo) {
                errno = sys_rval.hi;
                result = -1;
        }

        return result;
}
#endif // read()
#endif // Has Main
/*---------------------------------------------------------------------
| NAME
|        write - write to a file descriptor
| 
| SYNOPSIS
|        #include <unistd.h>
| 
|        ssize_t write(int fd, const void *buf, size_t count);
| 
| DESCRIPTION
|        write  writes  up to count bytes to the file referenced by
|        the file descriptor fd from the buffer  starting  at  buf.
|        POSIX  requires that a read() which can be proved to occur
|        after a write() has returned returns the new  data.   Note
|        that not all file systems are POSIX conforming.
| 
| RETURN VALUE
|        On success, the number of bytes written are returned (zero
|        indicates nothing was written).  On error, -1 is returned,
|        and  errno is set appropriately.  If count is zero and the
|        file descriptor refers  to  a  regular  file,  0  will  be
|        returned  without causing any other effect.  For a special
|        file, the results are not portable.
| 
| ERRORS
|        EBADF  fd is not a valid file descriptor or  is  not  open
|               for writing.
| 
|        EINVAL fd is attached to an object which is unsuitable for
|               writing.
| 
|        EFAULT buf is outside your accessible address space.
| 
|        EPIPE  fd is connected to a pipe or socket  whose  reading
|               end  is closed.  When this happens the writing pro-
|               cess will receive a SIGPIPE signal; if it  catches,
|               blocks or ignores this the error EPIPE is returned.
| 
|        EAGAIN Non-blocking I/O has been selected using O_NONBLOCK
|               and the write would block.
| 
|        EINTR  The  call  was  interrupted  by a signal before any
|               data was written.
| 
|        ENOSPC The device containing the file referred  to  by  fd
|               has no room for the data.
| 
|        EIO    A  low-level I/O error occurred while modifying the
|               inode.
| 
|        Other errors may occur, depending on the object  connected
|        to fd.
+----------------------------------------------------------------------*/

#ifndef __HAS_MAIN
extern ssize_t write(int fd, void *buf, size_t count);
#else
#if !defined(__cflow_processed) || defined(_uses_write_fcntl_os1_h)
ssize_t write(int fd, void *buf, size_t count)
{
        vector int sys_rval;
        ssize_t result;

        asm("\t!! start write()\n");

        asm("\t$io_start\n"
            "\t\\equ $cmd   $SYS_IOCMD_GWR\n"
            "\t\\equ $fmt   $SYS_IOFMT_BIN\n"
            "\t\\equ $sep   $SYS_IOPSEP_NOP\n"
            "\t\\equ $rdflg $SYS_IORDFLG_NOP\n"
            "\t\\equ $dev   $SYS_IODEV_MEM\n"
            "\t\\equ $l     %1>>4\n"
            "\t\\equ $bs    $SYS_IOBS_V\n"
            "\t$io_fd( 0.%2 )\n"
            "\t$io_slice_all\n"
            "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%3)\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            "\t!! end write()\n"
            : "=r" (sys_rval)
            : "r" (count), "r" (fd), "r" (buf) );

        result = sys_rval.hi << 4;      // number of bytes
        where (sys_rval.lo) {
                errno = sys_rval.hi;
                result = -1;
        }

        return result;
}
#endif // write()
#endif // Has Main


/*----------------------------------------------------------------------
| NAME
|        close - close a file descriptor
| 
| SYNOPSIS
|        #include <unistd.h>
| 
|        int close(int fd);
| 
| DESCRIPTION
|        close  closes  a  file  descriptor,  so  that it no longer
|        refers to any file and may be reused. Any  locks  held  on
|        the file it was associated with, and owned by the process,
|        are removed (regardless of the file  descriptor  that  was
|        used to obtain the lock).
| 
|        If fd is the last copy of a particular file descriptor the
|        resources associated with it are freed; if the  descriptor
|        was  the  last  reference to a file which has been removed
|        using unlink(2) the file is deleted.
| 
| RETURN VALUE
|        close returns zero on success, or -1 if an error occurred.
| 
| ERRORS
|        EBADF  fd isn't a valid open file descriptor.
| 
|        EINTR  The close() call was interrupted by a signal.
| 
|        EIO    An I/O error occurred.
| 
+-----------------------------------------------------------------------*/
#ifndef __HAS_MAIN
extern int close( int fd );
#else
#if !defined(__cflow_processed) || defined(_uses_close_fcntl_os1_h)
int close( int fd ) 
{
        int nf;
        vector int sys_rval;

        for(nf=0; nf<__NLCC_OS1_MAX_FILES__; nf++ ) { 
                if( __files[nf].fd == fd ) 
                        break;
        }
        if( nf == __NLCC_OS1_MAX_FILES__ ) { 
                errno = EBADF;
                return -1;
        }

        asm("\t$io_start\n"
            "\t$io_fclose(0.%1)\n"
            "\t$io_end\n"
            "\tlmtr %0 $MEM_SYS_RVAL\n"
            : "=r" (sys_rval) : "r" (fd));

        if (sys_rval.lo) {
                errno = sys_rval.hi;
                return -1;
        }

        __files[nf].fd = 0;
        return 0;
}
#endif // close()
#endif // Has Main

/*----------------------------------------------------------------------
| NAME
|        lseek - reposition read/write file offset
| 
| SYNOPSIS
|        #include <sys/types.h>
|        #include <unistd.h>
| 
|        off_t lseek(int fildes, off_t offset, int whence);
| 
| DESCRIPTION
|        The  lseek  function  repositions  the  offset of the file
|        descriptor fildes to the argument offset according to  the
|        directive whence as follows:
| 
|        SEEK_SET
|               The offset is set to offset bytes.
| 
|        SEEK_CUR
|               The offset is set to its current location plus off-
|               set bytes.
| 
|        SEEK_END
|               The offset is set to the size of the file plus off-
|               set bytes.
| 
|        The lseek function allows the file offset to be set beyond
|        the end of the existing end-of-file of the file.  If  data
|        is  later  written  at this point, subsequent reads of the
|        data in the gap return bytes of zeros (until data is actu-
|        ally written into the gap).
| 
| RETURN VALUE
|        Upon  successful  completion,  lseek returns the resulting
|        offset location as measured in bytes from the beginning of
|        the file.  Otherwise, a value of (off_t)-1 is returned and
|        errno is set to indicate the error.
| 
| ERRORS
|        EBADF  Fildes is not an open file descriptor.
| 
|        ESPIPE Fildes is associated with a pipe, socket, or  FIFO.
| 
|        EINVAL Whence is not a proper value.
+----------------------------------------------------------------------*/
// The possibilities for the third argument to `fseek'.
// These values should not be changed.  
#ifndef SEEK_SET
#define SEEK_SET        0       /* Seek from beginning of file.  */
#define SEEK_CUR        1       /* Seek from current position.  */
#define SEEK_END        2       /* Seek from end of file.  */
#endif

#if !defined(__cflow_processed) || defined(_uses_lseek_fcntl_os1_h)
inline off_t lseek(int fildes, off_t offset, int whence)
{
        int sys_whence;
        vector int sys_rval;
        off_t result;

        asm("\t!! begin lseek()\n");

        if (fildes < 0 || fildes > __NLCC_OS1_MAX_FILES__+40) {
                errno = EBADF;
                return (off_t) -1;
        }

        sys_whence = -2;
        where (whence == SEEK_SET)
                asm("$sys_setwhence(%0, $SYS_FSE_SET)\n" : "=r" (sys_whence) );
        where (whence == SEEK_CUR)
                asm("$sys_setwhence(%0, $SYS_FSE_CUR)\n" : "=r" (sys_whence) );
        where (whence == SEEK_END)
                asm("$sys_setwhence(%0, $SYS_FSE_END)\n" : "=r" (sys_whence) );
        if (sys_whence < 0) {
                errno = EINVAL;
                return (off_t) -1;
        }
        
        asm("\t$sys_fseek( 0.%0, 0.%1, %2 )\n"
            : : "r" (fildes), "r" (offset), "r" (sys_whence));
        asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (sys_rval));
        asm("\t!! end lseek()\n");

        result = sys_rval.hi;
        where ( sys_rval.lo ) {
                errno = sys_rval.hi;
                result = (off_t) -1;
        }

        return result;
}
#endif // lseek()



#endif // __ANEXT_OS1_FCNTL_H__

---