Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
EXEC(2)			      System Calls Manual		       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

       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 signal(2)) are	reset to their default

       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 ef-
       fective ID determines his access	privileges.  Exec changes  the	effec-
       tive  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

       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.  Con-
       ventionally arg[0] is the name of the file.

       From  C,	 two  interfaces  are available.  Execl	is useful when a known
       file with known arguments 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 arguments 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  arguments themselves.	 As indicated, argc is conven-
       tionally	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 environ-
       ment 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 ex-
       ecv and execl to	pass the environment to	any  subprograms  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  ex-
       ecv,  but  duplicate the	shell's	actions	in searching for an executable
       file in a list of directories.  The directory list is obtained from the

       /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 consti-
       tutes 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 executed.

       If execvp is called to execute a	file that turns	out to be a shell com-
       mand  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 (cur-
       rently 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.



Want to link to this manual page? Use this URL:

home | help