Subversion Repositories openrisc

@c                                           -*- Texinfo -*-

@node Syscalls

@chapter System Calls

@cindex linking the C library

The C subroutine library depends on a handful of subroutine calls for

operating system services.  If you use the C library on a system that

complies with the POSIX.1 standard (also known as IEEE 1003.1), most of

these subroutines are supplied with your operating system.

If some of these subroutines are not provided with your system---in

the extreme case, if you are developing software for a ``bare board''

system, without an OS---you will at least need to provide do-nothing

stubs (or subroutines with minimal functionality) to allow your

programs to link with the subroutines in @code{libc.a}.

@menu

* Stubs::               Definitions for OS interface

* Reentrant Syscalls::  Reentrant covers for OS subroutines

@end menu

@node Stubs

@section Definitions for OS interface

@cindex stubs

@cindex subroutines for OS interface

@cindex OS interface subroutines

This is the complete set of system definitions (primarily subroutines)

required; the examples shown implement the minimal functionality

required to allow @code{libc} to link, and fail gracefully where OS

services are not available.

Graceful failure is permitted by returning an error code.  A minor

complication arises here: the C library must be compatible with

development environments that supply fully functional versions of these

subroutines.  Such environments usually return error codes in a global

@code{errno}.  However, the Red Hat newlib C library provides a @emph{macro}

definition for @code{errno} in the header file @file{errno.h}, as part

of its support for reentrant routines (@pxref{Reentrancy,,Reentrancy}).

@cindex @code{errno} global vs macro

The bridge between these two interpretations of @code{errno} is

straightforward: the C library routines with OS interface calls

capture the @code{errno} values returned globally, and record them in

the appropriate field of the reentrancy structure (so that you can query

them using the @code{errno} macro from @file{errno.h}).

This mechanism becomes visible when you write stub routines for OS

interfaces.   You must include @file{errno.h}, then disable the macro,

like this:

@example

#include <errno.h>

#undef errno

extern int errno;

@end example

@noindent

The examples in this chapter include this treatment of @code{errno}.

@ftable @code

@item _exit

Exit a program without cleaning up files.  If your system doesn't

provide this, it is best to avoid linking with subroutines that require

it (@code{exit}, @code{system}).

@item close

Close a file.  Minimal implementation:

@example

int close(int file) @{

  return -1;

@}

@end example

@item environ

A pointer to a list of environment variables and their values.  For a

minimal environment, this empty list is adequate:

@example

char *__env[1] = @{ 0 @};

char **environ = __env;

@end example

@item execve

Transfer control to a new process.  Minimal implementation (for a system

without processes):

@example

#include <errno.h>

#undef errno

extern int errno;

int execve(char *name, char **argv, char **env) @{

  errno = ENOMEM;

  return -1;

@}

@end example

@item fork

Create a new process.  Minimal implementation (for a system without processes):

@example

#include <errno.h>

#undef errno

extern int errno;

int fork(void) @{

  errno = EAGAIN;

  return -1;

@}

@end example

@item fstat

Status of an open file.  For consistency with other minimal

implementations in these examples, all files are regarded as character

special devices.  The @file{sys/stat.h} header file required is

distributed in the @file{include} subdirectory for this C library.

@example

#include <sys/stat.h>

int fstat(int file, struct stat *st) @{

  st->st_mode = S_IFCHR;

  return 0;

@}

@end example

@item getpid

Process-ID; this is sometimes used to generate strings unlikely to

conflict with other processes.  Minimal implementation, for a system

without processes:

@example

int getpid(void) @{

  return 1;

@}

@end example

@item isatty

Query whether output stream is a terminal.   For consistency with the

other minimal implementations, which only support output to

@code{stdout}, this minimal implementation is suggested:

@example

int isatty(int file) @{

  return 1;

@}

@end example

@item kill

Send a signal.  Minimal implementation:

@example

#include <errno.h>

#undef errno

extern int errno;

int kill(int pid, int sig) @{

  errno = EINVAL;

  return -1;

@}

@end example

@item link

Establish a new name for an existing file.  Minimal implementation:

@example

#include <errno.h>

#undef errno

extern int errno;

int link(char *old, char *new) @{

  errno = EMLINK;

  return -1;

@}

@end example

@item lseek

Set position in a file.  Minimal implementation:

@example

int lseek(int file, int ptr, int dir) @{

  return 0;

@}

@end example

@item open

Open a file.  Minimal implementation:

@example

int open(const char *name, int flags, int mode) @{

  return -1;

@}

@end example

@item read

Read from a file.  Minimal implementation:

@example

int read(int file, char *ptr, int len) @{

  return 0;

@}

@end example

@item sbrk

Increase program data space.  As @code{malloc} and related functions

depend on this, it is useful to have a working implementation.  The

following suffices for a standalone system; it exploits the symbol

@code{_end} automatically defined by the GNU linker.

@example

@group

caddr_t sbrk(int incr) @{

  extern char _end;             /* @r{Defined by the linker} */

  static char *heap_end;

  char *prev_heap_end;

  if (heap_end == 0) @{

    heap_end = &_end;

  @}

  prev_heap_end = heap_end;

  if (heap_end + incr > stack_ptr) @{

    write (1, "Heap and stack collision\n", 25);

    abort ();

  @}

  heap_end += incr;

  return (caddr_t) prev_heap_end;

@}

@end group

@end example

@item stat

Status of a file (by name).  Minimal implementation:

@example

int stat(char *file, struct stat *st) @{

  st->st_mode = S_IFCHR;

  return 0;

@}

@end example

@item times

Timing information for current process.  Minimal implementation:

@example

int times(struct tms *buf) @{

  return -1;

@}

@end example

@item unlink

Remove a file's directory entry.  Minimal implementation:

@example

#include <errno.h>

#undef errno

extern int errno;

int unlink(char *name) @{

  errno = ENOENT;

  return -1;

@}

@end example

@item wait

Wait for a child process.  Minimal implementation:

@example

#include <errno.h>

#undef errno

extern int errno;

int wait(int *status) @{

  errno = ECHILD;

  return -1;

@}

@end example

@item write

Write to a file.  @file{libc} subroutines will use this

system routine for output to all files, @emph{including}

@code{stdout}---so if you need to generate any output, for example to a

serial port for debugging, you should make your minimal @code{write}

capable of doing this.  The following minimal implementation is an

incomplete example; it relies on a @code{outbyte} subroutine (not

shown; typically, you must write this in assembler from examples

provided by your hardware manufacturer) to actually perform the output.

@example

@group

int write(int file, char *ptr, int len) @{

  int todo;

  for (todo = 0; todo < len; todo++) @{

    outbyte (*ptr++);

  @}

  return len;

@}

@end group

@end example

@end ftable

@page

@node Reentrant Syscalls

@section Reentrant covers for OS subroutines

Since the system subroutines are used by other library routines that

require reentrancy, @file{libc.a} provides cover routines (for example,

the reentrant version of @code{fork} is @code{_fork_r}).  These cover

routines are consistent with the other reentrant subroutines in this

library, and achieve reentrancy by using a reserved global data block

(@pxref{Reentrancy,,Reentrancy}).

@c FIXME!!! The following ignored text specifies how this section ought

@c to work;  however, both standalone info and Emacs info mode fail when

@c confronted with nodes beginning `_' as of 24may93.  Restore when Info

@c readers fixed!

@ignore

@menu

* _open_r::     Reentrant version of open

* _close_r::    Reentrant version of close

* _lseek_r::    Reentrant version of lseek

* _read_r::     Reentrant version of read

* _write_r::    Reentrant version of write

* _link_r::     Reentrant version of link

* _unlink_r::   Reentrant version of unlink

* _stat_r::     Reentrant version of stat

* _fstat_r::    Reentrant version of fstat

* _sbrk_r::     Reentrant version of sbrk

* _fork_r::     Reentrant version of fork

* _wait_r::     Reentrant version of wait

@end menu

@down

@include reent/filer.def

@include reent/execr.def

@include reent/statr.def

@include reent/fstatr.def

@include reent/linkr.def

@include reent/unlinkr.def

@include reent/sbrkr.def

@up

@end ignore

@ftable @code

@item _open_r

A reentrant version of @code{open}.  It takes a pointer

to the global data block, which holds @code{errno}.

@example

int _open_r(void *@var{reent},

    const char *@var{file}, int @var{flags}, int @var{mode});

@end example

@ifset STDIO64

@item _open64_r

A reentrant version of @code{open64}.  It takes a pointer

to the global data block, which holds @code{errno}.

@example

int _open64_r(void *@var{reent},

    const char *@var{file}, int @var{flags}, int @var{mode});

@end example

@end ifset

@item _close_r

A reentrant version of @code{close}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _close_r(void *@var{reent}, int @var{fd});

@end example

@item _lseek_r

A reentrant version of @code{lseek}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

off_t _lseek_r(void *@var{reent},

    int @var{fd}, off_t @var{pos}, int @var{whence});

@end example

@ifset STDIO64

@item _lseek64_r

A reentrant version of @code{lseek64}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

off_t _lseek64_r(void *@var{reent},

    int @var{fd}, off_t @var{pos}, int @var{whence});

@end example

@end ifset

@item _read_r

A reentrant version of @code{read}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

long _read_r(void *@var{reent},

    int @var{fd}, void *@var{buf}, size_t @var{cnt});

@end example

@item _write_r

A reentrant version of @code{write}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

long _write_r(void *@var{reent},

    int @var{fd}, const void *@var{buf}, size_t @var{cnt});

@end example

@item _fork_r

A reentrant version of @code{fork}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _fork_r(void *@var{reent});

@end example

@item _wait_r

A reentrant version of @code{wait}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _wait_r(void *@var{reent}, int *@var{status});

@end example

@item _stat_r

A reentrant version of @code{stat}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _stat_r(void *@var{reent},

    const char *@var{file}, struct stat *@var{pstat});

@end example

@item _fstat_r

A reentrant version of @code{fstat}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _fstat_r(void *@var{reent},

    int @var{fd}, struct stat *@var{pstat});

@end example

@ifset STDIO64

@item _fstat64_r

A reentrant version of @code{fstat64}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _fstat64_r(void *@var{reent},

    int @var{fd}, struct stat *@var{pstat});

@end example

@end ifset

@item _link_r

A reentrant version of @code{link}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _link_r(void *@var{reent},

    const char *@var{old}, const char *@var{new});

@end example

@item _unlink_r

A reentrant version of @code{unlink}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

int _unlink_r(void *@var{reent}, const char *@var{file});

@end example

@item _sbrk_r

A reentrant version of @code{sbrk}.  It takes a pointer to the global

data block, which holds @code{errno}.

@example

char *_sbrk_r(void *@var{reent}, size_t @var{incr});

@end example

@end ftable