Minix Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
EXECVE(2)                     System Calls Manual                    EXECVE(2)

       execve - execute a file

       #include <unistd.h>

       int execve(const char *name, char *const argv[], char *const envp[])

       Execve  transforms  the  calling  process  into a new process.  The new
       process is constructed from an ordinary file  called  the  new  process
       file.  This file is either an executable object file, or a file of data
       for  an  interpreter.   An  executable  object  file  consists  of   an
       identifying  header, followed by pages of data representing the initial
       program (text) and initialized data pages.   Additional  pages  may  be
       specified  by  the  header  to  be  initialized  with  zero  data.  See

       An interpreter file begins with a line of the form ``#!  interpreter''.
       When an interpreter file is execve'd, the system execve's the specified
       interpreter, giving it the name of the originally  exec'd  file  as  an
       argument and shifting over the rest of the original arguments.

       There  can  be  no  return from a successful execve because the calling
       core image is lost.  This is the mechanism  whereby  different  process
       images become active.

       The  argument  argv is a null-terminated array of character pointers to
       null-terminated  character  strings.   These  strings  constitute   the
       argument  list to be made available to the new process.  By convention,
       at least one argument must be present in  this  array,  and  the  first
       element of this array should be the name of the executed program (i.e.,
       the last component of name).

       The argument envp is also a null-terminated array of character pointers
       to  null-terminated strings.  These strings pass information to the new
       process  that  is  not  directly  an  argument  to  the  command   (see

       Descriptors open in the calling process remain open in the new process,
       except  for  those  for  which  the  close-on-exec  flag  is  set  (see
       close(2)).  Descriptors that remain open are unaffected by execve.

       Ignored  signals  remain ignored across an execve, but signals that are
       caught are reset to  their  default  values.   Blocked  signals  remain
       blocked  regardless  of changes to the signal action.  The signal stack
       is reset to be undefined (see sigaction(2) for more information).

       Each process has real user and group IDs  and  an  effective  user  and
       group  IDs.   The  real  ID identifies the person using the system; the
       effective ID determines his  access  privileges.   Execve  changes  the
       effective  user  and  group ID to the owner of the executed file if the
       file has the "set-user-ID" or "set-group-ID" modes.  The real  user  ID
       is not affected.

       The new process also inherits the following attributes from the calling

            process ID          see getpid(2)
            parent process ID   see getppid(2)
            process group ID    see getpgrp(2)
            access groups       see getgroups(2)
            working directory   see chdir(2)
            root directory      see chroot(2)
            control terminal    see tty(4)
            alarm timer         see alarm(2)
            file mode mask      see umask(2)
            signal mask         see sigaction(2), sigprocmask(2)

       When the executed program begins, it is called as follows:

              int main(int argc, char *const argv[], char *const envp[]);

              exit(main(argc, argv, envp));

       where argc is the number of elements in argv (the  ``arg  count'')  and
       argv is the array of character pointers to the arguments themselves.

       Envp  is  a  pointer  to  an  array  of  strings  that  constitute  the
       environment of the process.  A pointer to this array is also stored  in
       the  global  variable  ``environ''.  Each string consists of a name, an
       "=", and a null-terminated value.  The array of pointers is  terminated
       by  a  null  pointer.   The shell sh(1) passes an environment entry for
       each global shell variable defined when the  program  is  called.   See
       environ(7) for some conventionally used names.

       If  execve  returns  to  the calling process an error has occurred; the
       return value will be -1 and the global variable errno will  contain  an
       error code.

       Execve  will  fail  and return to the calling process if one or more of
       the following are true:

       [ENOTDIR]      A component of the path prefix is not a directory.

       [ENAMETOOLONG] The path name exceeds PATH_MAX characters.

       [ENOENT]       The new process file does not exist.

       [ELOOP]        Too many symbolic links were encountered in  translating
                      the pathname.  (Minix-vmd)

       [EACCES]       Search  permission is denied for a component of the path

       [EACCES]       The new process file is not an ordinary file.

       [EACCES]       The new process file mode denies execute permission.

       [ENOEXEC]      The  new  process  file  has  the   appropriate   access
                      permission,  but  has  an  invalid  magic  number in its

       [ENOMEM]       The new process requires more (virtual) memory  than  is
                      currently available.

       [E2BIG]        The  number  of bytes in the new process's argument list
                      is larger than the system-imposed  limit  ARG_MAX.   The
                      limit in the system as released is 4096 bytes for 16-bit
                      MINIX 3, 16384 bytes for 32-bit Minix, and unlimited for

       [EFAULT]       Path, argv, or envp point to an illegal address.

       [EIO]          An  I/O  error  occurred  while  reading  from  the file

       If a program is setuid to a non-super-user, but is  executed  when  the
       real  uid  is  ``root'',  then  the program has some of the powers of a
       super-user as well.

       exit(2), fork(2), execl(3), environ(7).

4th Berkeley Distribution        May 22, 1986                        EXECVE(2)