8dfc7699a6
reverse order to easily support variadic arguments. Thus, instead of using the proper stdarg.h macros (that nowadays are compiler-dependent), it may be tempting to directly take the address of the last argument and considering it as the start of an array. This is a shortcut that avoid looping to get all the arguments as the CPU already pushed them on the stack before the call to the function. Unfortunately, such an assumption is strictly compiler-dependent and compilers are free to move the last argument on the stack, as a local variable, and return the address of the location where the argument was stored, if asked for. This will break things as the rest of the array's argument are stored elsewhere (typically, a couple of words above the location where the argument was stored). This patch fixes the issue by allowing ACK to take the shortcut and enabling gcc/llvm-gcc to follow the right way.
114 lines
2.5 KiB
C
114 lines
2.5 KiB
C
/* execve() - basic program execution call Author: Kees J. Bot
|
|
* 21 Jan 1994
|
|
*/
|
|
|
|
#define _MINIX_SOURCE
|
|
|
|
#define execve _execve
|
|
#define sbrk _sbrk
|
|
#include <lib.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <stddef.h>
|
|
|
|
int execve(const char *path, char * const *argv, char * const *envp)
|
|
{
|
|
char * const *ap;
|
|
char * const *ep;
|
|
char *frame;
|
|
char **vp;
|
|
char *sp;
|
|
size_t argc;
|
|
size_t frame_size;
|
|
size_t string_off;
|
|
size_t n;
|
|
int ov;
|
|
message m;
|
|
|
|
/* Assumptions: size_t and char *, it's all the same thing. */
|
|
|
|
/* Create a stack image that only needs to be patched up slightly
|
|
* by the kernel to be used for the process to be executed.
|
|
*/
|
|
|
|
ov= 0; /* No overflow yet. */
|
|
frame_size= 0; /* Size of the new initial stack. */
|
|
string_off= 0; /* Offset to start of the strings. */
|
|
argc= 0; /* Argument count. */
|
|
|
|
for (ap= argv; *ap != NULL; ap++) {
|
|
n = sizeof(*ap) + strlen(*ap) + 1;
|
|
frame_size+= n;
|
|
if (frame_size < n) ov= 1;
|
|
string_off+= sizeof(*ap);
|
|
argc++;
|
|
}
|
|
|
|
for (ep= envp; *ep != NULL; ep++) {
|
|
n = sizeof(*ep) + strlen(*ep) + 1;
|
|
frame_size+= n;
|
|
if (frame_size < n) ov= 1;
|
|
string_off+= sizeof(*ap);
|
|
}
|
|
|
|
/* Add an argument count and two terminating nulls. */
|
|
frame_size+= sizeof(argc) + sizeof(*ap) + sizeof(*ep);
|
|
string_off+= sizeof(argc) + sizeof(*ap) + sizeof(*ep);
|
|
|
|
/* Align. */
|
|
frame_size= (frame_size + sizeof(char *) - 1) & ~(sizeof(char *) - 1);
|
|
|
|
/* The party is off if there is an overflow. */
|
|
if (ov || frame_size < 3 * sizeof(char *)) {
|
|
errno= E2BIG;
|
|
return -1;
|
|
}
|
|
|
|
/* Allocate space for the stack frame. */
|
|
if ((frame = (char *) sbrk(frame_size)) == (char *) -1) {
|
|
errno = E2BIG;
|
|
return -1;
|
|
}
|
|
|
|
/* Set arg count, init pointers to vector and string tables. */
|
|
* (size_t *) frame = argc;
|
|
vp = (char **) (frame + sizeof(argc));
|
|
sp = frame + string_off;
|
|
|
|
/* Load the argument vector and strings. */
|
|
for (ap= argv; *ap != NULL; ap++) {
|
|
*vp++= (char *) (sp - frame);
|
|
n= strlen(*ap) + 1;
|
|
memcpy(sp, *ap, n);
|
|
sp+= n;
|
|
}
|
|
*vp++= NULL;
|
|
|
|
/* Load the environment vector and strings. */
|
|
for (ep= envp; *ep != NULL; ep++) {
|
|
*vp++= (char *) (sp - frame);
|
|
n= strlen(*ep) + 1;
|
|
memcpy(sp, *ep, n);
|
|
sp+= n;
|
|
}
|
|
*vp++= NULL;
|
|
|
|
/* Padding. */
|
|
while (sp < frame + frame_size) *sp++= 0;
|
|
|
|
/* We can finally make the system call. */
|
|
m.m1_i1 = strlen(path) + 1;
|
|
m.m1_i2 = frame_size;
|
|
m.m1_p1 = (char *) path;
|
|
m.m1_p2 = frame;
|
|
|
|
/* Clear unused fields */
|
|
m.m1_i3 = 0;
|
|
m.m1_p3 = NULL;
|
|
|
|
(void) _syscall(MM, EXEC, &m);
|
|
|
|
/* Failure, return the memory used for the frame and exit. */
|
|
(void) sbrk(-frame_size);
|
|
return -1;
|
|
}
|