kern_return_t
S_exec_init (struct trivfs_protid *protid,
auth_t auth, process_t proc)
{
mach_port_t host_priv, startup;
error_t err;
if (! protid || ! protid->isroot)
return EPERM;
_hurd_port_set (&_hurd_ports[INIT_PORT_PROC], proc); /* Consume. */
_hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], auth); /* Consume. */
/* Do initial setup with the proc server. */
_hurd_proc_init (save_argv, NULL, 0);
procserver = getproc ();
/* Have the proc server notify us when the canonical ints and ports
change. This will generate an immediate callback giving us the
initial boot-time canonical sets. */
{
struct iouser *user;
struct trivfs_protid *cred;
mach_port_t right;
err = iohelp_create_empty_iouser (&user);
assert_perror (err);
err = trivfs_open (fsys, user, 0, MACH_PORT_NULL, &cred);
assert_perror (err);
right = ports_get_send_right (cred);
proc_execdata_notify (procserver, right, MACH_MSG_TYPE_COPY_SEND);
mach_port_deallocate (mach_task_self (), right);
}
err = get_privileged_ports (&host_priv, NULL);
assert_perror (err);
proc_register_version (procserver, host_priv, "exec", "", HURD_VERSION);
err = proc_getmsgport (procserver, 1, &startup);
assert_perror (err);
mach_port_deallocate (mach_task_self (), procserver);
/* Call startup_essential task last; init assumes we are ready to
run once we call it. */
err = startup_essential_task (startup, mach_task_self (), MACH_PORT_NULL,
"exec", host_priv);
assert_perror (err);
mach_port_deallocate (mach_task_self (), startup);
mach_port_deallocate (mach_task_self (), host_priv);
return 0;
}
int
main (int argc, char **argv, char **envp)
{
mach_port_t boot;
error_t err;
void *genport;
process_t startup_port;
mach_port_t startup;
struct argp argp = { 0, 0, 0, "Hurd process server" };
argp_parse (&argp, argc, argv, 0, 0, 0);
initialize_version_info ();
err = task_get_bootstrap_port (mach_task_self (), &boot);
assert_perror (err);
if (boot == MACH_PORT_NULL)
error (2, 0, "proc server can only be run by init during boot");
proc_bucket = ports_create_bucket ();
proc_class = ports_create_class (0, 0);
generic_port_class = ports_create_class (0, 0);
exc_class = ports_create_class (exc_clean, 0);
ports_create_port (generic_port_class, proc_bucket,
sizeof (struct port_info), &genport);
generic_port = ports_get_right (genport);
/* Create the initial proc object for init (PID 1). */
init_proc = create_init_proc ();
/* Create the startup proc object for /hurd/init (PID 2). */
startup_proc = allocate_proc (MACH_PORT_NULL);
startup_proc->p_deadmsg = 1;
complete_proc (startup_proc, HURD_PID_STARTUP);
/* Create our own proc object. */
self_proc = allocate_proc (mach_task_self ());
assert (self_proc);
complete_proc (self_proc, HURD_PID_PROC);
startup_port = ports_get_send_right (startup_proc);
err = startup_procinit (boot, startup_port, &startup_proc->p_task,
&authserver, &_hurd_host_priv, &_hurd_device_master);
assert_perror (err);
mach_port_deallocate (mach_task_self (), startup_port);
mach_port_mod_refs (mach_task_self (), authserver, MACH_PORT_RIGHT_SEND, 1);
_hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], authserver);
mach_port_deallocate (mach_task_self (), boot);
proc_death_notify (startup_proc);
add_proc_to_hash (startup_proc); /* Now that we have the task port. */
/* Set our own argv and envp locations. */
self_proc->p_argv = (vm_address_t) argv;
self_proc->p_envp = (vm_address_t) envp;
/* Give ourselves good scheduling performance, because we are so
important. */
err = increase_priority ();
if (err)
error (0, err, "Increasing priority failed");
#if 0
err = register_new_task_notification (_hurd_host_priv,
generic_port,
MACH_MSG_TYPE_MAKE_SEND);
if (err)
error (0, err, "Registering task notifications failed");
#endif
{
/* Get our stderr set up to print on the console, in case we have
to panic or something. */
mach_port_t cons;
error_t err;
err = device_open (_hurd_device_master, D_READ|D_WRITE, "console", &cons);
assert_perror (err);
stdin = mach_open_devstream (cons, "r");
stdout = stderr = mach_open_devstream (cons, "w");
mach_port_deallocate (mach_task_self (), cons);
}
startup = file_name_lookup (_SERVERS_STARTUP, 0, 0);
if (MACH_PORT_VALID (startup))
{
err = startup_essential_task (startup, mach_task_self (),
MACH_PORT_NULL, "proc", _hurd_host_priv);
if (err)
/* Due to the single-threaded nature of /hurd/startup, it can
only handle requests once the core server bootstrap has
completed. Therefore, it does not bind itself to
/servers/startup until it is ready. */
/* Fall back to abusing the message port lookup. */
startup_fallback = 1;
err = mach_port_deallocate (mach_task_self (), startup);
assert_perror (err);
}
else
/* Fall back to abusing the message port lookup. */
startup_fallback = 1;
while (1)
ports_manage_port_operations_multithread (proc_bucket,
message_demuxer,
0, 0, 0);
}
