Unix/Linux Go Back    

Unix Version 7 - man page for exec (v7 section 2)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

EXEC(2) 										  EXEC(2)

       execl, execv, execle, execve, execlp, execvp, exec, exece, environ  - execute a file

       execl(name, arg0, arg1, ..., argn, 0)
       char *name, *arg0, *arg1, ..., *argn;

       execv(name, argv)
       char *name, *argv[ ];

       execle(name, arg0, arg1, ..., argn, 0, envp)
       char *name, *arg0, *arg1, ..., *argn, *envp[ ];

       execve(name, argv, envp);
       char *name, *argv[ ], *envp[ ];

       extern char **environ;

       Exec  in all its forms overlays the calling process with the named file, then transfers to
       the entry point of the core image of the file.  There can be no return from  a  successful
       exec; the calling core image is lost.

       Files  remain  open  across  exec unless explicit arrangement has been made; see ioctl(2).
       Ignored signals remain ignored across these calls, but signals that are caught  (see  sig-
       nal(2)) are reset to their default values.

       Each user has a real user ID and group ID and an effective user ID and group ID.  The real
       ID identifies the person using the system; the effective ID determines his  access  privi-
       leges.	Exec 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 name argument is a pointer to the name of the  file	to  be	executed.   The  pointers
       arg[0], arg[1] ...  address null-terminated strings.  Conventionally arg[0] is the name of
       the file.

       From C, two interfaces are available.  Execl is useful when a known file with known  argu-
       ments  is  being called; the arguments to execl are the character strings constituting the
       file and the arguments; the first argument is conventionally the same as the file name (or
       its last component).  A 0 argument must end the argument list.

       The  execv version is useful when the number of arguments is unknown in advance; the argu-
       ments to execv are the name of the file to be executed and a vector of strings  containing
       the arguments.  The last argument string must be followed by a 0 pointer.

       When a C program is executed, it is called as follows:

	    main(argc, argv, envp)
	    int argc;
	    char **argv, **envp;

       where  argc  is the argument count and argv is an array of character pointers to the argu-
       ments themselves.  As indicated, argc is conventionally at least one and the first  member
       of the array points to a string containing the name of the file.

       Argv is directly usable in another execv because argv[argc] is 0.

       Envp  is  a pointer to an array of strings that constitute the environment of the process.
       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(5)	for  some
       conventionally  used names.  The C run-time start-off routine places a copy of envp in the
       global cell environ, which is used by execv and execl to pass the environment to any  sub-
       programs  executed  by the current program.  The exec routines use lower-level routines as
       follows to pass an environment explicitly:
	      execle(file, arg0, arg1, . . . , argn, 0, environ);
	      execve(file, argv, environ);

       Execlp and execvp are called with the same arguments as execl and execv, but duplicate the
       shell's	actions in searching for an executable file in a list of directories.  The direc-
       tory list is obtained from the environment.

       /bin/sh	shell, invoked if command file found by execlp or execvp

       fork(2), environ(5)

       If the file cannot be found, if it is not executable, if it does not start  with  a  valid
       magic  number  (see  a.out(5)), if maximum memory is exceeded, or if the arguments require
       too much space, a return constitutes the diagnostic; the return value is -1.  Even for the
       super-user,  at least one of the execute-permission bits must be set for a file to be exe-

       If execvp is called to execute a file that turns out to be a shell command file, and if it
       is  impossible  to  execute the shell, the values of argv[0] and argv[-1] will be modified
       before return.

       (exec = 11.)
       sys exec; name; argv

       (exece = 59.)
       sys exece; name; argv; envp

       Plain exec is obsoleted by exece, but remains for historical reasons.

       When the called file starts execution on the PDP11, the stack pointer  points  to  a  word
       containing  the	number of arguments.  Just above this number is a list of pointers to the
       argument strings, followed by a null pointer, followed by the pointers to the  environment
       strings and then another null pointer.  The strings themselves follow; a 0 word is left at
       the very top of memory.

	 sp->	 nargs

	arg0:	 <arg0\0>
	env0:	 <env0\0>

       On the Interdata 8/32, the stack begins at a conventional place	(currently  0xD0000)  and
       grows upwards.  After exec, the layout of data on the stack is as follows.

	    int  0
	arg0:	 byte ...
       argp0:	 int  arg0
	    int  0
       envp0:	 int  env0
	    int  0
	%2->	 space	   40
	    int  nargs
	    int  argp0
	    int  envp0

       This arrangement happens to conform well to C calling conventions.

Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 01:52 PM.