servers/vm/fork.c

   1
   2 #define _SYSTEM 1
   3
   4 #include <minix/callnr.h>
   5 #include <minix/com.h>
   6 #include <minix/config.h>
   7 #include <minix/const.h>
   8 #include <minix/ds.h>
   9 #include <minix/endpoint.h>
  10 #include <minix/keymap.h>
  11 #include <minix/minlib.h>
  12 #include <minix/type.h>
  13 #include <minix/ipc.h>
  14 #include <minix/sysutil.h>
  15 #include <minix/syslib.h>
  16 #include <minix/debug.h>
  17 #include <minix/bitmap.h>
  18
  19 #include <string.h>
  20 #include <errno.h>
  21 #include <env.h>
  22 #include <assert.h>
  23
  24 #include "glo.h"
  25 #include "vm.h"
  26 #include "proto.h"
  27 #include "util.h"
  28 #include "sanitycheck.h"
  29 #include "region.h"
  30 #include "memory.h"
  31
  32 /*===========================================================================*
  33  *                              do_fork                                      *
  34  *===========================================================================*/
  35 PUBLIC int do_fork(message *msg)
  36 {
  37   int r, proc, s, childproc, fullvm;
  38   struct vmproc *vmp, *vmc;
  39   pt_t origpt;
  40   vir_bytes msgaddr;
  41
  42   SANITYCHECK(SCL_FUNCTIONS);
  43
  44   if(vm_isokendpt(msg->VMF_ENDPOINT, &proc) != OK) {
  45         printf("VM: bogus endpoint VM_FORK %d\n", msg->VMF_ENDPOINT);
  46   SANITYCHECK(SCL_FUNCTIONS);
  47         return EINVAL;
  48   }
  49
  50   childproc = msg->VMF_SLOTNO;
  51   if(childproc < 0 || childproc >= NR_PROCS) {
  52         printf("VM: bogus slotno VM_FORK %d\n", msg->VMF_SLOTNO);
  53   SANITYCHECK(SCL_FUNCTIONS);
  54         return EINVAL;
  55   }
  56
  57   vmp = &vmproc[proc];          /* parent */
  58   vmc = &vmproc[childproc];     /* child */
  59   vm_assert(vmc->vm_slot == childproc);
  60
  61   NOTRUNNABLE(vmp->vm_endpoint);
  62
  63   if(vmp->vm_flags & VMF_HAS_DMA) {
  64         printf("VM: %d has DMA memory and may not fork\n", msg->VMF_ENDPOINT);
  65         return EINVAL;
  66   }
  67
  68   fullvm = vmp->vm_flags & VMF_HASPT;
  69
  70   /* The child is basically a copy of the parent. */
  71   origpt = vmc->vm_pt;
  72   *vmc = *vmp;
  73   vmc->vm_slot = childproc;
  74   vmc->vm_regions = NULL;
  75   vmc->vm_endpoint = NONE;      /* In case someone tries to use it. */
  76   vmc->vm_pt = origpt;
  77   vmc->vm_flags |= VMF_HASPT;
  78
  79 #if VMSTATS
  80   vmc->vm_bytecopies = 0;
  81 #endif
  82
  83   if(pt_new(&vmc->vm_pt) != OK) {
  84         printf("VM: fork: pt_new failed\n");
  85         return ENOMEM;
  86   }
  87
  88   if(fullvm) {
  89         SANITYCHECK(SCL_DETAIL);
  90
  91         if(map_proc_copy(vmc, vmp) != OK) {
  92                 printf("VM: fork: map_proc_copy failed\n");
  93                 pt_free(&vmc->vm_pt);
  94                 return(ENOMEM);
  95         }
  96
  97         if(vmp->vm_heap) {
  98                 vmc->vm_heap = map_region_lookup_tag(vmc, VRT_HEAP);
  99                 vm_assert(vmc->vm_heap);
 100         }
 101
 102         SANITYCHECK(SCL_DETAIL);
 103   } else {
 104         vir_bytes sp;
 105         phys_bytes d_abs, s_abs;
 106         vir_bytes text_bytes, data_bytes, stack_bytes, parent_gap_bytes,
 107                 child_gap_bytes;
 108
 109         /* Get SP of new process (using parent). */
 110         if(get_stack_ptr(vmp->vm_endpoint, &sp) != OK) {
 111                 printf("VM: fork: get_stack_ptr failed for %d\n",
 112                         vmp->vm_endpoint);
 113                 return ENOMEM;
 114         }
 115
 116         /* Update size of stack segment using current SP. */
 117         if(adjust(vmp, vmp->vm_arch.vm_seg[D].mem_len, sp) != OK) {
 118                 printf("VM: fork: adjust failed for %d\n",
 119                         vmp->vm_endpoint);
 120                 return ENOMEM;
 121         }
 122
 123         /* Copy newly adjust()ed stack segment size to child. */
 124         vmc->vm_arch.vm_seg[S] = vmp->vm_arch.vm_seg[S];
 125
 126         text_bytes = CLICK2ABS(vmc->vm_arch.vm_seg[T].mem_len);
 127         data_bytes = CLICK2ABS(vmc->vm_arch.vm_seg[D].mem_len);
 128         stack_bytes = CLICK2ABS(vmc->vm_arch.vm_seg[S].mem_len);
 129
 130         /* how much space after break and before lower end (which is the
 131          * logical top) of stack for the parent
 132          */
 133         parent_gap_bytes = CLICK2ABS(vmc->vm_arch.vm_seg[S].mem_vir -
 134                 vmc->vm_arch.vm_seg[D].mem_len);
 135
 136         /* how much space can the child stack grow downwards, below
 137          * the current SP? The rest of the gap is available for the
 138          * heap to grow upwards.
 139          */
 140         child_gap_bytes = VM_PAGE_SIZE;
 141
 142         if((r=proc_new(vmc, VM_PROCSTART,
 143                 text_bytes, data_bytes, stack_bytes, child_gap_bytes, 0, 0,
 144                 CLICK2ABS(vmc->vm_arch.vm_seg[S].mem_vir +
 145                         vmc->vm_arch.vm_seg[S].mem_len), 1)) != OK) {
 146                         printf("VM: fork: proc_new failed\n");
 147                         return r;
 148         }
 149
 150         if((d_abs = map_lookup_phys(vmc, VRT_HEAP)) == MAP_NONE)
 151                 panic("couldn't lookup data");
 152         if((s_abs = map_lookup_phys(vmc, VRT_STACK)) == MAP_NONE)
 153                 panic("couldn't lookup stack");
 154
 155         /* Now copy the memory regions. */
 156
 157         if(vmc->vm_arch.vm_seg[T].mem_len > 0) {
 158                 phys_bytes t_abs;
 159                 if((t_abs = map_lookup_phys(vmc, VRT_TEXT)) == MAP_NONE)
 160                         panic("couldn't lookup text");
 161                 if(sys_abscopy(CLICK2ABS(vmp->vm_arch.vm_seg[T].mem_phys),
 162                         t_abs, text_bytes) != OK)
 163                                 panic("couldn't copy text");
 164         }
 165
 166         if(sys_abscopy(CLICK2ABS(vmp->vm_arch.vm_seg[D].mem_phys),
 167                 d_abs, data_bytes) != OK)
 168                         panic("couldn't copy data");
 169
 170         if(sys_abscopy(
 171                 CLICK2ABS(vmp->vm_arch.vm_seg[D].mem_phys +
 172                         vmc->vm_arch.vm_seg[D].mem_len) + parent_gap_bytes,
 173                         s_abs + child_gap_bytes, stack_bytes) != OK)
 174                         panic("couldn't copy stack");
 175   }
 176
 177   /* Only inherit these flags. */
 178   vmc->vm_flags &= (VMF_INUSE|VMF_SEPARATE|VMF_HASPT);
 179
 180   /* inherit the priv call bitmaps */
 181   memcpy(&vmc->vm_call_mask, &vmp->vm_call_mask, sizeof(vmc->vm_call_mask));
 182
 183   /* Tell kernel about the (now successful) FORK. */
 184   if((r=sys_fork(vmp->vm_endpoint, childproc,
 185         &vmc->vm_endpoint, vmc->vm_arch.vm_seg,
 186         PFF_VMINHIBIT, &msgaddr)) != OK) {
 187         panic("do_fork can't sys_fork: %d", r);
 188   }
 189
 190   NOTRUNNABLE(vmp->vm_endpoint);
 191   NOTRUNNABLE(vmc->vm_endpoint);
 192
 193   if(fullvm) {
 194         vir_bytes vir;
 195         /* making these messages writable is an optimisation
 196          * and its return value needn't be checked.
 197          */
 198         vir = arch_vir2map(vmc, msgaddr);
 199         handle_memory(vmc, vir, sizeof(message), 1);
 200         vir = arch_vir2map(vmp, msgaddr);
 201         handle_memory(vmp, vir, sizeof(message), 1);
 202   }
 203
 204   if((r=pt_bind(&vmc->vm_pt, vmc)) != OK)
 205         panic("fork can't pt_bind: %d", r);
 206
 207   /* Inform caller of new child endpoint. */
 208   msg->VMF_CHILD_ENDPOINT = vmc->vm_endpoint;
 209
 210   SANITYCHECK(SCL_FUNCTIONS);
 211   return OK;
 212 }
 213