diff options
Diffstat (limited to 'exec')
| -rw-r--r-- | exec/exec.c | 578 |
1 files changed, 321 insertions, 257 deletions
diff --git a/exec/exec.c b/exec/exec.c index 93aa6906..0ad38e86 100644 --- a/exec/exec.c +++ b/exec/exec.c @@ -970,9 +970,8 @@ load (task_t usertask, struct execdata *e) bfd_map_over_sections (e->bfd, postload_section, e); } - } #endif - + } } #ifdef GZIP @@ -1123,6 +1122,7 @@ struct bootinfo size_t argvlen, envplen, dtablesize, nports, nints; mach_port_t *dtable, *portarray; int *intarray; + vm_address_t phdr_addr, phdr_size, user_entry; }; static inline error_t @@ -1143,35 +1143,6 @@ servercopy (void **arg, u_int argsize, boolean_t argcopy) return 0; } -/* Put PORT into *SLOT. If *SLOT isn't already null, then - mach_port_deallocate it first. If AUTHENTICATE is not null, then - do an io_reauthenticate transaction to determine the port to put in - *SLOT. If CONSUME is set, then don't create a new send right; - otherwise do. (It is an error for both CONSUME and AUTHENTICATE to be - set.) */ -static void -set_init_port (mach_port_t port, mach_port_t *slot, auth_t authenticate, - int consume) -{ - mach_port_t ref; - - if (*slot != MACH_PORT_NULL) - mach_port_deallocate (mach_task_self (), *slot); - if (authenticate != MACH_PORT_NULL && port != MACH_PORT_NULL) - { - ref = mach_reply_port (); - io_reauthenticate (port, ref, MACH_MSG_TYPE_MAKE_SEND); - auth_user_authenticate (authenticate, port, - ref, MACH_MSG_TYPE_MAKE_SEND, slot); - mach_port_destroy (mach_task_self (), ref); - } - else - { - *slot = port; - if (!consume && port != MACH_PORT_NULL) - mach_port_mod_refs (mach_task_self (), port, MACH_PORT_RIGHT_SEND, 1); - } -} static error_t do_exec (mach_port_t execserver, @@ -1190,10 +1161,12 @@ do_exec (mach_port_t execserver, task_t newtask = MACH_PORT_NULL; thread_t thread = MACH_PORT_NULL; struct bootinfo *boot = 0; + int *ports_replaced; int secure, defaults; vm_address_t phdr_addr = 0; vm_size_t phdr_size = 0; - + u_int i; + /* Prime E for executing FILE and check its validity. This must be an inline function because it stores pointers into alloca'd storage in E for later use in `load'. */ @@ -1242,6 +1215,9 @@ do_exec (mach_port_t execserver, if ((!std_ports || !std_ints) && (flags & (EXEC_SECURE|EXEC_DEFAULTS))) return EIEIO; + /* Suspend the existing task before frobnicating it. */ + if (oldtask != MACH_PORT_NULL && (e.error = task_suspend (oldtask))) + return e.error; /* Prime E for executing FILE and check its validity. */ prepare_and_check (file, &e); @@ -1263,8 +1239,217 @@ do_exec (mach_port_t execserver, } } - interp.file = MACH_PORT_NULL; + + if (oldtask == MACH_PORT_NULL) + flags |= EXEC_NEWTASK; + + if (flags & (EXEC_NEWTASK|EXEC_SECURE)) + { + /* Create the new task. If we are not being secure, then use OLDTASK + for the task_create RPC, in case it is something magical. */ + e.error = task_create (((flags & EXEC_SECURE) || + oldtask == MACH_PORT_NULL) ? + mach_task_self () : oldtask, + 0, &newtask); + if (e.error) + goto out; + } + else + newtask = oldtask; + + + { + /* Store the data that we will give in response + to the RPC on the new task's bootstrap port. */ + + /* Set boot->portarray[IDX] to NEW. If REAUTH is nonzero, + io_reauthenticate NEW and set it to the authenticated port. + If CONSUME is nonzero, a reference on NEW is consumed; + it is invalid to give nonzero values to both REAUTH and CONSUME. */ +#define use(idx, new, reauth, consume) \ + do { use1 (idx, new, reauth, consume); if (e.error) goto bootout; } while (0) + void use1 (unsigned int idx, mach_port_t new, + int reauth, int consume) + { + if (new != MACH_PORT_NULL && reauth) + { + mach_port_t ref = mach_reply_port (), authed; + e.error = io_reauthenticate (new, ref, MACH_MSG_TYPE_MAKE_SEND); + if (! e.error) + e.error = auth_user_authenticate + (boot->portarray[INIT_PORT_AUTH], + new, ref, MACH_MSG_TYPE_MAKE_SEND, &authed); + mach_port_destroy (mach_task_self (), ref); + if (e.error) + return; + new = authed; + } + else + { + if (!consume && new != MACH_PORT_NULL) + mach_port_mod_refs (mach_task_self (), + new, MACH_PORT_RIGHT_SEND, 1); + } + + boot->portarray[idx] = new; + ports_replaced[idx] = 1; + } + + boot = alloc_recv (sizeof (*boot)); + if (boot == NULL) + { + e.error = ENOMEM; + goto out; + } + e.error = mach_port_insert_right (mach_task_self (), (mach_port_t) boot, + (mach_port_t) boot, + MACH_MSG_TYPE_MAKE_SEND); + if (e.error) + goto out; + e.error = task_set_bootstrap_port (newtask, (mach_port_t) boot); + mach_port_deallocate (mach_task_self (), (mach_port_t) boot); + if (e.error) + { + free (boot); + mach_port_destroy (mach_task_self (), (mach_port_t) boot); + goto out; + } + bzero (boot, sizeof *boot); + + /* First record some information about the image itself. */ + boot->phdr_addr = phdr_addr; + boot->phdr_size = phdr_size; + boot->user_entry = e.entry; + + /* These flags say the information we pass through to the new program + may need to be modified. */ + secure = (flags & EXEC_SECURE); + defaults = (flags & EXEC_DEFAULTS); + + /* Now record the big blocks of data we shuffle around unchanged. + Whatever arrived inline, we must allocate space for so it can + survive after this RPC returns. */ + + boot->flags = flags; + + e.error = servercopy ((void **) &argv, argvlen, argv_copy); + if (e.error) + goto bootout; + boot->argv = argv; + boot->argvlen = argvlen; + e.error = servercopy ((void **) &envp, envplen, envp_copy); + if (e.error) + goto bootout; + boot->envp = envp; + boot->envplen = envplen; + e.error = servercopy ((void **) &dtable, dtablesize * sizeof (mach_port_t), + dtable_copy); + if (e.error) + goto bootout; + boot->dtable = dtable; + boot->dtablesize = dtablesize; + + if ((secure || defaults) && nints < INIT_INT_MAX) + { + /* Make sure the intarray is at least big enough. */ + if (intarray_copy || (round_page (nints * sizeof (int)) < + round_page (INIT_INT_MAX * sizeof (int)))) + { + /* Allocate a new vector that is big enough. */ + vm_allocate (mach_task_self (), + (vm_address_t *) &boot->intarray, + INIT_INT_MAX * sizeof (int), + 1); + memcpy (boot->intarray, intarray, nints * sizeof (int)); + } + boot->nints = INIT_INT_MAX; + } + else + { + e.error = servercopy ((void **) &intarray, nints * sizeof (int), + intarray_copy); + if (e.error) + goto bootout; + boot->intarray = intarray; + boot->nints = nints; + } + + if (secure) + boot->intarray[INIT_UMASK] = std_ints ? std_ints[INIT_UMASK] : CMASK; + + /* Now choose the ports to give the new program. */ + + boot->nports = nports < INIT_PORT_MAX ? INIT_PORT_MAX : nports; + vm_allocate (mach_task_self (), + (vm_address_t *) &boot->portarray, + boot->nports * sizeof (mach_port_t), 1); + /* Start by copying the array as passed. */ + for (i = 0; i < nports; ++i) + boot->portarray[i] = portarray[i]; + if (MACH_PORT_NULL != 0) + for (; i < boot->nports; ++i) + boot->portarray[i] = MACH_PORT_NULL; + /* Keep track of which ports in BOOT->portarray come from the original + PORTARRAY, and which we replace. */ + ports_replaced = alloca (boot->nports * sizeof *ports_replaced); + bzero (ports_replaced, boot->nports * sizeof *ports_replaced); + + if (portarray[INIT_PORT_BOOTSTRAP] == MACH_PORT_NULL && + oldtask != MACH_PORT_NULL) + { + if (! task_get_bootstrap_port (oldtask, + &boot->portarray[INIT_PORT_BOOTSTRAP])) + ports_replaced[INIT_PORT_BOOTSTRAP] = 1; + } + + /* Note that the parentheses on this first test are different from the + others below it. */ + if ((secure || defaults) + && boot->portarray[INIT_PORT_AUTH] == MACH_PORT_NULL) + /* Q: Doesn't this let anyone run a program and make it + get a root auth port? + A: No; the standard port for INIT_PORT_AUTH has no UID's at all. + See init.trim/init.c (init_stdarrays). */ + use (INIT_PORT_AUTH, std_ports[INIT_PORT_AUTH], 0, 0); + if (secure || (defaults + && boot->portarray[INIT_PORT_PROC] == MACH_PORT_NULL)) + { + /* Ask the proc server for the proc port for this task. */ + mach_port_t new; + e.error = proc_task2proc (procserver, newtask, &new); + if (e.error) + goto bootout; + + use (INIT_PORT_PROC, new, 0, 1); + + /* XXX We should also call proc_setowner at this point. */ + } + else if (oldtask != newtask && oldtask != MACH_PORT_NULL + && boot->portarray[INIT_PORT_PROC] != MACH_PORT_NULL) + { + mach_port_t new; + /* This task port refers to the old task; use it to fetch a new + one for the new task. */ + e.error = proc_task2proc (boot->portarray[INIT_PORT_PROC], + newtask, &new); + if (e.error) + goto bootout; + use (INIT_PORT_PROC, new, 0, 1); + } + if (secure || (defaults + && boot->portarray[INIT_PORT_CRDIR] == MACH_PORT_NULL)) + use (INIT_PORT_CRDIR, std_ports[INIT_PORT_CRDIR], 1, 0); + if (secure || (defaults + && boot->portarray[INIT_PORT_CWDIR] == MACH_PORT_NULL)) + use (INIT_PORT_CWDIR, std_ports[INIT_PORT_CWDIR], 1, 0); + } + + + /* We have now concocted in BOOT the complete Hurd context (ports and + ints) that the new program image will run under. We will use these + ports for looking up the interpreter file if there is one. */ + if (! e.error && e.interp.section) { /* There is an interpreter section specifying another file to load @@ -1302,21 +1487,13 @@ do_exec (mach_port_t execserver, if (! name) e.interp.section = NULL; else - { - /* Open the named file using the appropriate directory ports for - the user. */ - inline mach_port_t user_port (unsigned int idx) - { - return (((flags & (EXEC_SECURE|EXEC_DEFAULTS)) || idx >= nports) - ? std_ports : portarray) - [idx]; - } - - e.error = hurd_file_name_lookup (user_port (INIT_PORT_CRDIR), - user_port (INIT_PORT_CWDIR), - name, O_READ, 0, &interp.file); - } + /* Open the named file using the appropriate directory ports for + the user. */ + e.error = hurd_file_name_lookup (boot->portarray[INIT_PORT_CRDIR], + boot->portarray[INIT_PORT_CWDIR], + name, O_READ, 0, &interp.file); } + if (interp.file != MACH_PORT_NULL) { /* We opened an interpreter file. Prepare it for loading too. */ @@ -1343,31 +1520,13 @@ do_exec (mach_port_t execserver, } if (e.error) - { - if (e.interp.section) - finish (&interp, 1); - finish (&e, 0); - return e.error; - } + goto bootout; - /* Suspend the existing task before frobnicating it. */ - if (oldtask != MACH_PORT_NULL && (e.error = task_suspend (oldtask))) - return e.error; - if (oldtask == MACH_PORT_NULL) - flags |= EXEC_NEWTASK; + /* We are now committed to the exec. It "should not fail". + If it does fail now, the task will be hopelessly munged. */ - if (flags & (EXEC_NEWTASK|EXEC_SECURE)) - { - /* Create the new task. If we are not being secure, then use OLDTASK - for the task_create RPC, in case it is something magical. */ - e.error = task_create ((flags & EXEC_SECURE) || !oldtask ? - mach_task_self () : oldtask, - 0, &newtask); - if (e.error) - goto out; - } - else + if (newtask == oldtask) { thread_array_t threads; mach_msg_type_number_t nthreads, i; @@ -1376,7 +1535,7 @@ do_exec (mach_port_t execserver, e.error = task_threads (oldtask, &threads, &nthreads); if (e.error) - goto out; + goto bootout; for (i = 0; i < nthreads; ++i) { thread_terminate (threads[i]); @@ -1399,10 +1558,8 @@ do_exec (mach_port_t execserver, for (i = 0; i < ndestroynames; ++i) mach_port_destroy (oldtask, destroynames[i]); - - newtask = oldtask; } - + /* XXX this should be below it is here to work around a vm_map kernel bug. */ if (interp.file != MACH_PORT_NULL) @@ -1412,7 +1569,7 @@ do_exec (mach_port_t execserver, if (interp.error) { e.error = interp.error; - goto out; + goto bootout; } finish (&interp, 1); } @@ -1421,7 +1578,7 @@ do_exec (mach_port_t execserver, /* Load the file into the task. */ load (newtask, &e); if (e.error) - goto out; + goto bootout; /* XXX loading of interp belongs here */ @@ -1431,175 +1588,7 @@ do_exec (mach_port_t execserver, /* Create the initial thread. */ e.error = thread_create (newtask, &thread); if (e.error) - goto out; - - /* Store the data that we will give in response - to the RPC on the new task's bootstrap port. */ - - boot = alloc_recv (sizeof (*boot)); - if (boot == NULL) - { - e.error = ENOMEM; - goto out; - } - - if (nports <= INIT_PORT_BOOTSTRAP) - { - mach_port_t *new; - vm_allocate (mach_task_self (), - (vm_address_t *) &new, - INIT_PORT_MAX * sizeof (mach_port_t), 1); - memcpy (new, portarray, nports * sizeof (mach_port_t)); - bzero (&new[nports], (INIT_PORT_MAX - nports) * sizeof (mach_port_t)); - } - if (portarray[INIT_PORT_BOOTSTRAP] == MACH_PORT_NULL && - oldtask != MACH_PORT_NULL) - task_get_bootstrap_port (oldtask, &portarray[INIT_PORT_BOOTSTRAP]); - - e.error = mach_port_insert_right (mach_task_self (), (mach_port_t) boot, - (mach_port_t) boot, - MACH_MSG_TYPE_MAKE_SEND); - if (e.error) - goto out; - e.error = task_set_bootstrap_port (newtask, (mach_port_t) boot); - if (e.error) - goto out; - mach_port_deallocate (mach_task_self (), (mach_port_t) boot); - -#ifdef XXX - boot->phdr_addr = phdr_addr; - boot->phdr_size = phdr_size; - boot->user_entry = e.entry; -#endif - - e.error = servercopy ((void **) &argv, argvlen, argv_copy); - if (e.error) - goto bootallocout; - boot->argv = argv; - boot->argvlen = argvlen; - e.error = servercopy ((void **) &envp, envplen, envp_copy); - if (e.error) - goto argvout; - boot->envp = envp; - boot->envplen = envplen; - e.error = servercopy ((void **) &dtable, dtablesize * sizeof (mach_port_t), - dtable_copy); - if (e.error) - goto envpout; - boot->dtable = dtable; - boot->dtablesize = dtablesize; - e.error = servercopy ((void **) &portarray, nports * sizeof (mach_port_t), - portarray_copy); - if (e.error) - goto portsout; - boot->portarray = portarray; - boot->nports = nports; - e.error = servercopy ((void **) &intarray, nints * sizeof (int), - intarray_copy); - if (e.error) - { - bootout: - vm_deallocate (mach_task_self (), - (vm_address_t) intarray, nints * sizeof (int)); - portsout: - vm_deallocate (mach_task_self (), - (vm_address_t) portarray, nports * sizeof (mach_port_t)); - envpout: - vm_deallocate (mach_task_self (), (vm_address_t) envp, envplen); - argvout: - vm_deallocate (mach_task_self (), (vm_address_t) argv, argvlen); - bootallocout: - free (boot); - mach_port_destroy (mach_task_self (), (mach_port_t) boot); - } - - boot->intarray = intarray; - boot->nints = nints; - boot->flags = flags; - - /* Adjust the information in BOOT for the secure and/or defaults flags. */ - - secure = (flags & EXEC_SECURE); - defaults = (flags & EXEC_DEFAULTS); - - if ((secure || defaults) && nports < INIT_PORT_MAX) - { - /* Allocate a new vector that is big enough. */ - vm_allocate (mach_task_self (), - (vm_address_t *) &boot->portarray, - INIT_PORT_MAX * sizeof (mach_port_t), - 1); - memcpy (boot->portarray, portarray, - nports * sizeof (mach_port_t)); - vm_deallocate (mach_task_self (), (vm_address_t) portarray, - nports * sizeof (mach_port_t)); - nports = INIT_PORT_MAX; - } - - /* Note that the parentheses on this first test are different from the - others below it. */ - if ((secure || defaults) - && boot->portarray[INIT_PORT_AUTH] == MACH_PORT_NULL) - /* Q: Doesn't this let anyone run a program and make it - get a root auth port? - A: No; the standard port for INIT_PORT_AUTH has no UID's at all. - See init.trim/init.c (init_stdarrays). */ - set_init_port (std_ports[INIT_PORT_AUTH], - &boot->portarray[INIT_PORT_AUTH], 0, 0); - if (secure || (defaults - && boot->portarray[INIT_PORT_PROC] == MACH_PORT_NULL)) - { - mach_port_t new; - e.error = proc_task2proc (procserver, newtask, &new); - if (e.error) - goto bootout; - - set_init_port (new, &boot->portarray[INIT_PORT_PROC], 0, 1); - - /* XXX We should also call proc_setowner at this point. */ - } - else if (oldtask != newtask && oldtask != MACH_PORT_NULL - && nports > INIT_PORT_PROC - && boot->portarray[INIT_PORT_PROC] != MACH_PORT_NULL) - { - mach_port_t new; - /* This task port refers to the old task; use it to fetch a new - one for the new task. */ - e.error = proc_task2proc (boot->portarray[INIT_PORT_PROC], - newtask, &new); - if (e.error) - goto bootout; - set_init_port (new, &boot->portarray[INIT_PORT_PROC], 0, 1); - } - if (secure || (defaults - && boot->portarray[INIT_PORT_CRDIR] == MACH_PORT_NULL)) - set_init_port (std_ports[INIT_PORT_CRDIR], - &boot->portarray[INIT_PORT_CRDIR], - boot->portarray[INIT_PORT_AUTH], 0); - if (secure || (defaults && - boot->portarray[INIT_PORT_CWDIR] == MACH_PORT_NULL)) - set_init_port (std_ports[INIT_PORT_CWDIR], - &boot->portarray[INIT_PORT_CWDIR], - boot->portarray[INIT_PORT_AUTH], 0); - - if ((secure || defaults) && nints < INIT_INT_MAX) - { - /* Allocate a new vector that is big enough. */ - vm_allocate (mach_task_self (), - (vm_address_t *) &boot->intarray, - INIT_INT_MAX * sizeof (int), - 1); - memcpy (boot->intarray, intarray, nints * sizeof (int)); - vm_deallocate (mach_task_self (), (vm_address_t) intarray, - nints * sizeof (int)); - nints = INIT_INT_MAX; - } - - if (secure) - boot->intarray[INIT_UMASK] = std_ints ? std_ints[INIT_UMASK] : CMASK; - - if (nports > INIT_PORT_PROC) - proc_mark_exec (boot->portarray[INIT_PORT_PROC]); + goto bootout; /* Start up the initial thread at the entry point. */ boot->stack_base = 0, boot->stack_size = 0; /* Don't care about values. */ @@ -1620,8 +1609,8 @@ do_exec (mach_port_t execserver, When not secure, it is nice to let processes associate with whatever proc server turns them on, regardless of which exec itself is using. */ - if ((flags & EXEC_SECURE) - || nports <= INIT_PORT_PROC + if (secure + || boot->nports <= INIT_PORT_PROC || boot->portarray[INIT_PORT_PROC] == MACH_PORT_NULL) psrv = procserver; else @@ -1634,9 +1623,9 @@ do_exec (mach_port_t execserver, proc_reassign (proc, newtask); mach_port_deallocate (mach_task_self (), proc); } - } - newtask = MACH_PORT_NULL; + mach_port_deallocate (mach_task_self (), oldtask); + } /* Request no-senders notification on BOOT, so we can release its resources if the task dies before calling exec_startup. */ @@ -1654,27 +1643,102 @@ do_exec (mach_port_t execserver, mach_port_move_member (mach_task_self (), (mach_port_t) boot, request_portset); - - out: - if (newtask != MACH_PORT_NULL) + if (e.error) { - task_terminate (newtask); - mach_port_deallocate (mach_task_self (), newtask); + /* We barfed somewhere along the way. Deallocate any local data + copies we just made. */ + bootout: + mach_port_destroy (mach_task_self (), (mach_port_t) boot); + if (intarray_copy) + vm_deallocate (mach_task_self (), + (vm_address_t) boot->intarray, + boot->nints * sizeof (int)); + if (dtable_copy) + vm_deallocate (mach_task_self (), + (vm_address_t) boot->dtable, + boot->dtablesize * sizeof (mach_port_t)); + if (envp_copy) + vm_deallocate (mach_task_self (), + (vm_address_t) boot->envp, boot->envplen); + if (argv_copy) + vm_deallocate (mach_task_self (), + (vm_address_t) boot->argv, boot->argvlen); + if (boot->portarray) + { + for (i = 0; i < boot->nports; ++i) + if (ports_replaced[i] && boot->portarray[i] != MACH_PORT_NULL) + /* This port was replaced, so we created reference anew and + we must deallocate it. (The references that arrived in + the original portarray will be deallocated by MiG on + failure return.) */ + mach_port_deallocate (mach_task_self (), boot->portarray[i]); + vm_deallocate (mach_task_self (), + (vm_address_t) boot->portarray, + boot->nports * sizeof (mach_port_t)); + } + free (boot); } + + out: if (e.interp.section) finish (&interp, 1); finish (&e, !e.error); - if (oldtask != newtask) - task_resume (oldtask); if (thread != MACH_PORT_NULL) { thread_resume (thread); mach_port_deallocate (mach_task_self (), thread); } - if (! e.error) - mach_port_deallocate (mach_task_self (), oldtask); + if (e.error) + { + if (oldtask != newtask) + { + /* We created a new task but failed to set it up. Kill it. */ + task_terminate (newtask); + mach_port_deallocate (mach_task_self (), newtask); + } + /* Resume the old task, which we suspended earlier. */ + task_resume (oldtask); + } + else + { + if (oldtask != newtask) + { + /* We successfully set the new task up. + Terminate the old task and deallocate our right to it. */ + task_terminate (oldtask); + mach_port_deallocate (mach_task_self (), oldtask); + } + else + /* Resume the task, it is ready to run the new program. */ + task_resume (oldtask); + /* Deallocate the right to the new task we created. */ + mach_port_deallocate (mach_task_self (), newtask); + + if (boot->nports > INIT_PORT_PROC) + proc_mark_exec (boot->portarray[INIT_PORT_PROC]); + + for (i = 0; i < nports; ++i) + if (ports_replaced[i] && portarray[i] != MACH_PORT_NULL) + /* This port was replaced, so the reference that arrived in the + original portarray is not being saved in BOOT for transfer to + the user task. Deallocate it; we don't want it, and MiG will + leave it for us on successful return. */ + mach_port_deallocate (mach_task_self (), portarray[i]); + + /* If there is vm_allocate'd space for the original intarray and/or + portarray, and we are not saving those pointers in BOOT for later + transfer, deallocate the original space now. */ + if (!intarray_copy && boot->intarray != intarray) + vm_deallocate (mach_task_self (), + (vm_address_t) intarray, + nints * sizeof intarray[0]); + if (!portarray_copy && boot->portarray != portarray) + vm_deallocate (mach_task_self (), + (vm_address_t) portarray, + nports * sizeof portarray[0]); + } return e.error; } |