Seth Woolley's Man Viewer

Manual for intro - man 2 intro

([section] manual, -k keyword, -K [section] search, -f whatis)
man plain no title

INTRO(2)                   Linux Programmer's Manual                  INTRO(2)

       intro(1,2,3,4,5,6,7,8), _syscall - Introduction to system calls

       This  chapter  describes the Linux system calls.  For a list of the 164
       syscalls present in(1,8) Linux 2.0, see syscalls(2).

   Calling Directly
       In most cases, it is unnecessary to invoke a system call directly,  but
       there  are  times when the Standard C library does not implement a nice(1,2)
       function call for you.

       #include <linux/unistd.h>

       A _syscall macro

       desired system call

       The important thing to know about a system call is its prototype.   You
       need  to  know how many arguments, their types, and the function return
       type.  There are six macros that make the actual call into  the  system
       easier.  They have the form:


                     where  X  is 0-5, which are the number of arguments taken
                            by the system call

                     type is the return type of the system call

                     name is the name of the system call

                     typeN is the Nth argument's type

                     argN is the name of the Nth argument

       These macros create a function called name with the arguments you spec-
       ify.  Once you include the _syscall() in(1,8) your source file(1,n), you call the
       system call by name.

       #include <stdio.h>
       #include <errno.h>
       #include <linux/unistd.h>     /* for _syscallX macros/related stuff */
       #include <linux/kernel.h>     /* for struct sysinfo */

       _syscall1(int, sysinfo, struct sysinfo *, info(1,5,n));

       /* Note: if(3,n) you copy directly from the nroff source, remember to
       REMOVE the extra backslashes in(1,8) the printf(1,3,1 builtins) statement. */

       int main(void)
            struct sysinfo s_info;
            int error(8,n);

            error(8,n) = sysinfo(&s_info);
            printf(1,3,1 builtins)("code error(8,n) = %d\n", error(8,n));
               printf(1,3,1 builtins)("Uptime = %lds\nLoad: 1 min %lu / 5 min %lu / 15 min %lu\n"
                       "RAM: total %lu / free %lu / shared %lu\n"
                       "Memory in(1,8) buffers = %lu\nSwap: total %lu / free %lu\n"
                       "Number of processes = %d\n",
                 s_info.uptime, s_info.loads[0],
                 s_info.loads[1], s_info.loads[2],
                 s_info.totalram, s_info.freeram,
                 s_info.sharedram, s_info.bufferram,
                 s_info.totalswap, s_info.freeswap,

Sample Output
       code error(8,n) = 0
       uptime = 502034s
       Load: 1 min 13376 / 5 min 5504 / 15 min 1152
       RAM: total 15343616 / free 827392 / shared 8237056
       Memory in(1,8) buffers = 5066752
       Swap: total 27881472 / free 24698880
       Number of processes = 40

       The _syscall() macros DO NOT produce a prototype.  You may have to cre-
       ate one, especially for C++ users.

       System calls are not required to return only positive or negative error(8,n)
       codes.  You need to read(2,n,1 builtins) the source to  be  sure  how  it  will  return
       errors.   Usually,  it  is the negative of a standard error(8,n) code, e.g.,
       -EPERM.  The _syscall() macros will return the result r of  the  system
       call  when  r  is  nonnegative, but will return -1 and set(7,n,1 builtins) the variable
       errno to -r when r is negative.  For the error(8,n) codes, see errno(3).

       Some system calls, such as mmap,  require  more  than  five  arguments.
       These  are  handled by pushing the arguments on the stack and passing a
       pointer to the block of arguments.

       When defining a system call, the argument types MUST be passed by-value
       or by-pointer (for aggregates like structs).

       The preferred way to invoke system calls that glibc does not know about
       yet, is via syscall(2).

       Certain codes are used to indicate Unix variants and standards to which
       calls in(1,8) the section conform.  These are:

       SVr4   System  V Release 4 Unix, as described in(1,8) the "Programmer's Ref-
              erence Manual: Operating System API (Intel  processors)"  (Pren-
              tice-Hall 1992, ISBN 0-13-951294-2)

       SVID   System  V  Interface  Definition,  as described in(1,8) "The System V
              Interface Definition, Fourth Edition".

              IEEE 1003.1-1990 part 1, aka  ISO/IEC  9945-1:1990s,  aka  "IEEE
              Portable Operating System Interface for Computing Environments",
              as elucidated in(1,8)  Donald  Lewine's  "POSIX  Programmer's  Guide"
              (O'Reilly & Associates, Inc., 1991, ISBN 0-937175-73-0.

              IEEE  Std  1003.1b-1993 (POSIX.1b standard) describing real-time
              facilities  for  portable   operating   systems,   aka   ISO/IEC
              9945-1:1996,  as elucidated in(1,8) "Programming for the real world -
              POSIX.4" by Bill O. Gallmeister  (O'Reilly  &  Associates,  Inc.
              ISBN 1-56592-074-0).

       SUS, SUSv2
              Single  Unix  Specification.   (Developed by X/Open and The Open
              Group. See also .)

              The 4.3 and 4.4 distributions  of  Berkeley  Unix.   4.4BSD  was
              upward-compatible from 4.3.

       V7     Version 7, the ancestral Unix from Bell Labs.


       syscall(2), errno(3)

Linux 1.2.13                      1996-05-22                          INTRO(2)

References for this manual (incoming links)