227 lines
7.7 KiB
C
227 lines
7.7 KiB
C
/* This file contains the main program of the process manager and some related
|
|
* procedures. When MINIX starts up, the kernel runs for a little while,
|
|
* initializing itself and its tasks, and then it runs PM and FS. Both PM
|
|
* and FS initialize themselves as far as they can. FS then makes a call to
|
|
* PM, because PM has to wait for FS to acquire a RAM disk. PM asks the
|
|
* kernel for all free memory and starts serving requests.
|
|
*
|
|
* The entry points into this file are:
|
|
* main: starts PM running
|
|
* setreply: set the reply to be sent to process making an PM system call
|
|
*/
|
|
|
|
#include "pm.h"
|
|
#include <minix/utils.h>
|
|
#include <minix/keymap.h>
|
|
#include <minix/callnr.h>
|
|
#include <minix/com.h>
|
|
#include <signal.h>
|
|
#include <fcntl.h>
|
|
#include <sys/ioc_memory.h>
|
|
#include <string.h>
|
|
#include "mproc.h"
|
|
#include "param.h"
|
|
|
|
#include "../../kernel/type.h"
|
|
|
|
FORWARD _PROTOTYPE( void get_work, (void) );
|
|
FORWARD _PROTOTYPE( void pm_init, (void) );
|
|
|
|
#define click_to_round_k(n) \
|
|
((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
|
|
|
|
/*===========================================================================*
|
|
* main *
|
|
*===========================================================================*/
|
|
PUBLIC void main()
|
|
{
|
|
/* Main routine of the process manager. */
|
|
|
|
int result, s, proc_nr;
|
|
struct mproc *rmp;
|
|
|
|
pm_init(); /* initialize process manager tables */
|
|
|
|
/* This is PM's main loop- get work and do it, forever and forever. */
|
|
while (TRUE) {
|
|
get_work(); /* wait for an PM system call */
|
|
|
|
/* Check for system notifications first. Special cases. */
|
|
if (call_nr == HARD_STOP) { /* MINIX is shutting down */
|
|
check_sig(-1, SIGKILL); /* kill all processes */
|
|
sys_exit(0);
|
|
/* never reached */
|
|
} else if (call_nr == FKEY_PRESSED) { /* create debug dump */
|
|
(void) do_fkey_pressed();
|
|
result = SUSPEND; /* don't reply */
|
|
} else if (call_nr == KSIG_PENDING) { /* signals pending */
|
|
(void) ksig_pending();
|
|
result = SUSPEND; /* don't reply */
|
|
}
|
|
/* Else, if the system call number is valid, perform the call. */
|
|
else if ((unsigned) call_nr >= NCALLS) {
|
|
result = ENOSYS;
|
|
} else {
|
|
result = (*call_vec[call_nr])();
|
|
}
|
|
|
|
/* Send the results back to the user to indicate completion. */
|
|
if (result != SUSPEND) setreply(who, result);
|
|
|
|
swap_in(); /* maybe a process can be swapped in? */
|
|
|
|
/* Send out all pending reply messages, including the answer to
|
|
* the call just made above. The processes must not be swapped out.
|
|
*/
|
|
for (proc_nr=0, rmp=mproc; proc_nr < NR_PROCS; proc_nr++, rmp++) {
|
|
if ((rmp->mp_flags & (REPLY | ONSWAP)) == REPLY) {
|
|
if ((s=send(proc_nr, &rmp->mp_reply)) != OK) {
|
|
panic("PM can't reply to", proc_nr);
|
|
}
|
|
rmp->mp_flags &= ~REPLY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* get_work *
|
|
*===========================================================================*/
|
|
PRIVATE void get_work()
|
|
{
|
|
/* Wait for the next message and extract useful information from it. */
|
|
if (receive(ANY, &m_in) != OK) panic("PM receive error", NO_NUM);
|
|
who = m_in.m_source; /* who sent the message */
|
|
call_nr = m_in.m_type; /* system call number */
|
|
|
|
/* Process slot of caller. Misuse PM's own process slot if the kernel is
|
|
* calling. The can happen in case of pending kernel signals.
|
|
*/
|
|
mp = &mproc[who < 0 ? PM_PROC_NR : who];
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* setreply *
|
|
*===========================================================================*/
|
|
PUBLIC void setreply(proc_nr, result)
|
|
int proc_nr; /* process to reply to */
|
|
int result; /* result of call (usually OK or error #) */
|
|
{
|
|
/* Fill in a reply message to be sent later to a user process. System calls
|
|
* may occasionally fill in other fields, this is only for the main return
|
|
* value, and for setting the "must send reply" flag.
|
|
*/
|
|
register struct mproc *rmp = &mproc[proc_nr];
|
|
|
|
rmp->mp_reply.reply_res = result;
|
|
rmp->mp_flags |= REPLY; /* reply pending */
|
|
|
|
if (rmp->mp_flags & ONSWAP)
|
|
swap_inqueue(rmp); /* must swap this process back in */
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* pm_init *
|
|
*===========================================================================*/
|
|
PRIVATE void pm_init()
|
|
{
|
|
/* Initialize the process manager. */
|
|
int key, i, s;
|
|
static struct system_image image[IMAGE_SIZE];
|
|
register struct system_image *ip;
|
|
static char core_sigs[] = { SIGQUIT, SIGILL, SIGTRAP, SIGABRT,
|
|
SIGEMT, SIGFPE, SIGUSR1, SIGSEGV, SIGUSR2 };
|
|
static char ign_sigs[] = { SIGCHLD };
|
|
register int proc_nr;
|
|
register struct mproc *rmp;
|
|
register char *sig_ptr;
|
|
phys_clicks ram_clicks, total_clicks, minix_clicks, free_clicks;
|
|
message mess;
|
|
struct mem_map kernel_map[NR_LOCAL_SEGS];
|
|
int mem;
|
|
|
|
/* Build the set of signals which cause core dumps, and the set of signals
|
|
* that are by default ignored.
|
|
*/
|
|
sigemptyset(&core_sset);
|
|
for (sig_ptr = core_sigs; sig_ptr < core_sigs+sizeof(core_sigs); sig_ptr++)
|
|
sigaddset(&core_sset, *sig_ptr);
|
|
sigemptyset(&ign_sset);
|
|
for (sig_ptr = ign_sigs; sig_ptr < ign_sigs+sizeof(ign_sigs); sig_ptr++)
|
|
sigaddset(&ign_sset, *sig_ptr);
|
|
|
|
/* Get the memory map of the kernel to see how much memory it uses. */
|
|
if ((s=get_mem_map(SYSTASK, kernel_map)) != OK)
|
|
panic("PM couldn't get proc entry of SYSTASK",s);
|
|
minix_clicks = (kernel_map[S].mem_phys + kernel_map[S].mem_len)
|
|
- kernel_map[T].mem_phys;
|
|
|
|
/* Initialize PM's tables. Request a copy of the system image table that
|
|
* is defined at the kernel level to see which slots to fill in.
|
|
*/
|
|
if (OK != (s=sys_getimage(&image))) {
|
|
printf("PM: warning, couldn't get system image table: %d\n", s);
|
|
}
|
|
procs_in_use = 0; /* start populating table */
|
|
for (ip = &image[0]; ip < &image[IMAGE_SIZE]; ip++) {
|
|
if (ip->proc_nr >= 0) { /* task have negative nrs */
|
|
procs_in_use += 1; /* found user process */
|
|
|
|
/* Set process details. */
|
|
rmp = &mproc[ip->proc_nr];
|
|
rmp->mp_flags |= IN_USE | DONT_SWAP;
|
|
rmp->mp_pid = (ip->proc_nr == INIT_PROC_NR) ?
|
|
INIT_PID : get_free_pid();
|
|
strncpy(rmp->mp_name, ip->proc_name, PROC_NAME_LEN);
|
|
|
|
/* Change signal handling behaviour. */
|
|
sigfillset(&rmp->mp_ignore);
|
|
sigfillset(&rmp->mp_sigmask);
|
|
sigemptyset(&rmp->mp_catch);
|
|
|
|
/* Get memory map for this process from the kernel. */
|
|
if ((s=get_mem_map(ip->proc_nr, rmp->mp_seg)) != OK)
|
|
panic("couldn't get process entry",s);
|
|
if (rmp->mp_seg[T].mem_len != 0) rmp->mp_flags |= SEPARATE;
|
|
minix_clicks += rmp->mp_seg[S].mem_phys +
|
|
rmp->mp_seg[S].mem_len - rmp->mp_seg[T].mem_phys;
|
|
|
|
/* Tell FS about this system process. */
|
|
mess.PR_PROC_NR = ip->proc_nr;
|
|
mess.PR_PID = rmp->mp_pid;
|
|
if (OK != (s=send(FS_PROC_NR, &mess)))
|
|
panic("PM can't sync up with FS", s);
|
|
}
|
|
}
|
|
|
|
/* Tell FS no more SYSTEM processes follow and synchronize. */
|
|
mess.PR_PROC_NR = NONE;
|
|
if (sendrec(FS_PROC_NR, &mess) != OK || mess.m_type != OK)
|
|
panic("PM can't sync up with FS", NO_NUM);
|
|
|
|
/* INIT process is somewhat special. */
|
|
sigemptyset(&mproc[INIT_PROC_NR].mp_ignore);
|
|
sigemptyset(&mproc[INIT_PROC_NR].mp_sigmask);
|
|
sigemptyset(&mproc[INIT_PROC_NR].mp_catch);
|
|
|
|
/* Initialize tables to all physical memory. */
|
|
mem_init(&free_clicks);
|
|
total_clicks = minix_clicks + free_clicks;
|
|
|
|
/* Print memory information. */
|
|
printf("Memory size=%uK ", click_to_round_k(total_clicks));
|
|
printf("System services=%uK ", click_to_round_k(minix_clicks));
|
|
printf("Available=%uK\n\n", click_to_round_k(free_clicks));
|
|
|
|
/* Register function keys with TTY for debug dumps. */
|
|
for (key=SF7; key<=SF8; key++) {
|
|
if ((i=fkey_enable(key))!=OK) {
|
|
printf("Warning: PM couldn't register Shift+F%d key: %d\n",
|
|
key-SF1+1, i);
|
|
}
|
|
}
|
|
}
|