minix/lib/libc/sys/stack_utils.c

   1 /* Utilities to generate a proper C stack.
   2  *
   3  * Author: Lionel A. Sambuc.
   4  */
   5
   6 #define _MINIX_SYSTEM
   7
   8 #include <sys/cdefs.h>
   9 #include "namespace.h"
  10 #include <lib.h>
  11
  12 #include <unistd.h>
  13 #include <string.h>
  14 #include <stddef.h>
  15 #include <sys/exec_elf.h>
  16 #include <sys/exec.h>
  17
  18 /* Create a stack image that only needs to be patched up slightly by
  19  * the kernel to be used for the process to be executed.
  20  *
  21  * Every pointers are stored here as offset from the frame base, and
  22  * will be adapted as required for the new process address space.
  23  *
  24  * The following parameters are passed by register to either __start
  25  * for static binaries, or _rtld_start for dynamic ones:
  26  *     *fct, *ObjEntry, *ps_string
  27  *
  28  * The following stack layout is expected by _rtld():
  29  *
  30  * | XXXXXXXXXX | 0x0000_00000
  31  * |  ...       |
  32  * |  ...       | Top of the stack
  33  * | argc       |
  34  * | *argv1     | points to the first char of the argv1
  35  * |  ...       |
  36  * | *argvN     |
  37  * | NULL       |
  38  * | *env1      |
  39  * |  ...       |
  40  * | *envN      |
  41  * | NULL       |
  42  * | ElfAuxV1   |
  43  * |  ...       |
  44  * | ElfAuxVX   |
  45  * | AuxExecName| fully resolve executable name, as an ASCIIZ string,
  46  *                at most PMEF_EXECNAMELEN1 long.
  47  *
  48  * Here we put first the strings, then word-align, then ps_strings, to
  49  * comply with the expected layout of NetBSD. This seems to matter for
  50  * the NetBSD ps command, so let's make sure we are compatible...
  51  *
  52  * | strings    | Maybe followed by some padding to word-align.
  53  * | **argv     | \
  54  * | argc       |  +---> ps_string structure content.
  55  * | **env      |  |
  56  * | envc       | /
  57  * | sigcode    | On NetBSD, there may be a compatibility stub here,
  58  * +------------+    for native code, it is not present.
  59  *   Stack Base , 0xF000_0000, descending stack.
  60  */
  61
  62 /* The minimum size of the frame is composed of:
  63  * argc, the NULL terminator for argv as well as one for
  64  * environ, the ELF Aux vectors, executable name and the
  65  * ps_strings struct. */
  66 #define STACK_MIN_SZ \
  67 ( \
  68         sizeof(int) + sizeof(void *) * 2 + \
  69         sizeof(AuxInfo) * PMEF_AUXVECTORS + PMEF_EXECNAMELEN1 + \
  70         sizeof(struct ps_strings) \
  71 )
  72
  73 /*****************************************************************************
  74  * Computes stack size, argc, envc, for a given set of path, argv, envp.     *
  75  *****************************************************************************/
  76 void minix_stack_params(const char *path, char * const *argv, char * const *envp,
  77         size_t *stack_size,  char *overflow, int *argc, int *envc)
  78 {
  79         char * const *p;
  80         size_t const min_size = STACK_MIN_SZ;
  81
  82         *stack_size = min_size; /* Size of the new initial stack. */
  83         *overflow = 0;          /* No overflow yet. */
  84         *argc = 0;              /* Argument count. */
  85         *envc = 0;              /* Environment count */
  86
  87         /* Compute and add the size required to store argv and env. */
  88         for (p = argv; *p != NULL; p++) {
  89                 size_t const n = sizeof(*p) + strlen(*p) + 1;
  90                 *stack_size += n;
  91                 if (*stack_size < n) {
  92                         *overflow = 1;
  93                 }
  94                 (*argc)++;
  95         }
  96
  97         for (p = envp; p && *p != NULL; p++) {
  98                 size_t const n = sizeof(*p) + strlen(*p) + 1;
  99                 *stack_size += n;
 100                 if (*stack_size < n) {
 101                         *overflow = 1;
 102                 }
 103                 (*envc)++;
 104         }
 105
 106         /* Compute the aligned frame size. */
 107         *stack_size = (*stack_size + sizeof(void *) - 1) &
 108                  ~(sizeof(void *) - 1);
 109
 110         if (*stack_size < min_size) {
 111                 /* This is possible only in case of overflow. */
 112                 *overflow = 1;
 113         }
 114 }
 115
 116 /*****************************************************************************
 117  * Generate a stack in the buffer frame, ready to be used.                   *
 118  *****************************************************************************/
 119 void minix_stack_fill(const char *path, int argc, char * const *argv,
 120         int envc, char * const *envp, size_t stack_size, char *frame,
 121         int *vsp, struct ps_strings **psp)
 122 {
 123         char * const *p;
 124
 125         /* Frame pointers (a.k.a stack pointer within the buffer in current
 126          * address space.) */
 127         char *fp;       /* byte aligned */
 128         char **fpw;     /* word aligned */
 129
 130         size_t const min_size = STACK_MIN_SZ;
 131
 132         /* Virtual address of the stack pointer, in new memory space. */
 133         *vsp = minix_get_user_sp() - stack_size;
 134
 135         /* Fill in the frame now. */
 136         fpw = (char **) frame;
 137         *fpw++ = (char *) argc;
 138
 139         /* The strings themselves are stored after the aux vectors,
 140          * cf. top comment. */
 141         fp = frame + (min_size - sizeof(struct ps_strings)) +
 142                 (envc + argc) * sizeof(char *);
 143
 144         /* Fill in argv and the environment, as well as copy the strings
 145          * themselves. */
 146         for (p = argv; *p != NULL; p++) {
 147                 size_t const n = strlen(*p) + 1;
 148                 *fpw++= (char *)(*vsp + (fp - frame));
 149                 memcpy(fp, *p, n);
 150                 fp += n;
 151         }
 152         *fpw++ = NULL;
 153
 154         for (p = envp; p && *p != NULL; p++) {
 155                 size_t const n = strlen(*p) + 1;
 156                 *fpw++= (char *)(*vsp + (fp - frame));
 157                 memcpy(fp, *p, n);
 158                 fp += n;
 159         }
 160         *fpw++ = NULL;
 161
 162         /* Padding, because of the stack alignement. */
 163         while ((size_t)fp % sizeof(void *)) *fp++= 0;
 164
 165         /* Fill in the ps_string struct*/
 166         *psp = (struct ps_strings *) fp;
 167
 168         (*psp)->ps_argvstr = (char **)(*vsp + sizeof(argc));
 169         (*psp)->ps_nargvstr = argc;
 170         (*psp)->ps_envstr = (*psp)->ps_argvstr + argc + 1;
 171         (*psp)->ps_nenvstr = envc;
 172 }