/[hurd]/hurd/boot/boot.c
ViewVC logotype

Diff of /hurd/boot/boot.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.104 by marcus, Mon May 13 17:30:40 2002 UTC revision 1.105 by roland, Wed May 29 02:42:28 2002 UTC
# Line 138  char bootstrap_args[100] = "-"; Line 138  char bootstrap_args[100] = "-";
138  char *bootdevice = 0;  char *bootdevice = 0;
139  char *bootscript = 0;  char *bootscript = 0;
140    
 void set_mach_stack_args (task_t, thread_t, char *, ...);  
141    
142  void safe_gets (char *buf, int buf_len)  void safe_gets (char *buf, int buf_len)
143  {  {
# Line 275  load_image (task_t t, Line 274  load_image (task_t t,
274        lseek (fd, sizeof hdr.a - headercruft, SEEK_SET);        lseek (fd, sizeof hdr.a - headercruft, SEEK_SET);
275        read (fd, buf, amount);        read (fd, buf, amount);
276        vm_allocate (t, &base, rndamount, 0);        vm_allocate (t, &base, rndamount, 0);
277        vm_write (t, base, (u_int) buf, rndamount);        vm_write (t, base, (vm_address_t) buf, rndamount);
278        if (magic != OMAGIC)        if (magic != OMAGIC)
279          vm_protect (t, base, trunc_page (headercruft + hdr.a.a_text),          vm_protect (t, base, trunc_page (headercruft + hdr.a.a_text),
280                      0, VM_PROT_READ | VM_PROT_EXECUTE);                      0, VM_PROT_READ | VM_PROT_EXECUTE);
# Line 343  boot_script_exec_cmd (void *hook, Line 342  boot_script_exec_cmd (void *hook,
342  {  {
343    char *args, *p;    char *args, *p;
344    int arg_len, i;    int arg_len, i;
345    unsigned reg_size;    size_t reg_size;
346    void *arg_pos;    void *arg_pos;
347    vm_offset_t stack_start, stack_end;    vm_offset_t stack_start, stack_end;
348    vm_address_t startpc, str_start;    vm_address_t startpc, str_start;
349    thread_t thread;    thread_t thread;
   struct i386_thread_state regs;  
350    
351    write (2, path, strlen (path));    write (2, path, strlen (path));
352    for (i = 1; i < argc; ++i)    for (i = 1; i < argc; ++i)
# Line 359  boot_script_exec_cmd (void *hook, Line 357  boot_script_exec_cmd (void *hook,
357    write (2, "\r\n", 2);    write (2, "\r\n", 2);
358    
359    startpc = load_image (task, path);    startpc = load_image (task, path);
   thread_create (task, &thread);  
360    arg_len = stringlen + (argc + 2) * sizeof (char *) + sizeof (integer_t);    arg_len = stringlen + (argc + 2) * sizeof (char *) + sizeof (integer_t);
361    arg_len += 5 * sizeof (int);    arg_len += 5 * sizeof (int);
362    stack_end = VM_MAX_ADDRESS;    stack_end = VM_MAX_ADDRESS;
363    stack_start = VM_MAX_ADDRESS - 16 * 1024 * 1024;    stack_start = VM_MAX_ADDRESS - 16 * 1024 * 1024;
364    vm_allocate (task, &stack_start, stack_end - stack_start, FALSE);    vm_allocate (task, &stack_start, stack_end - stack_start, FALSE);
365    reg_size = i386_THREAD_STATE_COUNT;    arg_pos = (void *) ((stack_end - arg_len) & ~(sizeof (natural_t) - 1));
   thread_get_state (thread, i386_THREAD_STATE,  
                     (thread_state_t) &regs, &reg_size);  
   regs.eip = (int) startpc;  
   regs.uesp = (int) ((stack_end - arg_len) & ~(sizeof (int) - 1));  
   thread_set_state (thread, i386_THREAD_STATE,  
                     (thread_state_t) &regs, reg_size);  
   arg_pos = (void *) regs.uesp;  
366    args = mmap (0, stack_end - trunc_page ((vm_offset_t) arg_pos),    args = mmap (0, stack_end - trunc_page ((vm_offset_t) arg_pos),
367                 PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);                 PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
368    str_start = ((vm_address_t) arg_pos    str_start = ((vm_address_t) arg_pos
# Line 389  boot_script_exec_cmd (void *hook, Line 379  boot_script_exec_cmd (void *hook,
379              stack_end - trunc_page ((vm_offset_t) arg_pos));              stack_end - trunc_page ((vm_offset_t) arg_pos));
380    munmap ((caddr_t) args,    munmap ((caddr_t) args,
381            stack_end - trunc_page ((vm_offset_t) arg_pos));            stack_end - trunc_page ((vm_offset_t) arg_pos));
382    
383      thread_create (task, &thread);
384    #ifdef I386_THREAD_STATE
385      {
386        struct i386_thread_state regs;
387        reg_size = i386_THREAD_STATE_COUNT;
388        thread_get_state (thread, i386_THREAD_STATE,
389                          (thread_state_t) &regs, &reg_size);
390        regs.eip = (int) startpc;
391        regs.uesp = (int) arg_pos;
392        thread_set_state (thread, i386_THREAD_STATE,
393                          (thread_state_t) &regs, reg_size);
394      }
395    #elif ALPHA_THREAD_STATE
396      {
397        struct alpha_thread_state regs;
398        reg_size = ALPHA_THREAD_STATE_COUNT;
399        thread_get_state (thread, ALPHA_THREAD_STATE,
400                          (thread_state_t) &regs, &reg_size);
401        regs.r30 = (natural_t) arg_pos;
402        regs.pc = (natural_t) startpc;
403        thread_set_state (thread, ALPHA_THREAD_STATE,
404                          (thread_state_t) &regs, reg_size);
405      }
406    #else
407    # error needs to be ported
408    #endif
409    
410    thread_resume (thread);    thread_resume (thread);
411    mach_port_deallocate (mach_task_self (), thread);    mach_port_deallocate (mach_task_self (), thread);
412    return 0;    return 0;
# Line 527  main (int argc, char **argv, char **envp Line 545  main (int argc, char **argv, char **envp
545    if (boot_script_set_variable ("host-port", VAL_PORT,    if (boot_script_set_variable ("host-port", VAL_PORT,
546                                  (int) privileged_host_port)                                  (int) privileged_host_port)
547        || boot_script_set_variable ("device-port", VAL_PORT,        || boot_script_set_variable ("device-port", VAL_PORT,
548                                     (int) pseudo_master_device_port)                                     (integer_t) pseudo_master_device_port)
549        || boot_script_set_variable ("kernel-command-line", VAL_STR,        || boot_script_set_variable ("kernel-command-line", VAL_STR,
550                                     (int) kernel_command_line)                                     (integer_t) kernel_command_line)
551        || boot_script_set_variable ("root-device", VAL_STR, (int) bootdevice)        || boot_script_set_variable ("root-device",
552        || boot_script_set_variable ("boot-args", VAL_STR, (int) bootstrap_args))                                     VAL_STR, (integer_t) bootdevice)
553          || boot_script_set_variable ("boot-args",
554                                       VAL_STR, (integer_t) bootstrap_args))
555      {      {
556        static const char msg[] = "error setting variable";        static const char msg[] = "error setting variable";
557    
# Line 552  main (int argc, char **argv, char **envp Line 572  main (int argc, char **argv, char **envp
572         if (eq == 0)         if (eq == 0)
573           continue;           continue;
574         *eq++ = '\0';         *eq++ = '\0';
575         err = boot_script_set_variable (word, VAL_STR, (int) eq);         err = boot_script_set_variable (word, VAL_STR, (integer_t) eq);
576         if (err)         if (err)
577           {           {
578             char *msg;             char *msg;
# Line 680  main (int argc, char **argv, char **envp Line 700  main (int argc, char **argv, char **envp
700  /*  mach_msg_server (request_server, __vm_page_size * 2, receive_set); */  /*  mach_msg_server (request_server, __vm_page_size * 2, receive_set); */
701  }  }
702    
 /* Set up stack args the Mach way */  
 void  
 set_mach_stack_args (task_t user_task,  
                      thread_t user_thread,  
                      char *startpc, ...)  
 {  
   /* This code is lifted from .../mk/bootstrap/load.c. */  
   va_list                       argv_ptr;  
   char *                        arg_ptr;  
   
   int                   arg_len;  
   int                   arg_count;  
   char *                        arg_pos;  
   unsigned int          arg_item_len;  
   
         /*  
          * Calculate the size of the argument list.  
          */  
         va_start(argv_ptr, startpc);  
         arg_len = 0;  
         arg_count = 0;  
         for (;;) {  
             arg_ptr = va_arg(argv_ptr, char *);  
             if (arg_ptr == (char *)0)  
                 break;  
             arg_count++;  
             arg_len += strlen(arg_ptr) + 1;     /* space for '\0' */  
         }  
         va_end(argv_ptr);  
         /*  
          * Add space for:  
          *    arg_count  
          *    pointers to arguments  
          *    trailing 0 pointer  
          *    dummy 0 pointer to environment variables  
          *    and align to integer boundary  
          */  
         arg_len += sizeof(integer_t) + (2 + arg_count) * sizeof(char *);  
         arg_len = (arg_len + (sizeof(integer_t) - 1)) & ~(sizeof(integer_t)-1);  
   
   
   /* This small piece is from .../mk/bootstrap/i386/exec.c. */  
   {  
         vm_offset_t     stack_start;  
         vm_offset_t     stack_end;  
         struct i386_thread_state        regs;  
         unsigned int            reg_size;  
   
 #define STACK_SIZE (1024 * 1024 * 16)  
   
         /*  
          * Add space for 5 ints to arguments, for  
          * PS program. XXX  
          */  
         arg_len += 5 * sizeof(int);  
   
         /*  
          * Allocate stack.  
          */  
         stack_end = VM_MAX_ADDRESS;  
         stack_start = VM_MAX_ADDRESS - STACK_SIZE;  
         (void)vm_allocate(user_task,  
                           &stack_start,  
                           (vm_size_t)(stack_end - stack_start),  
                           FALSE);  
   
         reg_size = i386_THREAD_STATE_COUNT;  
         (void)thread_get_state(user_thread,  
                                 i386_THREAD_STATE,  
                                 (thread_state_t)&regs,  
                                 &reg_size);  
   
         regs.eip = (int) startpc;  
         regs.uesp = (int)((stack_end - arg_len) & ~(sizeof(int)-1));  
   
         (void)thread_set_state(user_thread,  
                                 i386_THREAD_STATE,  
                                 (thread_state_t)&regs,  
                                 reg_size);  
   
         arg_pos = (void *) regs.uesp;  
       }  
   
         /*  
          * Copy out the arguments.  
          */  
         {  
             vm_offset_t u_arg_start;  
                                 /* user start of argument list block */  
             vm_offset_t k_arg_start;  
                                 /* kernel start of argument list block */  
             vm_offset_t u_arg_page_start;  
                                 /* user start of args, page-aligned */  
             vm_size_t   arg_page_size;  
                                 /* page_aligned size of args */  
             vm_offset_t k_arg_page_start;  
                                 /* kernel start of args, page-aligned */  
   
             register  
             char **     k_ap;   /* kernel arglist address */  
             char *      u_cp;   /* user argument string address */  
             register  
             char *      k_cp;   /* kernel argument string address */  
             register  
             int         i;  
   
             /*  
              * Get address of argument list in user space  
              */  
             u_arg_start = (vm_offset_t)arg_pos;  
   
             /*  
              * Round to page boundaries, and allocate kernel copy  
              */  
             u_arg_page_start = trunc_page(u_arg_start);  
             arg_page_size = (vm_size_t)(round_page(u_arg_start + arg_len)  
                                         - u_arg_page_start);  
   
             k_arg_page_start = (vm_address_t) mmap (0, arg_page_size,  
                                                     PROT_READ|PROT_WRITE,  
                                                     MAP_ANON, 0, 0);  
   
             /*  
              * Set up addresses corresponding to user pointers  
              * in the kernel block  
              */  
             k_arg_start = k_arg_page_start + (u_arg_start - u_arg_page_start);  
   
             k_ap = (char **)k_arg_start;  
   
             /*  
              * Start the strings after the arg-count and pointers  
              */  
             u_cp = (char *)u_arg_start + arg_count * sizeof(char *)  
                                         + 2 * sizeof(char *)  
                                         + sizeof(integer_t);  
             k_cp = (char *)k_arg_start + arg_count * sizeof(char *)  
                                         + 2 * sizeof(char *)  
                                         + sizeof(integer_t);  
   
             /*  
              * first the argument count  
              */  
             *k_ap++ = (char *)(natural_t)arg_count;  
   
             /*  
              * Then the strings and string pointers for each argument  
              */  
             va_start(argv_ptr, startpc);  
             for (i = 0; i < arg_count; i++) {  
                 arg_ptr = va_arg(argv_ptr, char *);  
                 arg_item_len = strlen(arg_ptr) + 1; /* include trailing 0 */  
   
                 /* set string pointer */  
                 *k_ap++ = u_cp;  
   
                 /* copy string */  
                 bcopy(arg_ptr, k_cp, arg_item_len);  
                 k_cp += arg_item_len;  
                 u_cp += arg_item_len;  
             }  
             va_end(argv_ptr);  
   
             /*  
              * last, the trailing 0 argument and a null environment pointer.  
              */  
             *k_ap++ = (char *)0;  
             *k_ap   = (char *)0;  
   
             /*  
              * Now write all of this to user space.  
              */  
             (void) vm_write(user_task,  
                             u_arg_page_start,  
                             k_arg_page_start,  
                             arg_page_size);  
   
             (void) munmap ((caddr_t) k_arg_page_start,  
                            arg_page_size);  
         }  
 }  
   
   
703  void  void
704  msg_thread()  msg_thread()
705  {  {
# Line 1141  ds_device_write (device_t device, Line 978  ds_device_write (device_t device,
978                   dev_mode_t mode,                   dev_mode_t mode,
979                   recnum_t recnum,                   recnum_t recnum,
980                   io_buf_ptr_t data,                   io_buf_ptr_t data,
981                   unsigned int datalen,                   size_t datalen,
982                   int *bytes_written)                   int *bytes_written)
983  {  {
984    if (device == pseudo_console)    if (device == pseudo_console)
# Line 1175  ds_device_write_inband (device_t device, Line 1012  ds_device_write_inband (device_t device,
1012                          dev_mode_t mode,                          dev_mode_t mode,
1013                          recnum_t recnum,                          recnum_t recnum,
1014                          io_buf_ptr_inband_t data,                          io_buf_ptr_inband_t data,
1015                          unsigned int datalen,                          size_t datalen,
1016                          int *bytes_written)                          int *bytes_written)
1017  {  {
1018    if (device == pseudo_console)    if (device == pseudo_console)
# Line 1210  ds_device_read (device_t device, Line 1047  ds_device_read (device_t device,
1047                  recnum_t recnum,                  recnum_t recnum,
1048                  int bytes_wanted,                  int bytes_wanted,
1049                  io_buf_ptr_t *data,                  io_buf_ptr_t *data,
1050                  unsigned int *datalen)                  size_t *datalen)
1051  {  {
1052    if (device == pseudo_console)    if (device == pseudo_console)
1053      {      {
# Line 1265  ds_device_read_inband (device_t device, Line 1102  ds_device_read_inband (device_t device,
1102                         recnum_t recnum,                         recnum_t recnum,
1103                         int bytes_wanted,                         int bytes_wanted,
1104                         io_buf_ptr_inband_t data,                         io_buf_ptr_inband_t data,
1105                         unsigned int *datalen)                         size_t *datalen)
1106  {  {
1107    if (device == pseudo_console)    if (device == pseudo_console)
1108      {      {
# Line 1328  kern_return_t Line 1165  kern_return_t
1165  ds_xxx_device_set_status (device_t device,  ds_xxx_device_set_status (device_t device,
1166                            dev_flavor_t flavor,                            dev_flavor_t flavor,
1167                            dev_status_t status,                            dev_status_t status,
1168                            u_int statu_cnt)                            size_t statu_cnt)
1169  {  {
1170    if (device != pseudo_console)    if (device != pseudo_console)
1171      return D_NO_SUCH_DEVICE;      return D_NO_SUCH_DEVICE;
# Line 1339  kern_return_t Line 1176  kern_return_t
1176  ds_xxx_device_get_status (device_t device,  ds_xxx_device_get_status (device_t device,
1177                            dev_flavor_t flavor,                            dev_flavor_t flavor,
1178                            dev_status_t status,                            dev_status_t status,
1179                            u_int *statuscnt)                            size_t *statuscnt)
1180  {  {
1181    if (device != pseudo_console && device != pseudo_root)    if (device != pseudo_console && device != pseudo_root)
1182      return D_NO_SUCH_DEVICE;      return D_NO_SUCH_DEVICE;
# Line 1351  ds_xxx_device_set_filter (device_t devic Line 1188  ds_xxx_device_set_filter (device_t devic
1188                            mach_port_t rec,                            mach_port_t rec,
1189                            int pri,                            int pri,
1190                            filter_array_t filt,                            filter_array_t filt,
1191                            unsigned int len)                            size_t len)
1192  {  {
1193    if (device != pseudo_console && device != pseudo_root)    if (device != pseudo_console && device != pseudo_root)
1194      return D_NO_SUCH_DEVICE;      return D_NO_SUCH_DEVICE;
# Line 1375  kern_return_t Line 1212  kern_return_t
1212  ds_device_set_status (device_t device,  ds_device_set_status (device_t device,
1213                        dev_flavor_t flavor,                        dev_flavor_t flavor,
1214                        dev_status_t status,                        dev_status_t status,
1215                        unsigned int statuslen)                        size_t statuslen)
1216  {  {
1217    if (device != pseudo_console && device != pseudo_root)    if (device != pseudo_console && device != pseudo_root)
1218      return D_NO_SUCH_DEVICE;      return D_NO_SUCH_DEVICE;
# Line 1386  kern_return_t Line 1223  kern_return_t
1223  ds_device_get_status (device_t device,  ds_device_get_status (device_t device,
1224                        dev_flavor_t flavor,                        dev_flavor_t flavor,
1225                        dev_status_t status,                        dev_status_t status,
1226                        unsigned int *statuslen)                        size_t *statuslen)
1227  {  {
1228    if (device == pseudo_console)    if (device == pseudo_console)
1229      return D_INVALID_OPERATION;      return D_INVALID_OPERATION;
# Line 1412  ds_device_set_filter (device_t device, Line 1249  ds_device_set_filter (device_t device,
1249                        mach_port_t receive_port,                        mach_port_t receive_port,
1250                        int priority,                        int priority,
1251                        filter_array_t filter,                        filter_array_t filter,
1252                        unsigned int filterlen)                        size_t filterlen)
1253  {  {
1254    if (device != pseudo_console && device != pseudo_root)    if (device != pseudo_console && device != pseudo_root)
1255      return D_NO_SUCH_DEVICE;      return D_NO_SUCH_DEVICE;
# Line 1732  S_io_reauthenticate (mach_port_t object, Line 1569  S_io_reauthenticate (mach_port_t object,
1569  {  {
1570    uid_t *gu, *au;    uid_t *gu, *au;
1571    gid_t *gg, *ag;    gid_t *gg, *ag;
1572    unsigned int gulen = 0, aulen = 0, gglen = 0, aglen = 0;    size_t gulen = 0, aulen = 0, gglen = 0, aglen = 0;
1573    error_t err;    error_t err;
1574    
1575    err = mach_port_insert_right (mach_task_self (), object, object,    err = mach_port_insert_right (mach_task_self (), object, object,
# Line 1765  S_io_restrict_auth (mach_port_t object, Line 1602  S_io_restrict_auth (mach_port_t object,
1602                      mach_port_t *newobject,                      mach_port_t *newobject,
1603                      mach_msg_type_name_t *newobjtype,                      mach_msg_type_name_t *newobjtype,
1604                      uid_t *uids,                      uid_t *uids,
1605                      u_int nuids,                      size_t nuids,
1606                      uid_t *gids,                      uid_t *gids,
1607                      u_int ngids)                      size_t ngids)
1608  {  {
1609    if (object != pseudo_console)    if (object != pseudo_console)
1610      return EOPNOTSUPP;      return EOPNOTSUPP;

Legend:
Removed from v.1.104  
changed lines
  Added in v.1.105

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26