exec, execl, _privates, _nprivates, _tos – execute a file|
void* exec(char *name, char* argv)
void* execl(char *name, ...)
typedef struct Tos Tos;
extern Tos *_tos;
Exec and execl overlay the calling process with the named file,
then transfer to the entry point of the image of the file. |
Name points to the name of the file to be executed; it must not
be a directory, and the permissions must allow the current user
to execute it (see stat(2)). It should also be a valid binary
image, as defined in the a.out(6) for the current machine architecture,
or a shell script (see rc(1)). The first line of a shell script
begin with #! followed by the name of the program to interpret
the file and any initial arguments to that program, for example
For a file beginning #!, the arguments passed to the program (/bin/rc in the example above) will be the name of the file being executed, any arguments on the #! line, the name of the file again, and finally the second and subsequent arguments given to the original exec call. The result honors the two conventions of a program accepting as argument a file to be interpreted and argv naming the file being executed.
Most attributes of the calling process are carried into the result; in particular, files remain open across exec (except those opened with OCEXEC OR'd into the open mode; see open(2)); and the working directory and environment (see env(3)) remain the same. However, a newly exec'ed process has no notification handler (see notify(2)).
The global cell _privates points to an array of _nprivates elements of per–process private data. This storage is private for each process, even if the processes share data segments.
When the new program begins, the global pointer _tos is set to the address of a structure that holds information allowing accurate time keeping and clock reading in user space. These data are updated by the kernel during of the life of the process, including across rforks and execs. If there is a user–space accessible fast clock (a processor cycle counter), cyclefreq will be set to its frequency in Hz. Kcycles (pcycles) counts the number of cycles this process has spent in kernel mode (kernel and user mode). Pid is the current process's id. Clock is the user–profiling clock (see prof(1)). Its time is measured in milliseconds but is updated at a system–dependent lower rate. This clock is typically used by the profiler but is available to all programs.
The above conventions apply to C programs; the raw system interface
to the new image is as follows: the word pointed to by the stack
pointer is argc; the words beyond that are the zeroth and subsequent
elements of argv, followed by a terminating null pointer; and
the return register (e.g. R0 on the 68020)
contains the address of the clock information.
prof(1), intro(2), stat(2)|
If these functions fail, they return and set errstr. There can
be no return to the calling process from a successful exec or
execl; the calling image is lost.|
There is a large but finite limit on the size of an argment list.
The 9 kernel constant TSTKSIZ controls this and typically yields
about one megabyte. In 9k, it's USTKSIZE, which is typically larger
(e.g., 16MB). |
Both functions rely upon the system's demand paging, which in
turn expects to be able to read full pages in a single read operation,
no matter what the underlying file server is.