int smtrdns_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to various threads */
# include "smtrdns.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from socket agent */
declare_smtsock_ok (ok_event, 0);
declare_smtsock_connect_ok (ok_event, 0);
declare_smtsock_closed (sock_closed_event, 0);
declare_smtsock_error (sock_error_event, 0);
declare_smtsock_timeout (sock_timeout_event, 0);
/* Public methods supported by this agent */
declare_smtrdns_get_host_name (get_host_event, 0);
declare_smtrdns_get_host_ip (get_ip_event, 0);
/* Reply events from timer agent */
declare_smttime_reply (timer_event, SMT_PRIORITY_LOW);
/* Private methods used to pass initial thread events */
method_declare (agent, "_MASTER", master_event, 0);
method_declare (agent, "_CLIENT", client_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
if (smttime_init ())
return (-1);
/* Create initial thread to manage master port */
if ((thread = thread_create (AGENT_NAME, "")) != NULL)
{
SEND (&thread-> queue-> qid, "_MASTER", "");
((TCB *) thread-> tcb)-> thread_type = master_event;
}
else
return (-1);
/* Signal okay to caller that we initialised okay */
return (0);
}
int
xiddns_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to console thread */
# include "xiddns.i" /* Include dialog interpreter */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
method_declare (agent, "SHUTDOWN", shutdown_event, SMT_PRIORITY_MAX);
/* Public methods supported by this agent */
method_declare (agent, "SIGNON", signon_event, 0);
method_declare (agent, "SIGNOFF", signoff_event, 0);
/* Reply events from socket agent */
method_declare (agent, "SOCK_INPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_OUTPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_READ_OK", ok_event, 0);
method_declare (agent, "SOCK_WRITE_OK", ok_event, 0);
method_declare (agent, "SOCK_CLOSED", ok_event, 0);
method_declare (agent, "SOCK_ERROR", sock_error_event, 0);
method_declare (agent, "SOCK_TIMEOUT", sock_timeout_event, 0);
/* Reply events from timer agent */
method_declare (agent, "TIME_ALARM", signon_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
smttime_init ();
if ((thread = thread_lookup (SMT_TIMER, "")) != NULL)
timeq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Create single master thread */
thread_create (AGENT_NAME, "main");
/* Signal okay to caller that we initialised okay */
return (0);
}
int
sysclia_init (char *p_command, char *p_port)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to console thread */
# include "sysclia.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from socket agent */
declare_smtsock_ok (ok_event, 0);
declare_smtsock_read_ok (ok_event, 0);
declare_smtsock_connect_ok (ok_event, 0);
declare_smtsock_closed (sock_closed_event, 0);
declare_smtsock_error (sock_error_event, 0);
declare_smtsock_timeout (sock_error_event, 0);
/* Reply events from transfer agent */
declare_smttran_get_block (ok_event, 0);
declare_smttran_put_block (SMT_NULL_EVENT, 0);
declare_smttran_putb_ok (SMT_NULL_EVENT, 0);
declare_smttran_getb_ok (ok_event, 0);
declare_smttran_closed (sock_closed_event, 0);
declare_smttran_error (sock_error_event, 0);
/* Create initial, unnamed thread */
thread_create (AGENT_NAME, "");
/* Ensure that socket agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Ensure that transfer agent is running, else start it up */
smttran_init ();
if ((thread = thread_lookup (SMT_TRANSFER, "")) != NULL)
tranq = thread-> queue-> qid;
else
return (-1);
/* Signal okay to caller that we initialised okay */
command = p_command; /* Get command from user */
port = p_port; /* Get port to connect to */
return (0);
}
int smttst1_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to console thread */
# include "smttst1.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Alarm event sent by kernel to this agent */
declare_smttime_reply (alarm_event, 0);
declare_smttime_error (error_event, 0);
/* Create initial thread - all threads are unnamed */
thread_create (AGENT_NAME, "");
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
console = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer is running, else start it up */
if (smttime_init ())
return (-1);
/* Signal okay to caller that we initialised okay */
return (0);
}
MODULE search_thread_for_request (THREAD *thread)
{
char
*thread_name = NULL;
tcb = thread-> tcb; /* Point to thread's context */
if (tcb-> main_req_type == REQ_TYPE_HOST)
thread_name = tcb-> ip_value;
else
thread_name = tcb-> host_name;
if (thread_name == NULL)
{
the_next_event = not_found_event;
return;
}
if ((client_thread = thread_lookup (AGENT_NAME, thread_name)) != NULL)
{
if (((TCB *)client_thread-> tcb)-> send_responce == FALSE)
the_next_event = found_event;
else
the_next_event = not_found_event;
}
else
the_next_event = not_found_event;
}
int
smtupmc_init (char *p_args, char *p_portname)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to console thread */
# include "smtupmc.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
method_declare (agent, "SHUTDOWN", shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from socket agent */
method_declare (agent, "SOCK_INPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_OUTPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_READ_OK", ok_event, 0);
method_declare (agent, "SOCK_WRITE_OK", ok_event, 0);
method_declare (agent, "SOCK_CLOSED", sock_closed_event, 0);
method_declare (agent, "SOCK_ERROR", sock_error_event, 0);
method_declare (agent, "SOCK_TIMEOUT", sock_error_event, 0);
/* Reply events from transfer agent */
method_declare (agent, "TRAN_GETF_OK", ok_event, 0);
method_declare (agent, "TRAN_PUTF_OK", SMT_NULL_EVENT, 0);
method_declare (agent, "TRAN_CLOSED", sock_closed_event, 0);
method_declare (agent, "TRAN_ERROR", sock_error_event, 0);
/* Create initial, unnamed thread */
thread_create (AGENT_NAME, "");
/* Ensure that socket agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Ensure that transfer agent is running, else start it up */
smttran_init ();
if ((thread = thread_lookup (SMT_TRANSFER, "")) != NULL)
tranq = thread-> queue-> qid;
else
return (-1);
/* Signal okay to caller that we initialised okay */
args = p_args; /* Get command-line arguments */
portname = p_portname;
return (0);
}
int smttst3_init (int argc, char *argv [])
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to various threads */
# include "smttst3.i" /* Include dialog interpreter */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
method_declare (agent, "SHUTDOWN", shutdown_event,
SMT_PRIORITY_MAX);
/* Reply events from reverse DNS agent */
method_declare (agent, "HOST_NAME", host_event, 0);
method_declare (agent, "HOST_IP", ip_event, 0);
method_declare (agent, "HOST_ERROR", error_event, 0);
method_declare (agent, "HOST_END", end_event, 0);
method_declare (agent, "HOST_TIMEOUT", timeout_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtrdns_init ();
if ((thread = thread_lookup ("smtrdns", "main")) != NULL)
rdnsq = thread-> queue-> qid;
else
return (-1);
/* Create initial, unnamed thread */
if ((thread = thread_create (AGENT_NAME, "")) != NULL)
{
((TCB *) thread-> tcb)-> argc = argc;
((TCB *) thread-> tcb)-> argv = argv;
}
/* Signal okay to caller that we initialised okay */
return (0);
}
int smtsmtp_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread;
# include "smtsmtp.i" /* Include dialog interpreter */
/* Change any of the agent properties that you need to */
agent-> router = FALSE; /* FALSE = default */
agent-> max_threads = 0; /* 0 = default */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Public methods supported by this agent */
declare_smtsmtp_send_message (send_mail_event, 0);
declare_smtsmtp_open_message (open_mail_event, 0);
declare_smtsmtp_message_chunk (mail_chunk_event, 0);
declare_smtsmtp_close_message (close_mail_event, 0);
/* Reply events from socket agent */
declare_smtsock_connect_ok (sock_connect_ok_event, SMT_PRIORITY_HIGH);
declare_smtsock_read_ok (sock_read_ok_event, SMT_PRIORITY_HIGH);
declare_smtsock_closed (sock_closed_event, SMT_PRIORITY_HIGH);
declare_smtsock_read_closed (sock_read_closed_event, SMT_PRIORITY_HIGH);
declare_smtsock_timeout (sock_timeout_event, SMT_PRIORITY_HIGH);
declare_smtsock_error (sock_error_event, SMT_PRIORITY_HIGH);
declare_smtsock_read_timeout (sock_timeout_event, SMT_PRIORITY_HIGH);
declare_smtsock_ok (sock_ok_event, SMT_PRIORITY_HIGH);
/* Ensure that socket i/o agent is running, else start it up */
if (agent_lookup (SMT_SOCKET) == NULL)
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Create master thread */
if ((thread = thread_create (AGENT_NAME, "master")) != NULL)
{
tcb = thread-> tcb;
clear_context (tcb);
tcb-> thread_type = master_event;
}
else
return (-1);
/* We need random number to generate message boundaries */
randomize ();
/* Signal okay to caller that we initialised okay */
return (0);
}
int smttst3_init (int argc, char *argv [])
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to various threads */
# include "smttst3.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from reverse DNS agent */
declare_smtrdns_host_name (host_event, 0);
declare_smtrdns_host_ip (ip_event, 0);
declare_smtrdns_host_error (error_event, 0);
declare_smtrdns_host_end (end_event, 0);
declare_smtrdns_host_timeout (timeout_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtrdns_init ();
if ((thread = thread_lookup ("smtrdns", "main")) != NULL)
rdnsq = thread-> queue-> qid;
else
return (-1);
/* Create initial, unnamed thread */
if ((thread = thread_create (AGENT_NAME, "")) != NULL)
{
((TCB *) thread-> tcb)-> argc = argc;
((TCB *) thread-> tcb)-> argv = argv;
}
/* Signal okay to caller that we initialised okay */
return (0);
}
int
smtpipe_init (char *p_filename)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle for initial thread */
# include "smtpipe.i" /* Include dialog interpreter */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from timer agent */
declare_smttime_reply (timer_event, SMT_PRIORITY_LOW);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that transfer agent is running, else start it up */
smttran_init ();
if ((thread = thread_lookup (SMT_TRANSFER, "")) != NULL)
tranq = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
if (smttime_init ())
return (-1);
/* Create initial, unnamed thread */
thread = thread_create (AGENT_NAME, "");
filename = p_filename; /* Get name of pipe definition */
/* Signal okay to caller that we initialised okay */
return (0);
}
struct process *
process_lookup(cookie_t pid)
{
struct thread *td;
struct process *p;
td = thread_lookup(pid);
if (td == NULL)
return (NULL);
p = td->td_process;
if (p->p_id != pid)
return (NULL);
return (p);
}
MODULE initialise_the_thread (THREAD *thread)
{
THREAD
*http_thread;
the_next_event = ok_event;
/* Just as an example, we'll define a dynamic WSX alias */
/* Find 'main' thread in SMTHTTP agent */
http_thread = thread_lookup (SMT_HTTP, "main");
ASSERT (http_thread);
send_wsx_install (&http_thread-> queue-> qid,
NULL, "error-test", AGENT_NAME);
}
int tstsmtp_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to console thread */
# include "tstsmtp.i" /* Include dialog interpreter */
/* Change any of the agent properties that you need to */
agent-> router = FALSE; /* FALSE = default */
agent-> max_threads = 0; /* 0 = default */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
declare_smtlib_shutdown (shutdown_event, SMT_PRIORITY_MAX);
/* Public methods supported by this agent */
declare_smtsmtp_ok (ok_event, 0);
declare_smtsmtp_error (error_event, 0);
/* Ensure that smtp is running, else start it up */
if (agent_lookup (SMT_SMTP) == NULL)
smtsmtp_init ();
if ((thread = thread_lookup (SMT_SMTP, "")) != NULL)
smtp = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
smttime_init ();
if ((thread = thread_lookup (SMT_TIMER, "")) != NULL)
timer = thread-> queue-> qid;
else
return (-1);
/* Signal okay to caller that we initialised okay */
return (0);
}
MODULE use_specified_log_queue (THREAD *thread)
{
THREAD
*log_thread;
struct_smtoper_set_log
*request;
/* Look for logging thread with specified name; if found, take that
thread's queue and save it. All messages will now go there... */
get_smtoper_set_log (thread-> event-> body, &request);
log_thread = thread_lookup (request-> agent_name, request-> thread_name);
if (log_thread)
logq = log_thread-> queue-> qid;
free_smtoper_set_log (&request);
}
static int
start_socket_agent (void)
{
THREAD
*thread;
if (! sockq)
{
if (agent_lookup (SMT_SOCKET) == NULL)
smtsock_init ();
if ( (thread = thread_lookup (SMT_SOCKET, "")) != NULL )
sockq = thread-> queue;
else
{
strcpy (object_error, "Unable to start SOCK agent.");
return -1;
}
}
return 0;
}
MODULE initialise_the_thread (THREAD *thread)
{
THREAD
*http_thread;
SYMBOL
*symbol; /* Next symbol in table */
the_next_event = ok_event;
/* Install all redirections as WSX aliases */
/* For now we do not handle distinguish virtual hosts */
http_thread = thread_lookup (SMT_HTTP, "main");
if (http_thread) {
for (symbol = config-> symbols; symbol; symbol = symbol-> next)
if (strprefixed (symbol-> name, "redirect:")) {
send_wsx_install (
&http_thread-> queue-> qid,
NULL, /* All virtual hosts */
symbol-> name + strlen ("redirect:"),
AGENT_NAME);
}
}
}
MODULE send_event_to_child_thread (THREAD *thread)
{
long
id;
THREAD
*child; /* Handle to child thread */
static char
child_name [20];
tcb = thread-> tcb; /* Point to thread's context */
exdr_read (thread-> event-> body, "q", &id);
sprintf (child_name, "%ld", id);
child = thread_lookup (AGENT_NAME, child_name);
if (child)
event_send (
&child-> queue-> qid, /* Send to specified queue */
&tcb-> reply_to, /* Queue for reply */
thread-> event-> name, /* Name of event to send */
thread-> event-> body, /* Event body and size */
thread-> event-> body_size,
NULL, NULL, NULL, /* No response events */
0); /* No timeout */
}
int smtftpd_init (void)
{
AGENT
*agent; /* Handle for our agent */
THREAD
*thread; /* Handle to various threads */
# include "smtftpd.i" /* Include dialog interpreter */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
method_declare (agent, "SHUTDOWN", shutdown_event, SMT_PRIORITY_MAX);
/* Reply events from socket agent */
method_declare (agent, "SOCK_INPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_OUTPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_READ_OK", ok_event, 0);
method_declare (agent, "SOCK_WRITE_OK", ok_event, 0);
method_declare (agent, "SOCK_CLOSED", sock_closed_event, 0);
method_declare (agent, "SOCK_ERROR", sock_error_event, 0);
method_declare (agent, "SOCK_TIMEOUT", sock_timeout_event, 0);
/* Reply events from transfer agent */
method_declare (agent, "TRAN_PUTF_OK", finished_event,
SMT_PRIORITY_HIGH);
method_declare (agent, "TRAN_GETF_OK", finished_event,
SMT_PRIORITY_HIGH);
method_declare (agent, "TRAN_CLOSED", sock_closed_event,
SMT_PRIORITY_HIGH);
method_declare (agent, "TRAN_ERROR", sock_error_event,
SMT_PRIORITY_HIGH);
/* Public methods supported by this agent */
method_declare (agent, "FTPD_PASSIVE", passive_event,
SMT_PRIORITY_LOW);
method_declare (agent, "FTPD_PUT_FILE", put_file_event,
SMT_PRIORITY_NORMAL);
method_declare (agent, "FTPD_GET_FILE", get_file_event,
SMT_PRIORITY_NORMAL);
method_declare (agent, "FTPD_APPEND_FILE", append_file_event,
SMT_PRIORITY_NORMAL);
method_declare (agent, "FTPD_ABORT", abort_event,
SMT_PRIORITY_HIGH);
method_declare (agent, "FTPD_CLOSECTRL", close_control_event,
SMT_PRIORITY_HIGH);
/* Private method used to pass initial thread events */
method_declare (agent, "_MASTER", master_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
smttime_init ();
if ((thread = thread_lookup (SMT_TIMER, "")) != NULL)
timeq = thread-> queue-> qid;
else
return (-1);
/* Ensure that transfer agent is running, else start it up */
smttran_init ();
if ((thread = thread_lookup (SMT_TRANSFER, "")) != NULL)
tranq = thread-> queue-> qid;
else
return (-1);
/* Create initial thread to manage master port */
if ((thread = thread_create (AGENT_NAME, "")) != NULL)
{
SEND (&thread-> queue-> qid, "_MASTER", "");
((TCB *) thread-> tcb)-> thread_type = master_event;
}
else
return (-1);
pasv_port = sym_create_table ();
/* Signal okay to caller that we initialised okay */
return (0);
}
static pthread_t create_uinit_main(void * stack_addr)
{
struct _sched_pthread_create_args init_ds = {
.param.sched_policy = SCHED_OTHER,
.param.sched_priority = NZERO,
.stack_addr = stack_addr,
.stack_size = configUSRINIT_SSIZE,
.flags = 0,
.start = uinit, /* We have to first get into user space to use exec
* and mount the rootfs.
*/
.arg1 = (uintptr_t)rootfs,
.del_thread = (void (*)(void *))uinit_exit,
};
return thread_create(&init_ds, THREAD_MODE_PRIV);
}
/**
* Map vmstack to proc.
*/
static void map_vmstack2proc(struct proc_info * proc, struct buf * vmstack)
{
struct vm_pt * vpt;
(*proc->mm.regions)[MM_STACK_REGION] = vmstack;
vm_updateusr_ap(vmstack);
vpt = ptlist_get_pt(&proc->mm, vmstack->b_mmu.vaddr,
MMU_PGSIZE_COARSE, VM_PT_CREAT);
if (vpt == 0)
panic("Couldn't get vpt for init stack");
vmstack->b_mmu.pt = &(vpt->pt);
vm_map_region(vmstack, vpt);
}
/**
* Create init process.
*/
int __kinit__ kinit(void)
{
SUBSYS_DEP(sched_init);
SUBSYS_DEP(proc_init);
SUBSYS_DEP(ramfs_init);
SUBSYS_DEP(sysctl_init);
SUBSYS_INIT("kinit");
char strbuf[80]; /* Buffer for panic messages. */
struct buf * init_vmstack;
pthread_t tid;
pid_t pid;
struct thread_info * init_thread;
struct proc_info * init_proc;
/*
* FIXME Memory allocation, protection or manipulation bug!
* There is a critical bug causing random crashes in userland. I suspect
* something is overwriting user space allocation from the kernel space.
* Allocating some memory before init is executed seems to fix this issue,
* however naturally this is not the proper way to fix the bug.
* Without the allocation here the issue is sometimes seen in init or
* usually after couple of fork + exec + exit cycles. The usual symptom is
* that the userland app first calls some 0:0 syscalls and then tries to
* execute undefined instruction, which probably means that either some
* jump table in the heap or some part of the executable code is modified
* by a bad access in kernel mode just before this happens.
*/
(void)geteblk(MMU_PGSIZE_COARSE * 10);
mount_tmp_rootfs();
/*
* User stack for init
*/
init_vmstack = create_vmstack();
if (!init_vmstack)
panic("Can't allocate a stack for init");
/*
* Create a thread for init
*/
tid = create_uinit_main((void *)(init_vmstack->b_mmu.paddr));
if (tid < 0) {
ksprintf(strbuf, sizeof(strbuf), "Can't create a thread for init. %i",
tid);
panic(strbuf);
}
/*
* pid of init
*/
pid = proc_fork();
if (pid <= 0) {
ksprintf(strbuf, sizeof(strbuf), "Can't fork a process for init. %i",
pid);
panic(strbuf);
}
init_thread = thread_lookup(tid);
if (!init_thread) {
panic("Can't get thread descriptor of init_thread!");
}
init_proc = proc_ref(pid);
if (!init_proc || (init_proc->state == PROC_STATE_INITIAL)) {
panic("Failed to get proc struct or invalid struct");
}
init_thread->pid_owner = pid;
init_thread->curr_mpt = &init_proc->mm.mpt;
/*
* Map the previously created user stack with init process page table.
*/
map_vmstack2proc(init_proc, init_vmstack);
/*
* Map tkstack of init with vm_pagetable_system.
*/
mmu_map_region(&init_thread->kstack_region->b_mmu);
init_proc->main_thread = init_thread;
KERROR_DBG("Init created with pid: %u, tid: %u, stack: %p\n",
pid, tid, (void *)init_vmstack->b_mmu.vaddr);
proc_unref(init_proc);
return 0;
}
int smtrdns_init (void)
{
AGENT *agent; /* Handle for our agent */
THREAD *thread; /* Handle to various threads */
# include "smtrdns.i" /* Include dialog interpreter */
/* Method name Event value Priority */
/* Shutdown event comes from Kernel */
method_declare (agent, "SHUTDOWN", shutdown_event,
SMT_PRIORITY_MAX);
/* Reply events from socket agent */
method_declare (agent, "SOCK_INPUT_OK", input_ok_event, 0);
method_declare (agent, "SOCK_OUTPUT_OK", ok_event, 0);
method_declare (agent, "SOCK_READ_OK", ok_event, 0);
method_declare (agent, "SOCK_WRITE_OK", ok_event, 0);
method_declare (agent, "SOCK_CLOSED", sock_closed_event, 0);
method_declare (agent, "SOCK_ERROR", sock_error_event, 0);
method_declare (agent, "SOCK_TIMEOUT", sock_timeout_event, 0);
/* Public methods supported by this agent */
method_declare (agent, "GET_HOST_NAME", get_host_event, 0);
method_declare (agent, "GET_HOST_IP", get_ip_event, 0);
/* Reply events from timer agent */
method_declare (agent, "TIME_ALARM", timer_event, SMT_PRIORITY_LOW);
/* Private methods used to pass initial thread events */
method_declare (agent, "_MASTER", master_event, 0);
method_declare (agent, "_CLIENT", client_event, 0);
/* Ensure that operator console is running, else start it up */
smtoper_init ();
if ((thread = thread_lookup (SMT_OPERATOR, "")) != NULL)
operq = thread-> queue-> qid;
else
return (-1);
/* Ensure that socket i/o agent is running, else start it up */
smtsock_init ();
if ((thread = thread_lookup (SMT_SOCKET, "")) != NULL)
sockq = thread-> queue-> qid;
else
return (-1);
/* Ensure that timer agent is running, else start it up */
smttime_init ();
if ((thread = thread_lookup (SMT_TIMER, "")) != NULL)
timeq = thread-> queue-> qid;
else
return (-1);
/* Create initial thread to manage master port */
if ((thread = thread_create (AGENT_NAME, "")) != NULL)
{
SEND (&thread-> queue-> qid, "_MASTER", "");
((TCB *) thread-> tcb)-> thread_type = master_event;
}
else
return (-1);
/* Signal okay to caller that we initialised okay */
return (0);
}
