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); }