dir..
build: all
all install clean:
- cd ./mm && $(MAKE) $@
+ cd ./pm && $(MAKE) $@
cd ./fs && $(MAKE) $@
cd ./is && $(MAKE) $@
cd ./init && $(MAKE) $@
--- /dev/null
+# Makefile for Process Manager (PM)
+SERVER = pm
+
+# directories
+u = /usr
+i = $u/include
+s = $i/sys
+h = $i/minix
+k = $u/src/kernel
+
+# programs, flags, etc.
+CC = exec cc
+CFLAGS = -I$i
+LDFLAGS = -i
+
+OBJ = main.o forkexit.o break.o exec.o procutils.o \
+ signal.o alloc.o utility.o table.o trace.o getset.o misc.o
+
+# build local binary
+all build: $(SERVER)
+$(SERVER): $(OBJ)
+ $(CC) -o $@ $(LDFLAGS) $(OBJ) -lsys -lutils
+ install -S 256w $@
+
+# install with other servers
+install: /usr/sbin/servers/$(SERVER)
+/usr/sbin/servers/$(SERVER): $(SERVER)
+ install -o root -cs $? $@
+
+# clean up local files
+clean:
+ rm -f $(SERVER) *.o *.bak
+
+# dependencies
+a = mm.h $h/config.h $s/types.h $h/const.h $h/type.h \
+ $i/ansi.h $i/fcntl.h $i/unistd.h $h/syslib.h \
+ $i/limits.h $i/errno.h const.h type.h proto.h glo.h
+
+alloc.o: $a
+alloc.o: $i/signal.h
+alloc.o: $h/com.h
+alloc.o: $h/callnr.h
+alloc.o: mproc.h
+alloc.o: $k/type.h
+alloc.o: $k/const.h
+
+break.o: $a
+break.o: $i/signal.h
+break.o: mproc.h
+break.o: param.h
+
+exec.o: $a
+exec.o: $s/stat.h
+exec.o: $h/callnr.h
+exec.o: $h/com.h
+exec.o: $i/a.out.h
+exec.o: $i/signal.h
+exec.o: $i/string.h
+exec.o: mproc.h
+exec.o: param.h
+
+forkexit.o: $a
+forkexit.o: $s/wait.h
+forkexit.o: $h/callnr.h
+forkexit.o: $h/com.h
+forkexit.o: $h/utils.h
+forkexit.o: $i/signal.h
+forkexit.o: mproc.h
+forkexit.o: param.h
+
+getset.o: $a
+getset.o: $h/callnr.h
+getset.o: $i/signal.h
+getset.o: mproc.h
+getset.o: param.h
+
+main.o: $a
+main.o: $h/callnr.h
+main.o: $h/com.h
+main.o: $i/signal.h
+main.o: $i/fcntl.h
+main.o: $h/ioctl.h
+main.o: $s/ioc_memory.h
+main.o: $h/utils.h
+main.o: mproc.h
+main.o: param.h
+
+misc.o: $a
+misc.o: $h/callnr.h
+misc.o: $h/utils.h
+misc.o: $i/signal.h
+misc.o: $h/ioctl.h
+misc.o: $s/svrctl.h
+misc.o: mproc.h
+misc.o: param.h
+
+procutils.o: $a
+procutils.o: $i/timers.h
+procutils.o: $i/string.h
+procutils.o: $k/const.h
+procutils.o: $k/type.h
+procutils.o: $k/proc.h
+
+signal.o: $a
+signal.o: $s/stat.h
+signal.o: $h/callnr.h
+signal.o: $h/utils.h
+signal.o: $h/com.h
+signal.o: $i/signal.h
+signal.o: $s/sigcontext.h
+signal.o: $i/string.h
+signal.o: mproc.h
+signal.o: param.h
+
+table.o: $a
+table.o: $h/callnr.h
+table.o: $i/signal.h
+table.o: mproc.h
+table.o: param.h
+
+trace.o: $a
+trace.o: $h/com.h
+trace.o: $s/ptrace.h
+trace.o: $i/signal.h
+trace.o: mproc.h
+trace.o: param.h
+
+utility.o: $a
+utility.o: $s/stat.h
+utility.o: $h/callnr.h
+utility.o: $h/com.h
+utility.o: $i/fcntl.h
+utility.o: $i/signal.h
+utility.o: mproc.h
--- /dev/null
+/* This file is concerned with allocating and freeing arbitrary-size blocks of
+ * physical memory on behalf of the FORK and EXEC system calls. The key data
+ * structure used is the hole table, which maintains a list of holes in memory.
+ * It is kept sorted in order of increasing memory address. The addresses
+ * it contains refers to physical memory, starting at absolute address 0
+ * (i.e., they are not relative to the start of MM). During system
+ * initialization, that part of memory containing the interrupt vectors,
+ * kernel, and MM are "allocated" to mark them as not available and to
+ * remove them from the hole list.
+ *
+ * The entry points into this file are:
+ * alloc_mem: allocate a given sized chunk of memory
+ * free_mem: release a previously allocated chunk of memory
+ * mem_init: initialize the tables when MM start up
+ * max_hole: returns the largest hole currently available
+ */
+
+#include "mm.h"
+#include <minix/com.h>
+#include <minix/callnr.h>
+#include <signal.h>
+#include "mproc.h"
+#include "../../kernel/const.h"
+#include "../../kernel/type.h"
+
+#define NR_HOLES (2*NR_PROCS) /* max # entries in hole table */
+#define NIL_HOLE (struct hole *) 0
+
+PRIVATE struct hole {
+ struct hole *h_next; /* pointer to next entry on the list */
+ phys_clicks h_base; /* where does the hole begin? */
+ phys_clicks h_len; /* how big is the hole? */
+} hole[NR_HOLES];
+
+PRIVATE struct hole *hole_head; /* pointer to first hole */
+PRIVATE struct hole *free_slots;/* ptr to list of unused table slots */
+#if ENABLE_SWAP
+PRIVATE int swap_fd = -1; /* file descriptor of open swap file/device */
+PRIVATE u32_t swap_offset; /* offset to start of swap area on swap file */
+PRIVATE phys_clicks swap_base; /* memory offset chosen as swap base */
+PRIVATE phys_clicks swap_maxsize;/* maximum amount of swap "memory" possible */
+PRIVATE struct mproc *in_queue; /* queue of processes wanting to swap in */
+PRIVATE struct mproc *outswap = &mproc[LOW_USER]; /* outswap candidate? */
+#else /* !SWAP */
+#define swap_base ((phys_clicks) -1)
+#endif /* !SWAP */
+
+FORWARD _PROTOTYPE( void del_slot, (struct hole *prev_ptr, struct hole *hp) );
+FORWARD _PROTOTYPE( void merge, (struct hole *hp) );
+#if ENABLE_SWAP
+FORWARD _PROTOTYPE( int swap_out, (void) );
+#else
+#define swap_out() (0)
+#endif
+
+/*===========================================================================*
+ * alloc_mem *
+ *===========================================================================*/
+PUBLIC phys_clicks alloc_mem(clicks)
+phys_clicks clicks; /* amount of memory requested */
+{
+/* Allocate a block of memory from the free list using first fit. The block
+ * consists of a sequence of contiguous bytes, whose length in clicks is
+ * given by 'clicks'. A pointer to the block is returned. The block is
+ * always on a click boundary. This procedure is called when memory is
+ * needed for FORK or EXEC. Swap other processes out if needed.
+ */
+
+ register struct hole *hp, *prev_ptr;
+ phys_clicks old_base;
+
+ do {
+ hp = hole_head;
+ while (hp != NIL_HOLE && hp->h_base < swap_base) {
+ if (hp->h_len >= clicks) {
+ /* We found a hole that is big enough. Use it. */
+ old_base = hp->h_base; /* remember where it started */
+ hp->h_base += clicks; /* bite a piece off */
+ hp->h_len -= clicks; /* ditto */
+
+ /* Delete the hole if used up completely. */
+ if (hp->h_len == 0) del_slot(prev_ptr, hp);
+
+ /* Return the start address of the acquired block. */
+ return(old_base);
+ }
+
+ prev_ptr = hp;
+ hp = hp->h_next;
+ }
+ } while (swap_out()); /* try to swap some other process out */
+ return(NO_MEM);
+}
+
+/*===========================================================================*
+ * free_mem *
+ *===========================================================================*/
+PUBLIC void free_mem(base, clicks)
+phys_clicks base; /* base address of block to free */
+phys_clicks clicks; /* number of clicks to free */
+{
+/* Return a block of free memory to the hole list. The parameters tell where
+ * the block starts in physical memory and how big it is. The block is added
+ * to the hole list. If it is contiguous with an existing hole on either end,
+ * it is merged with the hole or holes.
+ */
+
+ register struct hole *hp, *new_ptr, *prev_ptr;
+
+ if (clicks == 0) return;
+ if ( (new_ptr = free_slots) == NIL_HOLE) panic("Hole table full", NO_NUM);
+ new_ptr->h_base = base;
+ new_ptr->h_len = clicks;
+ free_slots = new_ptr->h_next;
+ hp = hole_head;
+
+ /* If this block's address is numerically less than the lowest hole currently
+ * available, or if no holes are currently available, put this hole on the
+ * front of the hole list.
+ */
+ if (hp == NIL_HOLE || base <= hp->h_base) {
+ /* Block to be freed goes on front of the hole list. */
+ new_ptr->h_next = hp;
+ hole_head = new_ptr;
+ merge(new_ptr);
+ return;
+ }
+
+ /* Block to be returned does not go on front of hole list. */
+ while (hp != NIL_HOLE && base > hp->h_base) {
+ prev_ptr = hp;
+ hp = hp->h_next;
+ }
+
+ /* We found where it goes. Insert block after 'prev_ptr'. */
+ new_ptr->h_next = prev_ptr->h_next;
+ prev_ptr->h_next = new_ptr;
+ merge(prev_ptr); /* sequence is 'prev_ptr', 'new_ptr', 'hp' */
+}
+
+/*===========================================================================*
+ * del_slot *
+ *===========================================================================*/
+PRIVATE void del_slot(prev_ptr, hp)
+register struct hole *prev_ptr; /* pointer to hole entry just ahead of 'hp' */
+register struct hole *hp; /* pointer to hole entry to be removed */
+{
+/* Remove an entry from the hole list. This procedure is called when a
+ * request to allocate memory removes a hole in its entirety, thus reducing
+ * the numbers of holes in memory, and requiring the elimination of one
+ * entry in the hole list.
+ */
+
+ if (hp == hole_head)
+ hole_head = hp->h_next;
+ else
+ prev_ptr->h_next = hp->h_next;
+
+ hp->h_next = free_slots;
+ free_slots = hp;
+}
+
+/*===========================================================================*
+ * merge *
+ *===========================================================================*/
+PRIVATE void merge(hp)
+register struct hole *hp; /* ptr to hole to merge with its successors */
+{
+/* Check for contiguous holes and merge any found. Contiguous holes can occur
+ * when a block of memory is freed, and it happens to abut another hole on
+ * either or both ends. The pointer 'hp' points to the first of a series of
+ * three holes that can potentially all be merged together.
+ */
+
+ register struct hole *next_ptr;
+
+ /* If 'hp' points to the last hole, no merging is possible. If it does not,
+ * try to absorb its successor into it and free the successor's table entry.
+ */
+ if ( (next_ptr = hp->h_next) == NIL_HOLE) return;
+ if (hp->h_base + hp->h_len == next_ptr->h_base) {
+ hp->h_len += next_ptr->h_len; /* first one gets second one's mem */
+ del_slot(hp, next_ptr);
+ } else {
+ hp = next_ptr;
+ }
+
+ /* If 'hp' now points to the last hole, return; otherwise, try to absorb its
+ * successor into it.
+ */
+ if ( (next_ptr = hp->h_next) == NIL_HOLE) return;
+ if (hp->h_base + hp->h_len == next_ptr->h_base) {
+ hp->h_len += next_ptr->h_len;
+ del_slot(hp, next_ptr);
+ }
+}
+
+/*===========================================================================*
+ * mem_init *
+ *===========================================================================*/
+PUBLIC void mem_init(free)
+phys_clicks *free; /* memory size summaries */
+{
+/* Initialize hole lists. There are two lists: 'hole_head' points to a linked
+ * list of all the holes (unused memory) in the system; 'free_slots' points to
+ * a linked list of table entries that are not in use. Initially, the former
+ * list has one entry for each chunk of physical memory, and the second
+ * list links together the remaining table slots. As memory becomes more
+ * fragmented in the course of time (i.e., the initial big holes break up into
+ * smaller holes), new table slots are needed to represent them. These slots
+ * are taken from the list headed by 'free_slots'.
+ */
+ struct memory mem[NR_MEMS]; /* chunks of physical memory */
+ int i;
+ register struct hole *hp;
+ phys_clicks base; /* base address of chunk */
+ phys_clicks size; /* size of chunk */
+ message mess;
+
+ /* Get a copy of the physical memory chunks found at the kernel. */
+ if ((i=sys_getmemchunks(mem)) != OK)
+ panic("MM couldn't get mem chunks",i);
+
+ /* Put all holes on the free list. */
+ for (hp = &hole[0]; hp < &hole[NR_HOLES]; hp++) hp->h_next = hp + 1;
+ hole[NR_HOLES-1].h_next = NIL_HOLE;
+ hole_head = NIL_HOLE;
+ free_slots = &hole[0];
+
+ /* Ask the kernel for chunks of physical memory and allocate holes. */
+ *free = 0;
+ for (i=0; i<NR_MEMS; i++) {
+ if (mem[i].size > 0) {
+ free_mem(mem[i].base, mem[i].size);
+ *free += mem[i].size;
+#if ENABLE_SWAP
+ if (swap_base < mem[i].base + mem[i].size)
+ swap_base = mem[i].base+mem[i].size;
+#endif
+ }
+ }
+
+#if ENABLE_SWAP
+ /* The swap area is represented as a hole above and separate of regular
+ * memory. A hole at the size of the swap file is allocated on "swapon".
+ */
+ swap_base++; /* make separate */
+ swap_maxsize = 0 - swap_base; /* maximum we can possibly use */
+#endif
+}
+
+#if ENABLE_SWAP
+/*===========================================================================*
+ * swap_on *
+ *===========================================================================*/
+PUBLIC int swap_on(file, offset, size)
+char *file; /* file to swap on */
+u32_t offset, size; /* area on swap file to use */
+{
+/* Turn swapping on. */
+
+ if (swap_fd != -1) return(EBUSY); /* already have swap? */
+
+ tell_fs(CHDIR, who, FALSE, 0); /* be like the caller for open() */
+ if ((swap_fd = open(file, O_RDWR)) < 0) return(-errno);
+ swap_offset = offset;
+ size >>= CLICK_SHIFT;
+ if (size > swap_maxsize) size = swap_maxsize;
+ if (size > 0) free_mem(swap_base, (phys_clicks) size);
+}
+
+/*===========================================================================*
+ * swap_off *
+ *===========================================================================*/
+PUBLIC int swap_off()
+{
+/* Turn swapping off. */
+ struct mproc *rmp;
+ struct hole *hp, *prev_ptr;
+
+ if (swap_fd == -1) return(OK); /* can't turn off what isn't on */
+
+ /* Put all swapped out processes on the inswap queue and swap in. */
+ for (rmp = &mproc[LOW_USER]; rmp < &mproc[NR_PROCS]; rmp++) {
+ if (rmp->mp_flags & ONSWAP) swap_inqueue(rmp);
+ }
+ swap_in();
+
+ /* All in memory? */
+ for (rmp = &mproc[LOW_USER]; rmp < &mproc[NR_PROCS]; rmp++) {
+ if (rmp->mp_flags & ONSWAP) return(ENOMEM);
+ }
+
+ /* Yes. Remove the swap hole and close the swap file descriptor. */
+ for (hp = hole_head; hp != NIL_HOLE; prev_ptr = hp, hp = hp->h_next) {
+ if (hp->h_base >= swap_base) {
+ del_slot(prev_ptr, hp);
+ hp = hole_head;
+ }
+ }
+ close(swap_fd);
+ swap_fd = -1;
+ return(OK);
+}
+
+/*===========================================================================*
+ * swap_inqueue *
+ *===========================================================================*/
+PUBLIC void swap_inqueue(rmp)
+register struct mproc *rmp; /* process to add to the queue */
+{
+/* Put a swapped out process on the queue of processes to be swapped in. This
+ * happens when such a process gets a signal, or if a reply message must be
+ * sent, like when a process doing a wait() has a child that exits.
+ */
+ struct mproc **pmp;
+
+ if (rmp->mp_flags & SWAPIN) return; /* already queued */
+
+
+ for (pmp = &in_queue; *pmp != NULL; pmp = &(*pmp)->mp_swapq) {}
+ *pmp = rmp;
+ rmp->mp_swapq = NULL;
+ rmp->mp_flags |= SWAPIN;
+}
+
+/*===========================================================================*
+ * swap_in *
+ *===========================================================================*/
+PUBLIC void swap_in()
+{
+/* Try to swap in a process on the inswap queue. We want to send it a message,
+ * interrupt it, or something.
+ */
+ struct mproc **pmp, *rmp;
+ phys_clicks old_base, new_base, size;
+ off_t off;
+ int proc_nr;
+
+ pmp = &in_queue;
+ while ((rmp = *pmp) != NULL) {
+ proc_nr = (rmp - mproc);
+ size = rmp->mp_seg[S].mem_vir + rmp->mp_seg[S].mem_len
+ - rmp->mp_seg[D].mem_vir;
+
+ if (!(rmp->mp_flags & SWAPIN)) {
+ /* Guess it got killed. (Queue is cleaned here.) */
+ *pmp = rmp->mp_swapq;
+ continue;
+ } else
+ if ((new_base = alloc_mem(size)) == NO_MEM) {
+ /* No memory for this one, try the next. */
+ pmp = &rmp->mp_swapq;
+ } else {
+ /* We've found memory. Update map and swap in. */
+ old_base = rmp->mp_seg[D].mem_phys;
+ rmp->mp_seg[D].mem_phys = new_base;
+ rmp->mp_seg[S].mem_phys = rmp->mp_seg[D].mem_phys +
+ (rmp->mp_seg[S].mem_vir - rmp->mp_seg[D].mem_vir);
+ sys_newmap(proc_nr, rmp->mp_seg);
+ off = swap_offset + ((off_t) (old_base-swap_base)<<CLICK_SHIFT);
+ lseek(swap_fd, off, SEEK_SET);
+ rw_seg(0, swap_fd, proc_nr, D, (phys_bytes)size << CLICK_SHIFT);
+ free_mem(old_base, size);
+ rmp->mp_flags &= ~(ONSWAP|SWAPIN);
+ *pmp = rmp->mp_swapq;
+ check_pending(rmp); /* a signal may have waked this one */
+ }
+ }
+}
+
+/*===========================================================================*
+ * swap_out *
+ *===========================================================================*/
+PRIVATE int swap_out()
+{
+/* Try to find a process that can be swapped out. Candidates are those blocked
+ * on a system call that MM handles, like wait(), pause() or sigsuspend().
+ */
+ struct mproc *rmp;
+ struct hole *hp, *prev_ptr;
+ phys_clicks old_base, new_base, size;
+ off_t off;
+ int proc_nr;
+
+ rmp = outswap;
+ do {
+ if (++rmp == &mproc[NR_PROCS]) rmp = &mproc[LOW_USER];
+
+ /* A candidate? */
+ if (!(rmp->mp_flags & (PAUSED | WAITING | SIGSUSPENDED))) continue;
+
+ /* Already on swap or otherwise to be avoided? */
+ if (rmp->mp_flags & (TRACED | REPLY | ONSWAP)) continue;
+
+ /* Got one, find a swap hole and swap it out. */
+ proc_nr = (rmp - mproc);
+ size = rmp->mp_seg[S].mem_vir + rmp->mp_seg[S].mem_len
+ - rmp->mp_seg[D].mem_vir;
+
+ prev_ptr = NIL_HOLE;
+ for (hp = hole_head; hp != NIL_HOLE; prev_ptr = hp, hp = hp->h_next) {
+ if (hp->h_base >= swap_base && hp->h_len >= size) break;
+ }
+ if (hp == NIL_HOLE) continue; /* oops, not enough swapspace */
+ new_base = hp->h_base;
+ hp->h_base += size;
+ hp->h_len -= size;
+ if (hp->h_len == 0) del_slot(prev_ptr, hp);
+
+ off = swap_offset + ((off_t) (new_base - swap_base) << CLICK_SHIFT);
+ lseek(swap_fd, off, SEEK_SET);
+ rw_seg(1, swap_fd, proc_nr, D, (phys_bytes)size << CLICK_SHIFT);
+ old_base = rmp->mp_seg[D].mem_phys;
+ rmp->mp_seg[D].mem_phys = new_base;
+ rmp->mp_seg[S].mem_phys = rmp->mp_seg[D].mem_phys +
+ (rmp->mp_seg[S].mem_vir - rmp->mp_seg[D].mem_vir);
+ sys_newmap(proc_nr, rmp->mp_seg);
+ free_mem(old_base, size);
+ rmp->mp_flags |= ONSWAP;
+
+ outswap = rmp; /* next time start here */
+ return(TRUE);
+ } while (rmp != outswap);
+
+ return(FALSE); /* no candidate found */
+}
+#endif /* SWAP */
--- /dev/null
+/* The MINIX model of memory allocation reserves a fixed amount of memory for
+ * the combined text, data, and stack segments. The amount used for a child
+ * process created by FORK is the same as the parent had. If the child does
+ * an EXEC later, the new size is taken from the header of the file EXEC'ed.
+ *
+ * The layout in memory consists of the text segment, followed by the data
+ * segment, followed by a gap (unused memory), followed by the stack segment.
+ * The data segment grows upward and the stack grows downward, so each can
+ * take memory from the gap. If they meet, the process must be killed. The
+ * procedures in this file deal with the growth of the data and stack segments.
+ *
+ * The entry points into this file are:
+ * do_brk: BRK/SBRK system calls to grow or shrink the data segment
+ * adjust: see if a proposed segment adjustment is allowed
+ * size_ok: see if the segment sizes are feasible
+ */
+
+#include "mm.h"
+#include <signal.h>
+#include "mproc.h"
+#include "param.h"
+
+#define DATA_CHANGED 1 /* flag value when data segment size changed */
+#define STACK_CHANGED 2 /* flag value when stack size changed */
+
+/*===========================================================================*
+ * do_brk *
+ *===========================================================================*/
+PUBLIC int do_brk()
+{
+/* Perform the brk(addr) system call.
+ *
+ * The call is complicated by the fact that on some machines (e.g., 8088),
+ * the stack pointer can grow beyond the base of the stack segment without
+ * anybody noticing it.
+ * The parameter, 'addr' is the new virtual address in D space.
+ */
+
+ register struct mproc *rmp;
+ int r;
+ vir_bytes v, new_sp;
+ vir_clicks new_clicks;
+
+ rmp = mp;
+ v = (vir_bytes) m_in.addr;
+ new_clicks = (vir_clicks) ( ((long) v + CLICK_SIZE - 1) >> CLICK_SHIFT);
+ if (new_clicks < rmp->mp_seg[D].mem_vir) {
+ rmp->mp_reply.reply_ptr = (char *) -1;
+ return(ENOMEM);
+ }
+ new_clicks -= rmp->mp_seg[D].mem_vir;
+ if ((r=p_getsp(who, &new_sp)) != OK) /* ask kernel for current sp value */
+ panic("MM couldn't get stack pointer", r);
+ r = adjust(rmp, new_clicks, new_sp);
+ rmp->mp_reply.reply_ptr = (r == OK ? m_in.addr : (char *) -1);
+ return(r); /* return new address or -1 */
+}
+
+
+/*===========================================================================*
+ * adjust *
+ *===========================================================================*/
+PUBLIC int adjust(rmp, data_clicks, sp)
+register struct mproc *rmp; /* whose memory is being adjusted? */
+vir_clicks data_clicks; /* how big is data segment to become? */
+vir_bytes sp; /* new value of sp */
+{
+/* See if data and stack segments can coexist, adjusting them if need be.
+ * Memory is never allocated or freed. Instead it is added or removed from the
+ * gap between data segment and stack segment. If the gap size becomes
+ * negative, the adjustment of data or stack fails and ENOMEM is returned.
+ */
+
+ register struct mem_map *mem_sp, *mem_dp;
+ vir_clicks sp_click, gap_base, lower, old_clicks;
+ int changed, r, ft;
+ long base_of_stack, delta; /* longs avoid certain problems */
+
+ mem_dp = &rmp->mp_seg[D]; /* pointer to data segment map */
+ mem_sp = &rmp->mp_seg[S]; /* pointer to stack segment map */
+ changed = 0; /* set when either segment changed */
+
+ if (mem_sp->mem_len == 0) return(OK); /* don't bother init */
+
+ /* See if stack size has gone negative (i.e., sp too close to 0xFFFF...) */
+ base_of_stack = (long) mem_sp->mem_vir + (long) mem_sp->mem_len;
+ sp_click = sp >> CLICK_SHIFT; /* click containing sp */
+ if (sp_click >= base_of_stack) return(ENOMEM); /* sp too high */
+
+ /* Compute size of gap between stack and data segments. */
+ delta = (long) mem_sp->mem_vir - (long) sp_click;
+ lower = (delta > 0 ? sp_click : mem_sp->mem_vir);
+
+ /* Add a safety margin for future stack growth. Impossible to do right. */
+#define SAFETY_BYTES (384 * sizeof(char *))
+#define SAFETY_CLICKS ((SAFETY_BYTES + CLICK_SIZE - 1) / CLICK_SIZE)
+ gap_base = mem_dp->mem_vir + data_clicks + SAFETY_CLICKS;
+ if (lower < gap_base) return(ENOMEM); /* data and stack collided */
+
+ /* Update data length (but not data orgin) on behalf of brk() system call. */
+ old_clicks = mem_dp->mem_len;
+ if (data_clicks != mem_dp->mem_len) {
+ mem_dp->mem_len = data_clicks;
+ changed |= DATA_CHANGED;
+ }
+
+ /* Update stack length and origin due to change in stack pointer. */
+ if (delta > 0) {
+ mem_sp->mem_vir -= delta;
+ mem_sp->mem_phys -= delta;
+ mem_sp->mem_len += delta;
+ changed |= STACK_CHANGED;
+ }
+
+ /* Do the new data and stack segment sizes fit in the address space? */
+ ft = (rmp->mp_flags & SEPARATE);
+ r = size_ok(ft, rmp->mp_seg[T].mem_len, rmp->mp_seg[D].mem_len,
+ rmp->mp_seg[S].mem_len, rmp->mp_seg[D].mem_vir, rmp->mp_seg[S].mem_vir);
+ if (r == OK) {
+ if (changed) sys_newmap((int)(rmp - mproc), rmp->mp_seg);
+ return(OK);
+ }
+
+ /* New sizes don't fit or require too many page/segment registers. Restore.*/
+ if (changed & DATA_CHANGED) mem_dp->mem_len = old_clicks;
+ if (changed & STACK_CHANGED) {
+ mem_sp->mem_vir += delta;
+ mem_sp->mem_phys += delta;
+ mem_sp->mem_len -= delta;
+ }
+ return(ENOMEM);
+}
+
+
+/*===========================================================================*
+ * size_ok *
+ *===========================================================================*/
+PUBLIC int size_ok(file_type, tc, dc, sc, dvir, s_vir)
+int file_type; /* SEPARATE or 0 */
+vir_clicks tc; /* text size in clicks */
+vir_clicks dc; /* data size in clicks */
+vir_clicks sc; /* stack size in clicks */
+vir_clicks dvir; /* virtual address for start of data seg */
+vir_clicks s_vir; /* virtual address for start of stack seg */
+{
+/* Check to see if the sizes are feasible and enough segmentation registers
+ * exist. On a machine with eight 8K pages, text, data, stack sizes of
+ * (32K, 16K, 16K) will fit, but (33K, 17K, 13K) will not, even though the
+ * former is bigger (64K) than the latter (63K). Even on the 8088 this test
+ * is needed, since the data and stack may not exceed 4096 clicks.
+ */
+
+#if (CHIP == INTEL && _WORD_SIZE == 2)
+ int pt, pd, ps; /* segment sizes in pages */
+
+ pt = ( (tc << CLICK_SHIFT) + PAGE_SIZE - 1)/PAGE_SIZE;
+ pd = ( (dc << CLICK_SHIFT) + PAGE_SIZE - 1)/PAGE_SIZE;
+ ps = ( (sc << CLICK_SHIFT) + PAGE_SIZE - 1)/PAGE_SIZE;
+
+ if (file_type == SEPARATE) {
+ if (pt > MAX_PAGES || pd + ps > MAX_PAGES) return(ENOMEM);
+ } else {
+ if (pt + pd + ps > MAX_PAGES) return(ENOMEM);
+ }
+#endif
+
+ if (dvir + dc > s_vir) return(ENOMEM);
+
+ return(OK);
+}
--- /dev/null
+/* Constants used by the Memory Manager. */
+
+#define NO_MEM ((phys_clicks) 0) /* returned by alloc_mem() with mem is up */
+
+#if (CHIP == INTEL && _WORD_SIZE == 2)
+/* These definitions are used in size_ok and are not needed for 386.
+ * The 386 segment granularity is 1 for segments smaller than 1M and 4096
+ * above that.
+ */
+#define PAGE_SIZE 16 /* how many bytes in a page (s.b.HCLICK_SIZE)*/
+#define MAX_PAGES 4096 /* how many pages in the virtual addr space */
+#endif
+
+#define INIT_PID 1 /* init's process id number */
--- /dev/null
+/* This file handles the EXEC system call. It performs the work as follows:
+ * - see if the permissions allow the file to be executed
+ * - read the header and extract the sizes
+ * - fetch the initial args and environment from the user space
+ * - allocate the memory for the new process
+ * - copy the initial stack from MM to the process
+ * - read in the text and data segments and copy to the process
+ * - take care of setuid and setgid bits
+ * - fix up 'mproc' table
+ * - tell kernel about EXEC
+ * - save offset to initial argc (for ps)
+ *
+ * The entry points into this file are:
+ * do_exec: perform the EXEC system call
+ * rw_seg: read or write a segment from or to a file
+ * find_share: find a process whose text segment can be shared
+ */
+
+#include "mm.h"
+#include <sys/stat.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <a.out.h>
+#include <signal.h>
+#include <string.h>
+#include "mproc.h"
+#include "param.h"
+
+FORWARD _PROTOTYPE( int new_mem, (struct mproc *sh_mp, vir_bytes text_bytes,
+ vir_bytes data_bytes, vir_bytes bss_bytes,
+ vir_bytes stk_bytes, phys_bytes tot_bytes) );
+FORWARD _PROTOTYPE( void patch_ptr, (char stack[ARG_MAX], vir_bytes base) );
+FORWARD _PROTOTYPE( int insert_arg, (char stack[ARG_MAX],
+ vir_bytes *stk_bytes, char *arg, int replace) );
+FORWARD _PROTOTYPE( char *patch_stack, (int fd, char stack[ARG_MAX],
+ vir_bytes *stk_bytes, char *script) );
+FORWARD _PROTOTYPE( int read_header, (int fd, int *ft, vir_bytes *text_bytes,
+ vir_bytes *data_bytes, vir_bytes *bss_bytes,
+ phys_bytes *tot_bytes, long *sym_bytes, vir_clicks sc,
+ vir_bytes *pc) );
+
+#define ESCRIPT (-2000) /* Returned by read_header for a #! script. */
+#define PTRSIZE sizeof(char *) /* Size of pointers in argv[] and envp[]. */
+
+/*===========================================================================*
+ * do_exec *
+ *===========================================================================*/
+PUBLIC int do_exec()
+{
+/* Perform the execve(name, argv, envp) call. The user library builds a
+ * complete stack image, including pointers, args, environ, etc. The stack
+ * is copied to a buffer inside MM, and then to the new core image.
+ */
+
+ register struct mproc *rmp;
+ struct mproc *sh_mp;
+ int m, r, fd, ft, sn;
+ static char mbuf[ARG_MAX]; /* buffer for stack and zeroes */
+ static char name_buf[PATH_MAX]; /* the name of the file to exec */
+ char *new_sp, *name, *basename;
+ vir_bytes src, dst, text_bytes, data_bytes, bss_bytes, stk_bytes, vsp;
+ phys_bytes tot_bytes; /* total space for program, including gap */
+ long sym_bytes;
+ vir_clicks sc;
+ struct stat s_buf[2], *s_p;
+ vir_bytes pc;
+
+ /* Do some validity checks. */
+ rmp = mp;
+ stk_bytes = (vir_bytes) m_in.stack_bytes;
+ if (stk_bytes > ARG_MAX) return(ENOMEM); /* stack too big */
+ if (m_in.exec_len <= 0 || m_in.exec_len > PATH_MAX) return(EINVAL);
+
+ /* Get the exec file name and see if the file is executable. */
+ src = (vir_bytes) m_in.exec_name;
+ dst = (vir_bytes) name_buf;
+ r = sys_datacopy(who, (vir_bytes) src,
+ PM_PROC_NR, (vir_bytes) dst, (phys_bytes) m_in.exec_len);
+ if (r != OK) return(r); /* file name not in user data segment */
+
+ /* Fetch the stack from the user before destroying the old core image. */
+ src = (vir_bytes) m_in.stack_ptr;
+ dst = (vir_bytes) mbuf;
+ r = sys_datacopy(who, (vir_bytes) src,
+ PM_PROC_NR, (vir_bytes) dst, (phys_bytes)stk_bytes);
+
+ if (r != OK) return(EACCES); /* can't fetch stack (e.g. bad virtual addr) */
+
+ r = 0; /* r = 0 (first attempt), or 1 (interpreted script) */
+ name = name_buf; /* name of file to exec. */
+ do {
+ s_p = &s_buf[r];
+ tell_fs(CHDIR, who, FALSE, 0); /* switch to the user's FS environ */
+ fd = allowed(name, s_p, X_BIT); /* is file executable? */
+ if (fd < 0) return(fd); /* file was not executable */
+
+ /* Read the file header and extract the segment sizes. */
+ sc = (stk_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+
+ m = read_header(fd, &ft, &text_bytes, &data_bytes, &bss_bytes,
+ &tot_bytes, &sym_bytes, sc, &pc);
+ if (m != ESCRIPT || ++r > 1) break;
+ } while ((name = patch_stack(fd, mbuf, &stk_bytes, name_buf)) != NULL);
+
+ if (m < 0) {
+ close(fd); /* something wrong with header */
+ return(stk_bytes > ARG_MAX ? ENOMEM : ENOEXEC);
+ }
+
+ /* Can the process' text be shared with that of one already running? */
+ sh_mp = find_share(rmp, s_p->st_ino, s_p->st_dev, s_p->st_ctime);
+
+ /* Allocate new memory and release old memory. Fix map and tell kernel. */
+ r = new_mem(sh_mp, text_bytes, data_bytes, bss_bytes, stk_bytes, tot_bytes);
+ if (r != OK) {
+ close(fd); /* insufficient core or program too big */
+ return(r);
+ }
+
+ /* Save file identification to allow it to be shared. */
+ rmp->mp_ino = s_p->st_ino;
+ rmp->mp_dev = s_p->st_dev;
+ rmp->mp_ctime = s_p->st_ctime;
+
+ /* Patch up stack and copy it from MM to new core image. */
+ vsp = (vir_bytes) rmp->mp_seg[S].mem_vir << CLICK_SHIFT;
+ vsp += (vir_bytes) rmp->mp_seg[S].mem_len << CLICK_SHIFT;
+ vsp -= stk_bytes;
+ patch_ptr(mbuf, vsp);
+ src = (vir_bytes) mbuf;
+ r = sys_datacopy(PM_PROC_NR, (vir_bytes) src,
+ who, (vir_bytes) vsp, (phys_bytes)stk_bytes);
+ if (r != OK) panic("do_exec stack copy err on", who);
+
+ /* Read in text and data segments. */
+ if (sh_mp != NULL) {
+ lseek(fd, (off_t) text_bytes, SEEK_CUR); /* shared: skip text */
+ } else {
+ rw_seg(0, fd, who, T, text_bytes);
+ }
+ rw_seg(0, fd, who, D, data_bytes);
+
+ close(fd); /* don't need exec file any more */
+
+ /* Take care of setuid/setgid bits. */
+ if ((rmp->mp_flags & TRACED) == 0) { /* suppress if tracing */
+ if (s_buf[0].st_mode & I_SET_UID_BIT) {
+ rmp->mp_effuid = s_buf[0].st_uid;
+ tell_fs(SETUID,who, (int)rmp->mp_realuid, (int)rmp->mp_effuid);
+ }
+ if (s_buf[0].st_mode & I_SET_GID_BIT) {
+ rmp->mp_effgid = s_buf[0].st_gid;
+ tell_fs(SETGID,who, (int)rmp->mp_realgid, (int)rmp->mp_effgid);
+ }
+ }
+
+ /* Save offset to initial argc (for ps) */
+ rmp->mp_procargs = vsp;
+
+ /* Fix 'mproc' fields, tell kernel that exec is done, reset caught sigs. */
+ for (sn = 1; sn <= _NSIG; sn++) {
+ if (sigismember(&rmp->mp_catch, sn)) {
+ sigdelset(&rmp->mp_catch, sn);
+ rmp->mp_sigact[sn].sa_handler = SIG_DFL;
+ sigemptyset(&rmp->mp_sigact[sn].sa_mask);
+ }
+ }
+
+ rmp->mp_flags &= ~SEPARATE; /* turn off SEPARATE bit */
+ rmp->mp_flags |= ft; /* turn it on for separate I & D files */
+ new_sp = (char *) vsp;
+
+ tell_fs(EXEC, who, 0, 0); /* allow FS to handle FD_CLOEXEC files */
+
+ /* System will save command line for debugging, ps(1) output, etc. */
+ basename = strrchr(name, '/');
+ if (basename == NULL) basename = name; else basename++;
+ strncpy(rmp->mp_name, basename, PROC_NAME_LEN-1);
+ rmp->mp_name[PROC_NAME_LEN] = '\0';
+ sys_exec(who, new_sp, rmp->mp_flags & TRACED, basename, pc);
+
+ return(SUSPEND); /* no reply, new program just runs */
+}
+
+
+/*===========================================================================*
+ * read_header *
+ *===========================================================================*/
+PRIVATE int read_header(fd, ft, text_bytes, data_bytes, bss_bytes,
+ tot_bytes, sym_bytes, sc, pc)
+int fd; /* file descriptor for reading exec file */
+int *ft; /* place to return ft number */
+vir_bytes *text_bytes; /* place to return text size */
+vir_bytes *data_bytes; /* place to return initialized data size */
+vir_bytes *bss_bytes; /* place to return bss size */
+phys_bytes *tot_bytes; /* place to return total size */
+long *sym_bytes; /* place to return symbol table size */
+vir_clicks sc; /* stack size in clicks */
+vir_bytes *pc; /* program entry point (initial PC) */
+{
+/* Read the header and extract the text, data, bss and total sizes from it. */
+
+ int m, ct;
+ vir_clicks tc, dc, s_vir, dvir;
+ phys_clicks totc;
+ struct exec hdr; /* a.out header is read in here */
+
+ /* Read the header and check the magic number. The standard MINIX header
+ * is defined in <a.out.h>. It consists of 8 chars followed by 6 longs.
+ * Then come 4 more longs that are not used here.
+ * Byte 0: magic number 0x01
+ * Byte 1: magic number 0x03
+ * Byte 2: normal = 0x10 (not checked, 0 is OK), separate I/D = 0x20
+ * Byte 3: CPU type, Intel 16 bit = 0x04, Intel 32 bit = 0x10,
+ * Motorola = 0x0B, Sun SPARC = 0x17
+ * Byte 4: Header length = 0x20
+ * Bytes 5-7 are not used.
+ *
+ * Now come the 6 longs
+ * Bytes 8-11: size of text segments in bytes
+ * Bytes 12-15: size of initialized data segment in bytes
+ * Bytes 16-19: size of bss in bytes
+ * Bytes 20-23: program entry point
+ * Bytes 24-27: total memory allocated to program (text, data + stack)
+ * Bytes 28-31: size of symbol table in bytes
+ * The longs are represented in a machine dependent order,
+ * little-endian on the 8088, big-endian on the 68000.
+ * The header is followed directly by the text and data segments, and the
+ * symbol table (if any). The sizes are given in the header. Only the
+ * text and data segments are copied into memory by exec. The header is
+ * used here only. The symbol table is for the benefit of a debugger and
+ * is ignored here.
+ */
+
+ if ((m= read(fd, &hdr, A_MINHDR)) < 2) return(ENOEXEC);
+
+ /* Interpreted script? */
+ if (((char *) &hdr)[0] == '#' && ((char *) &hdr)[1] == '!') return(ESCRIPT);
+
+ if (m != A_MINHDR) return(ENOEXEC);
+
+ /* Check magic number, cpu type, and flags. */
+ if (BADMAG(hdr)) return(ENOEXEC);
+#if (CHIP == INTEL && _WORD_SIZE == 2)
+ if (hdr.a_cpu != A_I8086) return(ENOEXEC);
+#endif
+#if (CHIP == INTEL && _WORD_SIZE == 4)
+ if (hdr.a_cpu != A_I80386) return(ENOEXEC);
+#endif
+ if ((hdr.a_flags & ~(A_NSYM | A_EXEC | A_SEP)) != 0) return(ENOEXEC);
+
+ *ft = ( (hdr.a_flags & A_SEP) ? SEPARATE : 0); /* separate I & D or not */
+
+ /* Get text and data sizes. */
+ *text_bytes = (vir_bytes) hdr.a_text; /* text size in bytes */
+ *data_bytes = (vir_bytes) hdr.a_data; /* data size in bytes */
+ *bss_bytes = (vir_bytes) hdr.a_bss; /* bss size in bytes */
+ *tot_bytes = hdr.a_total; /* total bytes to allocate for prog */
+ *sym_bytes = hdr.a_syms; /* symbol table size in bytes */
+ if (*tot_bytes == 0) return(ENOEXEC);
+
+ if (*ft != SEPARATE) {
+ /* If I & D space is not separated, it is all considered data. Text=0*/
+ *data_bytes += *text_bytes;
+ *text_bytes = 0;
+ }
+ *pc = hdr.a_entry; /* initial address to start execution */
+
+ /* Check to see if segment sizes are feasible. */
+ tc = ((unsigned long) *text_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ dc = (*data_bytes + *bss_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ totc = (*tot_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ if (dc >= totc) return(ENOEXEC); /* stack must be at least 1 click */
+ dvir = (*ft == SEPARATE ? 0 : tc);
+ s_vir = dvir + (totc - sc);
+ m = size_ok(*ft, tc, dc, sc, dvir, s_vir);
+ ct = hdr.a_hdrlen & BYTE; /* header length */
+ if (ct > A_MINHDR) lseek(fd, (off_t) ct, SEEK_SET); /* skip unused hdr */
+ return(m);
+}
+
+
+/*===========================================================================*
+ * new_mem *
+ *===========================================================================*/
+PRIVATE int new_mem(sh_mp, text_bytes, data_bytes,bss_bytes,stk_bytes,tot_bytes)
+struct mproc *sh_mp; /* text can be shared with this process */
+vir_bytes text_bytes; /* text segment size in bytes */
+vir_bytes data_bytes; /* size of initialized data in bytes */
+vir_bytes bss_bytes; /* size of bss in bytes */
+vir_bytes stk_bytes; /* size of initial stack segment in bytes */
+phys_bytes tot_bytes; /* total memory to allocate, including gap */
+{
+/* Allocate new memory and release the old memory. Change the map and report
+ * the new map to the kernel. Zero the new core image's bss, gap and stack.
+ */
+
+ register struct mproc *rmp;
+ vir_clicks text_clicks, data_clicks, gap_clicks, stack_clicks, tot_clicks;
+ phys_clicks new_base;
+ static char zero[1024]; /* used to zero bss */
+ phys_bytes bytes, base, count, bss_offset;
+
+ /* No need to allocate text if it can be shared. */
+ if (sh_mp != NULL) text_bytes = 0;
+
+ /* Allow the old data to be swapped out to make room. (Which is really a
+ * waste of time, because we are going to throw it away anyway.)
+ */
+ rmp->mp_flags |= WAITING;
+
+ /* Acquire the new memory. Each of the 4 parts: text, (data+bss), gap,
+ * and stack occupies an integral number of clicks, starting at click
+ * boundary. The data and bss parts are run together with no space.
+ */
+ text_clicks = ((unsigned long) text_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ data_clicks = (data_bytes + bss_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ stack_clicks = (stk_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ tot_clicks = (tot_bytes + CLICK_SIZE - 1) >> CLICK_SHIFT;
+ gap_clicks = tot_clicks - data_clicks - stack_clicks;
+ if ( (int) gap_clicks < 0) return(ENOMEM);
+
+ /* Try to allocate memory for the new process. */
+ new_base = alloc_mem(text_clicks + tot_clicks);
+ if (new_base == NO_MEM) return(ENOMEM);
+
+ /* We've got memory for the new core image. Release the old one. */
+ rmp = mp;
+
+ if (find_share(rmp, rmp->mp_ino, rmp->mp_dev, rmp->mp_ctime) == NULL) {
+ /* No other process shares the text segment, so free it. */
+ free_mem(rmp->mp_seg[T].mem_phys, rmp->mp_seg[T].mem_len);
+ }
+ /* Free the data and stack segments. */
+ free_mem(rmp->mp_seg[D].mem_phys,
+ rmp->mp_seg[S].mem_vir + rmp->mp_seg[S].mem_len - rmp->mp_seg[D].mem_vir);
+
+ /* We have now passed the point of no return. The old core image has been
+ * forever lost, memory for a new core image has been allocated. Set up
+ * and report new map.
+ */
+ if (sh_mp != NULL) {
+ /* Share the text segment. */
+ rmp->mp_seg[T] = sh_mp->mp_seg[T];
+ } else {
+ rmp->mp_seg[T].mem_phys = new_base;
+ rmp->mp_seg[T].mem_vir = 0;
+ rmp->mp_seg[T].mem_len = text_clicks;
+ }
+ rmp->mp_seg[D].mem_phys = new_base + text_clicks;
+ rmp->mp_seg[D].mem_vir = 0;
+ rmp->mp_seg[D].mem_len = data_clicks;
+ rmp->mp_seg[S].mem_phys = rmp->mp_seg[D].mem_phys + data_clicks + gap_clicks;
+ rmp->mp_seg[S].mem_vir = rmp->mp_seg[D].mem_vir + data_clicks + gap_clicks;
+ rmp->mp_seg[S].mem_len = stack_clicks;
+
+#if (CHIP == M68000)
+ rmp->mp_seg[T].mem_vir = 0;
+ rmp->mp_seg[D].mem_vir = rmp->mp_seg[T].mem_len;
+ rmp->mp_seg[S].mem_vir = rmp->mp_seg[D].mem_vir + rmp->mp_seg[D].mem_len + gap_clicks;
+#endif
+
+ sys_newmap(who, rmp->mp_seg); /* report new map to the kernel */
+
+ /* The old memory may have been swapped out, but the new memory is real. */
+ rmp->mp_flags &= ~(WAITING|ONSWAP|SWAPIN);
+
+ /* Zero the bss, gap, and stack segment. */
+ bytes = (phys_bytes)(data_clicks + gap_clicks + stack_clicks) << CLICK_SHIFT;
+ base = (phys_bytes) rmp->mp_seg[D].mem_phys << CLICK_SHIFT;
+ bss_offset = (data_bytes >> CLICK_SHIFT) << CLICK_SHIFT;
+ base += bss_offset;
+ bytes -= bss_offset;
+
+ while (bytes > 0) {
+ count = MIN(bytes, (phys_bytes) sizeof(zero));
+ if (sys_physcopy(PM_PROC_NR, D, (phys_bytes) zero,
+ NONE, PHYS_SEG, base, count) != OK) {
+ panic("new_mem can't zero", NO_NUM);
+ }
+ base += count;
+ bytes -= count;
+ }
+ return(OK);
+}
+
+
+/*===========================================================================*
+ * patch_ptr *
+ *===========================================================================*/
+PRIVATE void patch_ptr(stack, base)
+char stack[ARG_MAX]; /* pointer to stack image within MM */
+vir_bytes base; /* virtual address of stack base inside user */
+{
+/* When doing an exec(name, argv, envp) call, the user builds up a stack
+ * image with arg and env pointers relative to the start of the stack. Now
+ * these pointers must be relocated, since the stack is not positioned at
+ * address 0 in the user's address space.
+ */
+
+ char **ap, flag;
+ vir_bytes v;
+
+ flag = 0; /* counts number of 0-pointers seen */
+ ap = (char **) stack; /* points initially to 'nargs' */
+ ap++; /* now points to argv[0] */
+ while (flag < 2) {
+ if (ap >= (char **) &stack[ARG_MAX]) return; /* too bad */
+ if (*ap != NULL) {
+ v = (vir_bytes) *ap; /* v is relative pointer */
+ v += base; /* relocate it */
+ *ap = (char *) v; /* put it back */
+ } else {
+ flag++;
+ }
+ ap++;
+ }
+}
+
+
+/*===========================================================================*
+ * insert_arg *
+ *===========================================================================*/
+PRIVATE int insert_arg(stack, stk_bytes, arg, replace)
+char stack[ARG_MAX]; /* pointer to stack image within MM */
+vir_bytes *stk_bytes; /* size of initial stack */
+char *arg; /* argument to prepend/replace as new argv[0] */
+int replace;
+{
+/* Patch the stack so that arg will become argv[0]. Be careful, the stack may
+ * be filled with garbage, although it normally looks like this:
+ * nargs argv[0] ... argv[nargs-1] NULL envp[0] ... NULL
+ * followed by the strings "pointed" to by the argv[i] and the envp[i]. The
+ * pointers are really offsets from the start of stack.
+ * Return true iff the operation succeeded.
+ */
+ int offset, a0, a1, old_bytes = *stk_bytes;
+
+ /* Prepending arg adds at least one string and a zero byte. */
+ offset = strlen(arg) + 1;
+
+ a0 = (int) ((char **) stack)[1]; /* argv[0] */
+ if (a0 < 4 * PTRSIZE || a0 >= old_bytes) return(FALSE);
+
+ a1 = a0; /* a1 will point to the strings to be moved */
+ if (replace) {
+ /* Move a1 to the end of argv[0][] (argv[1] if nargs > 1). */
+ do {
+ if (a1 == old_bytes) return(FALSE);
+ --offset;
+ } while (stack[a1++] != 0);
+ } else {
+ offset += PTRSIZE; /* new argv[0] needs new pointer in argv[] */
+ a0 += PTRSIZE; /* location of new argv[0][]. */
+ }
+
+ /* stack will grow by offset bytes (or shrink by -offset bytes) */
+ if ((*stk_bytes += offset) > ARG_MAX) return(FALSE);
+
+ /* Reposition the strings by offset bytes */
+ memmove(stack + a1 + offset, stack + a1, old_bytes - a1);
+
+ strcpy(stack + a0, arg); /* Put arg in the new space. */
+
+ if (!replace) {
+ /* Make space for a new argv[0]. */
+ memmove(stack + 2 * PTRSIZE, stack + 1 * PTRSIZE, a0 - 2 * PTRSIZE);
+
+ ((char **) stack)[0]++; /* nargs++; */
+ }
+ /* Now patch up argv[] and envp[] by offset. */
+ patch_ptr(stack, (vir_bytes) offset);
+ ((char **) stack)[1] = (char *) a0; /* set argv[0] correctly */
+ return(TRUE);
+}
+
+
+/*===========================================================================*
+ * patch_stack *
+ *===========================================================================*/
+PRIVATE char *patch_stack(fd, stack, stk_bytes, script)
+int fd; /* file descriptor to open script file */
+char stack[ARG_MAX]; /* pointer to stack image within MM */
+vir_bytes *stk_bytes; /* size of initial stack */
+char *script; /* name of script to interpret */
+{
+/* Patch the argument vector to include the path name of the script to be
+ * interpreted, and all strings on the #! line. Returns the path name of
+ * the interpreter.
+ */
+ char *sp, *interp = NULL;
+ int n;
+ enum { INSERT=FALSE, REPLACE=TRUE };
+
+ /* Make script[] the new argv[0]. */
+ if (!insert_arg(stack, stk_bytes, script, REPLACE)) return(NULL);
+
+ if (lseek(fd, 2L, 0) == -1 /* just behind the #! */
+ || (n= read(fd, script, PATH_MAX)) < 0 /* read line one */
+ || (sp= memchr(script, '\n', n)) == NULL) /* must be a proper line */
+ return(NULL);
+
+ /* Move sp backwards through script[], prepending each string to stack. */
+ for (;;) {
+ /* skip spaces behind argument. */
+ while (sp > script && (*--sp == ' ' || *sp == '\t')) {}
+ if (sp == script) break;
+
+ sp[1] = 0;
+ /* Move to the start of the argument. */
+ while (sp > script && sp[-1] != ' ' && sp[-1] != '\t') --sp;
+
+ interp = sp;
+ if (!insert_arg(stack, stk_bytes, sp, INSERT)) return(NULL);
+ }
+
+ /* Round *stk_bytes up to the size of a pointer for alignment contraints. */
+ *stk_bytes= ((*stk_bytes + PTRSIZE - 1) / PTRSIZE) * PTRSIZE;
+
+ close(fd);
+ return(interp);
+}
+
+
+/*===========================================================================*
+ * rw_seg *
+ *===========================================================================*/
+PUBLIC void rw_seg(rw, fd, proc, seg, seg_bytes0)
+int rw; /* 0 = read, 1 = write */
+int fd; /* file descriptor to read from / write to */
+int proc; /* process number */
+int seg; /* T, D, or S */
+phys_bytes seg_bytes0; /* how much is to be transferred? */
+{
+/* Transfer text or data from/to a file and copy to/from a process segment.
+ * This procedure is a little bit tricky. The logical way to transfer a
+ * segment would be block by block and copying each block to/from the user
+ * space one at a time. This is too slow, so we do something dirty here,
+ * namely send the user space and virtual address to the file system in the
+ * upper 10 bits of the file descriptor, and pass it the user virtual address
+ * instead of a MM address. The file system extracts these parameters when
+ * gets a read or write call from the memory manager, which is the only process
+ * that is permitted to use this trick. The file system then copies the whole
+ * segment directly to/from user space, bypassing MM completely.
+ *
+ * The byte count on read is usually smaller than the segment count, because
+ * a segment is padded out to a click multiple, and the data segment is only
+ * partially initialized.
+ */
+
+ int new_fd, bytes, r;
+ char *ubuf_ptr;
+ struct mem_map *sp = &mproc[proc].mp_seg[seg];
+ phys_bytes seg_bytes = seg_bytes0;
+
+ new_fd = (proc << 7) | (seg << 5) | fd;
+ ubuf_ptr = (char *) ((vir_bytes) sp->mem_vir << CLICK_SHIFT);
+
+ while (seg_bytes != 0) {
+#define MM_CHUNK_SIZE 8192
+ bytes = MIN((INT_MAX / MM_CHUNK_SIZE) * MM_CHUNK_SIZE, seg_bytes);
+ if (rw == 0) {
+ r = read(new_fd, ubuf_ptr, bytes);
+ } else {
+ r = write(new_fd, ubuf_ptr, bytes);
+ }
+ if (r != bytes) break;
+ ubuf_ptr += bytes;
+ seg_bytes -= bytes;
+ }
+}
+
+
+/*===========================================================================*
+ * find_share *
+ *===========================================================================*/
+PUBLIC struct mproc *find_share(mp_ign, ino, dev, ctime)
+struct mproc *mp_ign; /* process that should not be looked at */
+ino_t ino; /* parameters that uniquely identify a file */
+dev_t dev;
+time_t ctime;
+{
+/* Look for a process that is the file <ino, dev, ctime> in execution. Don't
+ * accidentally "find" mp_ign, because it is the process on whose behalf this
+ * call is made.
+ */
+ struct mproc *sh_mp;
+
+ for (sh_mp = &mproc[INIT_PROC_NR]; sh_mp < &mproc[NR_PROCS]; sh_mp++) {
+ if (!(sh_mp->mp_flags & SEPARATE)) continue;
+ if (sh_mp == mp_ign) continue;
+ if (sh_mp->mp_ino != ino) continue;
+ if (sh_mp->mp_dev != dev) continue;
+ if (sh_mp->mp_ctime != ctime) continue;
+ return sh_mp;
+ }
+ return(NULL);
+}
--- /dev/null
+/* This file deals with creating processes (via FORK) and deleting them (via
+ * EXIT/WAIT). When a process forks, a new slot in the 'mproc' table is
+ * allocated for it, and a copy of the parent's core image is made for the
+ * child. Then the kernel and file system are informed. A process is removed
+ * from the 'mproc' table when two events have occurred: (1) it has exited or
+ * been killed by a signal, and (2) the parent has done a WAIT. If the process
+ * exits first, it continues to occupy a slot until the parent does a WAIT.
+ *
+ * The entry points into this file are:
+ * do_fork: perform the FORK system call
+ * do_mm_exit: perform the EXIT system call (by calling mm_exit())
+ * mm_exit: actually do the exiting
+ * do_wait: perform the WAITPID or WAIT system call
+ */
+
+
+#include "mm.h"
+#include <sys/wait.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <minix/utils.h>
+#include <signal.h>
+#include "mproc.h"
+#include "param.h"
+
+#define LAST_FEW 2 /* last few slots reserved for superuser */
+
+PRIVATE pid_t next_pid = INIT_PID+1; /* next pid to be assigned */
+
+FORWARD _PROTOTYPE (void cleanup, (register struct mproc *child) );
+
+/*===========================================================================*
+ * do_fork *
+ *===========================================================================*/
+PUBLIC int do_fork()
+{
+/* The process pointed to by 'mp' has forked. Create a child process. */
+
+ register struct mproc *rmp; /* pointer to parent */
+ register struct mproc *rmc; /* pointer to child */
+ int i, child_nr, t;
+ phys_clicks prog_clicks, child_base;
+ phys_bytes prog_bytes, parent_abs, child_abs; /* Intel only */
+
+ /* If tables might fill up during FORK, don't even start since recovery half
+ * way through is such a nuisance.
+ */
+ rmp = mp;
+ if ((procs_in_use == NR_PROCS) ||
+ (procs_in_use >= NR_PROCS-LAST_FEW && rmp->mp_effuid != 0))
+ {
+ printf("MM: proc table full!\n");
+ return(EAGAIN);
+ }
+
+ /* Determine how much memory to allocate. Only the data and stack need to
+ * be copied, because the text segment is either shared or of zero length.
+ */
+ prog_clicks = (phys_clicks) rmp->mp_seg[S].mem_len;
+ prog_clicks += (rmp->mp_seg[S].mem_vir - rmp->mp_seg[D].mem_vir);
+ prog_bytes = (phys_bytes) prog_clicks << CLICK_SHIFT;
+ if ( (child_base = alloc_mem(prog_clicks)) == NO_MEM) return(ENOMEM);
+
+ /* Create a copy of the parent's core image for the child. */
+ child_abs = (phys_bytes) child_base << CLICK_SHIFT;
+ parent_abs = (phys_bytes) rmp->mp_seg[D].mem_phys << CLICK_SHIFT;
+ i = sys_abscopy(parent_abs, child_abs, prog_bytes);
+ if (i < 0) panic("do_fork can't copy", i);
+
+ /* Find a slot in 'mproc' for the child process. A slot must exist. */
+ for (rmc = &mproc[0]; rmc < &mproc[NR_PROCS]; rmc++)
+ if ( (rmc->mp_flags & IN_USE) == 0) break;
+
+ /* Set up the child and its memory map; copy its 'mproc' slot from parent. */
+ child_nr = (int)(rmc - mproc); /* slot number of the child */
+ procs_in_use++;
+ *rmc = *rmp; /* copy parent's process slot to child's */
+
+ rmc->mp_parent = who; /* record child's parent */
+ rmc->mp_flags &= (IN_USE|SEPARATE); /* inherit only these flags */
+
+ /* A separate I&D child keeps the parents text segment. The data and stack
+ * segments must refer to the new copy.
+ */
+ if (!(rmc->mp_flags & SEPARATE)) rmc->mp_seg[T].mem_phys = child_base;
+ rmc->mp_seg[D].mem_phys = child_base;
+ rmc->mp_seg[S].mem_phys = rmc->mp_seg[D].mem_phys +
+ (rmp->mp_seg[S].mem_vir - rmp->mp_seg[D].mem_vir);
+ rmc->mp_exitstatus = 0;
+ rmc->mp_sigstatus = 0;
+
+ /* Find a free pid for the child and put it in the table. */
+ do {
+ t = 0; /* 't' = 0 means pid still free */
+ next_pid = (next_pid < 30000 ? next_pid + 1 : INIT_PID + 1);
+ for (rmp = &mproc[0]; rmp < &mproc[NR_PROCS]; rmp++)
+ if (rmp->mp_pid == next_pid || rmp->mp_procgrp == next_pid) {
+ t = 1;
+ break;
+ }
+ rmc->mp_pid = next_pid; /* assign pid to child */
+ } while (t);
+
+ /* Tell kernel and file system about the (now successful) FORK. */
+ sys_fork(who, child_nr, rmc->mp_pid);
+ tell_fs(FORK, who, child_nr, rmc->mp_pid);
+
+ /* Report child's memory map to kernel. */
+ sys_newmap(child_nr, rmc->mp_seg);
+
+ /* Reply to child to wake it up. */
+ setreply(child_nr, 0);
+ return(next_pid); /* child's pid */
+}
+
+
+/*===========================================================================*
+ * do_mm_exit *
+ *===========================================================================*/
+PUBLIC int do_mm_exit()
+{
+/* Perform the exit(status) system call. The real work is done by mm_exit(),
+ * which is also called when a process is killed by a signal.
+ */
+
+ mm_exit(mp, m_in.status);
+ return(SUSPEND); /* can't communicate from beyond the grave */
+}
+
+
+/*===========================================================================*
+ * mm_exit *
+ *===========================================================================*/
+PUBLIC void mm_exit(rmp, exit_status)
+register struct mproc *rmp; /* pointer to the process to be terminated */
+int exit_status; /* the process' exit status (for parent) */
+{
+/* A process is done. Release most of the process' possessions. If its
+ * parent is waiting, release the rest, else keep the process slot and
+ * become a zombie.
+ */
+
+ register int proc_nr;
+ int parent_waiting, right_child;
+ pid_t pidarg, procgrp;
+ struct mproc *p_mp;
+
+ proc_nr = (int) (rmp - mproc); /* get process slot number */
+
+ /* Remember a session leader's process group. */
+ procgrp = (rmp->mp_pid == mp->mp_procgrp) ? mp->mp_procgrp : 0;
+
+ /* If the exited process has a timer pending, kill it. */
+ if (rmp->mp_flags & ALARM_ON) set_alarm(proc_nr, (unsigned) 0);
+
+ /* Tell the kernel and FS that the process is no longer runnable. */
+ tell_fs(EXIT, proc_nr, 0, 0); /* file system can free the proc slot */
+ sys_xit(rmp->mp_parent, proc_nr);
+
+ /* Release the memory occupied by the child. */
+ if (find_share(rmp, rmp->mp_ino, rmp->mp_dev, rmp->mp_ctime) == NULL) {
+ /* No other process shares the text segment, so free it. */
+ free_mem(rmp->mp_seg[T].mem_phys, rmp->mp_seg[T].mem_len);
+ }
+ /* Free the data and stack segments. */
+ free_mem(rmp->mp_seg[D].mem_phys,
+ rmp->mp_seg[S].mem_vir + rmp->mp_seg[S].mem_len - rmp->mp_seg[D].mem_vir);
+
+ /* The process slot can only be freed if the parent has done a WAIT. */
+ rmp->mp_exitstatus = (char) exit_status;
+
+ p_mp = &mproc[rmp->mp_parent]; /* process' parent */
+ pidarg = p_mp->mp_wpid; /* who's being waited for? */
+ parent_waiting = p_mp->mp_flags & WAITING;
+
+ right_child = /* child meets one of the 3 tests? */
+ (pidarg == -1 || pidarg == rmp->mp_pid || -pidarg == rmp->mp_procgrp);
+
+ if (parent_waiting && right_child) {
+ cleanup(rmp); /* tell parent and release child slot */
+ } else {
+ rmp->mp_flags = IN_USE|ZOMBIE; /* parent not waiting, zombify child */
+ sig_proc(p_mp, SIGCHLD); /* send parent a "child died" signal */
+ }
+
+ /* If the process has children, disinherit them. INIT is the new parent. */
+ for (rmp = &mproc[0]; rmp < &mproc[NR_PROCS]; rmp++) {
+ if (rmp->mp_flags & IN_USE && rmp->mp_parent == proc_nr) {
+ /* 'rmp' now points to a child to be disinherited. */
+ rmp->mp_parent = INIT_PROC_NR;
+ parent_waiting = mproc[INIT_PROC_NR].mp_flags & WAITING;
+ if (parent_waiting && (rmp->mp_flags & ZOMBIE)) cleanup(rmp);
+ }
+ }
+
+ /* Send a hangup to the process' process group if it was a session leader. */
+ if (procgrp != 0) check_sig(-procgrp, SIGHUP);
+}
+
+
+/*===========================================================================*
+ * do_waitpid *
+ *===========================================================================*/
+PUBLIC int do_waitpid()
+{
+/* A process wants to wait for a child to terminate. If one is already waiting,
+ * go clean it up and let this WAIT call terminate. Otherwise, really wait.
+ * Both WAIT and WAITPID are handled by this code.
+ */
+
+ register struct mproc *rp;
+ int pidarg, options, children;
+
+ /* A process calling WAIT never gets a reply in the usual way at the end
+ * of the main loop (unless WNOHANG is set or no qualifying child exists).
+ * If a child has already exited, the routine cleanup() sends the reply
+ * to awaken the caller.
+ */
+
+ /* Set internal variables, depending on whether this is WAIT or WAITPID. */
+ pidarg = (call_nr == WAIT ? -1 : m_in.pid); /* 1st param of waitpid */
+ options = (call_nr == WAIT ? 0 : m_in.sig_nr); /* 3rd param of waitpid */
+ if (pidarg == 0) pidarg = -mp->mp_procgrp; /* pidarg < 0 ==> proc grp */
+
+ /* Is there a child waiting to be collected? At this point, pidarg != 0:
+ * pidarg > 0 means pidarg is pid of a specific process to wait for
+ * pidarg == -1 means wait for any child
+ * pidarg < -1 means wait for any child whose process group = -pidarg
+ */
+ children = 0;
+ for (rp = &mproc[0]; rp < &mproc[NR_PROCS]; rp++) {
+ if ( (rp->mp_flags & IN_USE) && rp->mp_parent == who) {
+ /* The value of pidarg determines which children qualify. */
+ if (pidarg > 0 && pidarg != rp->mp_pid) continue;
+ if (pidarg < -1 && -pidarg != rp->mp_procgrp) continue;
+
+ children++; /* this child is acceptable */
+ if (rp->mp_flags & ZOMBIE) {
+ /* This child meets the pid test and has exited. */
+ cleanup(rp); /* this child has already exited */
+ return(SUSPEND);
+ }
+ if ((rp->mp_flags & STOPPED) && rp->mp_sigstatus) {
+ /* This child meets the pid test and is being traced.*/
+ mp->mp_reply.reply_res2 = 0177|(rp->mp_sigstatus << 8);
+ rp->mp_sigstatus = 0;
+ return(rp->mp_pid);
+ }
+ }
+ }
+
+ /* No qualifying child has exited. Wait for one, unless none exists. */
+ if (children > 0) {
+ /* At least 1 child meets the pid test exists, but has not exited. */
+ if (options & WNOHANG) return(0); /* parent does not want to wait */
+ mp->mp_flags |= WAITING; /* parent wants to wait */
+ mp->mp_wpid = (pid_t) pidarg; /* save pid for later */
+ return(SUSPEND); /* do not reply, let it wait */
+ } else {
+ /* No child even meets the pid test. Return error immediately. */
+ return(ECHILD); /* no - parent has no children */
+ }
+}
+
+
+/*===========================================================================*
+ * cleanup *
+ *===========================================================================*/
+PRIVATE void cleanup(child)
+register struct mproc *child; /* tells which process is exiting */
+{
+/* Finish off the exit of a process. The process has exited or been killed
+ * by a signal, and its parent is waiting.
+ */
+
+ struct mproc *parent = &mproc[child->mp_parent];
+ int exitstatus;
+
+ /* Wake up the parent. */
+ exitstatus = (child->mp_exitstatus << 8) | (child->mp_sigstatus & 0377);
+ parent->mp_reply.reply_res2 = exitstatus;
+ setreply(child->mp_parent, child->mp_pid);
+ parent->mp_flags &= ~WAITING; /* parent no longer waiting */
+
+ /* Release the process table entry. */
+ child->mp_flags = 0;
+ procs_in_use--;
+}
--- /dev/null
+/* This file handles the 4 system calls that get and set uids and gids.
+ * It also handles getpid(), setsid(), and getpgrp(). The code for each
+ * one is so tiny that it hardly seemed worthwhile to make each a separate
+ * function.
+ */
+
+#include "mm.h"
+#include <minix/callnr.h>
+#include <signal.h>
+#include "mproc.h"
+#include "param.h"
+
+/*===========================================================================*
+ * do_getset *
+ *===========================================================================*/
+PUBLIC int do_getset()
+{
+/* Handle GETUID, GETGID, GETPID, GETPGRP, SETUID, SETGID, SETSID. The four
+ * GETs and SETSID return their primary results in 'r'. GETUID, GETGID, and
+ * GETPID also return secondary results (the effective IDs, or the parent
+ * process ID) in 'reply_res2', which is returned to the user.
+ */
+
+ register struct mproc *rmp = mp;
+ register int r;
+
+ switch(call_nr) {
+ case GETUID:
+ r = rmp->mp_realuid;
+ rmp->mp_reply.reply_res2 = rmp->mp_effuid;
+ break;
+
+ case GETGID:
+ r = rmp->mp_realgid;
+ rmp->mp_reply.reply_res2 = rmp->mp_effgid;
+ break;
+
+ case GETPID:
+ r = mproc[who].mp_pid;
+ rmp->mp_reply.reply_res2 = mproc[rmp->mp_parent].mp_pid;
+ break;
+
+ case SETUID:
+ if (rmp->mp_realuid != (uid_t) m_in.usr_id &&
+ rmp->mp_effuid != SUPER_USER)
+ return(EPERM);
+ rmp->mp_realuid = (uid_t) m_in.usr_id;
+ rmp->mp_effuid = (uid_t) m_in.usr_id;
+ tell_fs(SETUID, who, rmp->mp_realuid, rmp->mp_effuid);
+ r = OK;
+ break;
+
+ case SETGID:
+ if (rmp->mp_realgid != (gid_t) m_in.grp_id &&
+ rmp->mp_effuid != SUPER_USER)
+ return(EPERM);
+ rmp->mp_realgid = (gid_t) m_in.grp_id;
+ rmp->mp_effgid = (gid_t) m_in.grp_id;
+ tell_fs(SETGID, who, rmp->mp_realgid, rmp->mp_effgid);
+ r = OK;
+ break;
+
+ case SETSID:
+ if (rmp->mp_procgrp == rmp->mp_pid) return(EPERM);
+ rmp->mp_procgrp = rmp->mp_pid;
+ tell_fs(SETSID, who, 0, 0);
+ /*FALL THROUGH*/
+
+ case GETPGRP:
+ r = rmp->mp_procgrp;
+ break;
+
+ default:
+ r = EINVAL;
+ break;
+ }
+ return(r);
+}
--- /dev/null
+/* EXTERN should be extern except in table.c */
+#ifdef _TABLE
+#undef EXTERN
+#define EXTERN
+#endif
+
+/* Global variables. */
+EXTERN struct mproc *mp; /* ptr to 'mproc' slot of current process */
+EXTERN int procs_in_use; /* how many processes are marked as IN_USE */
+
+/* The parameters of the call are kept here. */
+EXTERN message m_in; /* the incoming message itself is kept here. */
+EXTERN int who; /* caller's proc number */
+EXTERN int call_nr; /* system call number */
+
+extern _PROTOTYPE (int (*call_vec[]), (void) ); /* system call handlers */
+extern char core_name[]; /* file name where core images are produced */
+EXTERN sigset_t core_sset; /* which signals cause core images */
+EXTERN sigset_t ign_sset; /* which signals are by default ignored */
+
--- /dev/null
+/* This file contains the main program of the memory 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 MM and FS. Both MM
+ * and FS initialize themselves as far as they can. FS then makes a call to
+ * MM, because MM has to wait for FS to acquire a RAM disk. MM asks the
+ * kernel for all free memory and starts serving requests.
+ *
+ * The entry points into this file are:
+ * main: starts MM running
+ * setreply: set the reply to be sent to process making an MM system call
+ */
+
+#include "mm.h"
+#include <minix/utils.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <sys/ioc_memory.h>
+#include "mproc.h"
+#include "param.h"
+
+FORWARD _PROTOTYPE( void get_work, (void) );
+FORWARD _PROTOTYPE( void mm_init, (void) );
+
+#define click_to_round_k(n) \
+ ((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
+
+/*===========================================================================*
+ * main *
+ *===========================================================================*/
+PUBLIC void main()
+{
+/* Main routine of the memory manager. */
+
+ int result, proc_nr;
+ struct mproc *rmp;
+
+ mm_init(); /* initialize memory manager tables */
+
+ /* This is MM's main loop- get work and do it, forever and forever. */
+ while (TRUE) {
+ get_work(); /* wait for an MM 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 == 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 (send(proc_nr, &rmp->mp_reply) != OK)
+ panic("MM 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("MM 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 MM'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 the 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 */
+}
+
+
+/*===========================================================================*
+ * mm_init *
+ *===========================================================================*/
+PRIVATE void mm_init()
+{
+/* Initialize the memory manager. */
+ int s;
+ 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=p_getmap(SYSTASK, kernel_map)) != OK)
+ panic("MM 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 MM's tables. Request a copy of the system image table that
+ * is defined at the kernel level to see which slots to fill in.
+ */
+ for (proc_nr = 0; proc_nr <= INIT_PROC_NR; proc_nr++) {
+ rmp = &mproc[proc_nr];
+ rmp->mp_flags |= IN_USE;
+ if ((s=p_getmap(proc_nr, rmp->mp_seg)) != OK)
+ panic("MM couldn't get proc 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;
+ }
+ mproc[INIT_PROC_NR].mp_pid = INIT_PID;
+ sigemptyset(&mproc[INIT_PROC_NR].mp_ignore);
+ sigemptyset(&mproc[INIT_PROC_NR].mp_catch);
+ procs_in_use = LOW_USER + 1;
+
+ /* Wait for FS to send a message telling the RAM disk size then go "on-line".
+ */
+ if (receive(FS_PROC_NR, &mess) != OK)
+ panic("MM can't obtain RAM disk size from FS", NO_NUM);
+
+ ram_clicks = mess.MEM_CHUNK_SIZE;
+
+ /* Initialize tables to all physical mem. */
+ mem_init(&free_clicks);
+ total_clicks = minix_clicks + ram_clicks + free_clicks;
+
+ /* Print memory information. */
+ printf("Memory size=%uK ", click_to_round_k(total_clicks));
+ printf("MINIX=%uK ", click_to_round_k(minix_clicks));
+ printf("RAM disk=%uK ", click_to_round_k(ram_clicks));
+ printf("Available=%uK\n\n", click_to_round_k(free_clicks));
+
+ /* Tell FS to continue. */
+ if (send(FS_PROC_NR, &mess) != OK)
+ panic("MM can't sync up with FS", NO_NUM);
+
+ /* Tell the memory task where my process table is for the sake of ps(1). */
+ if ((mem = open("/dev/ram", O_RDWR)) != -1) {
+ ioctl(mem, MIOCSPSINFO, (void *) mproc);
+ close(mem);
+ }
+}
--- /dev/null
+/* Miscellaneous system calls. Author: Kees J. Bot
+ * 31 Mar 2000
+ * The entry points into this file are:
+ * do_reboot: kill all processes, then reboot system
+ * do_svrctl: memory manager control
+ * do_getsysinfo: request copy of MM data structure
+ */
+
+#include "mm.h"
+#include <minix/callnr.h>
+#include <signal.h>
+#include <sys/svrctl.h>
+#include <minix/com.h>
+#include <minix/utils.h>
+#include <string.h>
+#include "mproc.h"
+#include "param.h"
+
+FORWARD _PROTOTYPE( char *find_key, (const char *params, const char *key));
+
+/* MM gets a copy of all boot monitor parameters. */
+PRIVATE char monitor_params[128*sizeof(char *)];
+
+/*=====================================================================*
+ * do_getsysinfo *
+ *=====================================================================*/
+PUBLIC int do_getsysinfo()
+{
+ return(OK);
+}
+
+
+/*=====================================================================*
+ * do_reboot *
+ *=====================================================================*/
+PUBLIC int do_reboot()
+{
+ register struct mproc *rmp = mp;
+ char monitor_code[32*sizeof(char *)];
+
+ if (rmp->mp_effuid != SUPER_USER) return(EPERM);
+
+ switch (m_in.reboot_flag) {
+ case RBT_HALT:
+ case RBT_REBOOT:
+ case RBT_PANIC:
+ case RBT_RESET:
+ break;
+ case RBT_MONITOR:
+ if (m_in.reboot_size >= sizeof(monitor_code)) return(EINVAL);
+ if (sys_datacopy(who, (vir_bytes) m_in.reboot_code,
+ PM_PROC_NR, (vir_bytes) monitor_code,
+ (phys_bytes) (m_in.reboot_size+1)) != OK) return(EFAULT);
+ if (monitor_code[m_in.reboot_size] != 0) return(EINVAL);
+ break;
+ default:
+ return(EINVAL);
+ }
+
+ check_sig(-1, SIGKILL); /* kill all processes except init */
+ tell_fs(REBOOT,0,0,0); /* tell FS to prepare for shutdown */
+
+ sys_abort(m_in.reboot_flag, PM_PROC_NR, monitor_code, m_in.reboot_size);
+ sys_exit(0);
+}
+
+/*=====================================================================*
+ * do_svrctl *
+ *=====================================================================*/
+PUBLIC int do_svrctl()
+{
+ static int initialized = 0;
+ int s, req;
+ vir_bytes ptr;
+ req = m_in.svrctl_req;
+ ptr = (vir_bytes) m_in.svrctl_argp;
+
+ /* Initialize private copy of monitor parameters on first call. */
+ if (! initialized) {
+ if ((s=sys_getmonparams(monitor_params, sizeof(monitor_params))) != OK)
+ printf("MM: Warning couldn't get copy of monitor params: %d\n",s);
+ else
+ initialized = 1;
+ }
+
+ /* Binary compatibility check. */
+ if (req == SYSGETENV) {
+#if DEAD_CODE
+ printf("SYSGETENV by %d (fix!)\n", who);
+#endif
+ req = MMGETPARAM;
+ }
+
+ /* Is the request for the kernel? Forward it, except for SYSGETENV. */
+ if (((req >> 8) & 0xFF) == 'S') {
+
+ /* Simply forward call to the SYSTEM task. */
+ return(sys_svrctl(who, req, mp->mp_effuid == SUPER_USER, ptr));
+ }
+
+ /* Control operations local to the MM. */
+ switch(req) {
+ case MMGETPARAM: {
+ struct sysgetenv sysgetenv;
+ char search_key[64];
+ char *val_start;
+ size_t val_len;
+ size_t copy_len;
+
+ /* Check if boot monitor parameters are in place. */
+ if (! initialized) return(EAGAIN);
+
+ /* Copy sysgetenv structure to MM. */
+ if (sys_datacopy(who, ptr, SELF, (vir_bytes) &sysgetenv,
+ sizeof(sysgetenv)) != OK) return(EFAULT);
+
+ if (sysgetenv.keylen == 0) { /* copy all parameters */
+ val_start = monitor_params;
+ val_len = sizeof(monitor_params);
+ }
+ else { /* lookup value for key */
+ /* Try to get a copy of the requested key. */
+ if (sysgetenv.keylen > sizeof(search_key)) return(EINVAL);
+ if ((s = sys_datacopy(who, (vir_bytes) sysgetenv.key,
+ SELF, (vir_bytes) search_key, sysgetenv.keylen)) != OK)
+ return(s);
+
+ /* Make sure key is null-terminated and lookup value. */
+ search_key[sysgetenv.keylen-1]= '\0';
+ if ((val_start = find_key(monitor_params, search_key)) == NULL)
+ return(ESRCH);
+ val_len = strlen(val_start) + 1;
+ }
+
+ /* Value found, make the actual copy (as far as possible). */
+ copy_len = MAX(val_len, sysgetenv.vallen);
+ if ((s=sys_datacopy(SELF, (vir_bytes) val_start,
+ who, (vir_bytes) sysgetenv.val, copy_len)) != OK)
+ return(s);
+
+ /* See if it fits in the client's buffer. */
+ return (copy_len > sysgetenv.vallen) ? E2BIG : OK;
+ }
+ case MMSIGNON: {
+ /* A user process becomes a task. Simulate an exit by
+ * releasing a waiting parent and disinheriting children.
+ */
+ struct mproc *rmp;
+ pid_t pidarg;
+
+ if (mp->mp_effuid != SUPER_USER) return(EPERM);
+
+ rmp = &mproc[mp->mp_parent];
+ tell_fs(EXIT, who, 0, 0);
+
+ pidarg = rmp->mp_wpid;
+ if ((rmp->mp_flags & WAITING) && (pidarg == -1
+ || pidarg == mp->mp_pid || -pidarg == mp->mp_procgrp))
+ {
+ /* Wake up the parent. */
+ rmp->mp_reply.reply_res2 = 0;
+ setreply(mp->mp_parent, mp->mp_pid);
+ rmp->mp_flags &= ~WAITING;
+ }
+
+ /* Disinherit children. */
+ for (rmp = &mproc[0]; rmp < &mproc[NR_PROCS]; rmp++) {
+ if (rmp->mp_flags & IN_USE && rmp->mp_parent == who) {
+ rmp->mp_parent = INIT_PROC_NR;
+ }
+ }
+
+ /* Become like MM and FS. */
+ mp->mp_pid = mp->mp_procgrp = 0;
+ mp->mp_parent = 0;
+ return(OK); }
+
+#if ENABLE_SWAP
+ case MMSWAPON: {
+ struct mmswapon swapon;
+
+ if (mp->mp_effuid != SUPER_USER) return(EPERM);
+
+ if (sys_datacopy(who, (phys_bytes) ptr,
+ PM_PROC_NR, (phys_bytes) &swapon,
+ (phys_bytes) sizeof(swapon)) != OK) return(EFAULT);
+
+ return(swap_on(swapon.file, swapon.offset, swapon.size)); }
+
+ case MMSWAPOFF: {
+ if (mp->mp_effuid != SUPER_USER) return(EPERM);
+
+ return(swap_off()); }
+#endif /* SWAP */
+
+ default:
+ return(EINVAL);
+ }
+}
+
+/*==========================================================================*
+ * find_key *
+ *==========================================================================*/
+PRIVATE char *find_key(params,name)
+const char *params;
+const char *name;
+{
+ register const char *namep;
+ register char *envp;
+
+ for (envp = (char *) params; *envp != 0;) {
+ for (namep = name; *namep != 0 && *namep == *envp; namep++, envp++)
+ ;
+ if (*namep == '\0' && *envp == '=')
+ return(envp + 1);
+ while (*envp++ != 0)
+ ;
+ }
+ return(NULL);
+}
+
--- /dev/null
+/* This is the master header for mm. It includes some other files
+ * and defines the principal constants.
+ */
+#define _POSIX_SOURCE 1 /* tell headers to include POSIX stuff */
+#define _MINIX 1 /* tell headers to include MINIX stuff */
+#define _SYSTEM 1 /* tell headers that this is the kernel */
+
+/* The following are so basic, all the *.c files get them automatically. */
+#include <minix/config.h> /* MUST be first */
+#include <ansi.h> /* MUST be second */
+#include <sys/types.h>
+#include <minix/const.h>
+#include <minix/type.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+#include <minix/syslib.h>
+
+#include <limits.h>
+#include <errno.h>
+
+#include "const.h"
+#include "type.h"
+#include "proto.h"
+#include "glo.h"
--- /dev/null
+/* This table has one slot per process. It contains all the memory management
+ * information for each process. Among other things, it defines the text, data
+ * and stack segments, uids and gids, and various flags. The kernel and file
+ * systems have tables that are also indexed by process, with the contents
+ * of corresponding slots referring to the same process in all three.
+ */
+
+EXTERN struct mproc {
+ struct mem_map mp_seg[NR_LOCAL_SEGS]; /* points to text, data, stack */
+ char mp_exitstatus; /* storage for status when process exits */
+ char mp_sigstatus; /* storage for signal # for killed procs */
+ pid_t mp_pid; /* process id */
+ pid_t mp_procgrp; /* pid of process group (used for signals) */
+ pid_t mp_wpid; /* pid this process is waiting for */
+ int mp_parent; /* index of parent process */
+
+ /* Real and effective uids and gids. */
+ uid_t mp_realuid; /* process' real uid */
+ uid_t mp_effuid; /* process' effective uid */
+ gid_t mp_realgid; /* process' real gid */
+ gid_t mp_effgid; /* process' effective gid */
+
+ /* File identification for sharing. */
+ ino_t mp_ino; /* inode number of file */
+ dev_t mp_dev; /* device number of file system */
+ time_t mp_ctime; /* inode changed time */
+
+ /* Signal handling information. */
+ sigset_t mp_ignore; /* 1 means ignore the signal, 0 means don't */
+ sigset_t mp_catch; /* 1 means catch the signal, 0 means don't */
+ sigset_t mp_sigmask; /* signals to be blocked */
+ sigset_t mp_sigmask2; /* saved copy of mp_sigmask */
+ sigset_t mp_sigpending; /* signals being blocked */
+ struct sigaction mp_sigact[_NSIG + 1]; /* as in sigaction(2) */
+ vir_bytes mp_sigreturn; /* address of C library __sigreturn function */
+
+ /* Backwards compatibility for signals. */
+ sighandler_t mp_func; /* all sigs vectored to a single user fcn */
+
+ unsigned mp_flags; /* flag bits */
+ vir_bytes mp_procargs; /* ptr to proc's initial stack arguments */
+ struct mproc *mp_swapq; /* queue of procs waiting to be swapped in */
+ message mp_reply; /* reply message to be sent to one */
+
+ char mp_name[PROC_NAME_LEN]; /* process name */
+} mproc[NR_PROCS];
+
+/* Flag values */
+#define IN_USE 0x001 /* set when 'mproc' slot in use */
+#define WAITING 0x002 /* set by WAIT system call */
+#define ZOMBIE 0x004 /* set by EXIT, cleared by WAIT */
+#define PAUSED 0x008 /* set by PAUSE system call */
+#define ALARM_ON 0x010 /* set when SIGALRM timer started */
+#define SEPARATE 0x020 /* set if file is separate I & D space */
+#define TRACED 0x040 /* set if process is to be traced */
+#define STOPPED 0x080 /* set if process stopped for tracing */
+#define SIGSUSPENDED 0x100 /* set by SIGSUSPEND system call */
+#define REPLY 0x200 /* set if a reply message is pending */
+#define ONSWAP 0x400 /* set if data segment is swapped out */
+#define SWAPIN 0x800 /* set if on the "swap this in" queue */
+
+#define NIL_MPROC ((struct mproc *) 0)
--- /dev/null
+/* The following names are synonyms for the variables in the input message. */
+#define addr m1_p1
+#define exec_name m1_p1
+#define exec_len m1_i1
+#define func m6_f1
+#define grp_id m1_i1
+#define namelen m1_i1
+#define pid m1_i1
+#define seconds m1_i1
+#define sig m6_i1
+#define stack_bytes m1_i2
+#define stack_ptr m1_p2
+#define status m1_i1
+#define usr_id m1_i1
+#define request m2_i2
+#define taddr m2_l1
+#define data m2_l2
+#define sig_nr m1_i2
+#define sig_nsa m1_p1
+#define sig_osa m1_p2
+#define sig_ret m1_p3
+#define sig_set m2_l1
+#define sig_how m2_i1
+#define sig_flags m2_i2
+#define sig_context m2_p1
+#ifdef _SIGMESSAGE
+#define sig_msg m1_i1
+#endif
+#define reboot_flag m1_i1
+#define reboot_code m1_p1
+#define reboot_size m1_i2
+#define svrctl_req m2_i1
+#define svrctl_argp m2_p1
+
+/* The following names are synonyms for the variables in a reply message. */
+#define reply_res m_type
+#define reply_res2 m2_i1
+#define reply_ptr m2_p1
+#define reply_mask m2_l1
+#define reply_trace m2_l2
+
+/* The following names are used to inform the FS about certain events. */
+#define tell_fs_arg1 m1_i1
+#define tell_fs_arg2 m1_i2
+#define tell_fs_arg3 m1_i3
+
--- /dev/null
+#include "mm.h"
+#include <minix/config.h>
+#include <timers.h>
+#include <string.h>
+#include "../../kernel/const.h"
+#include "../../kernel/type.h"
+#include "../../kernel/proc.h"
+
+/* The entry points into this file are:
+ * p_getmap: get memory map of given process
+ * p_getsp: get stack pointer of given process
+ */
+
+/*===========================================================================*
+ * p_getmap *
+ *===========================================================================*/
+PUBLIC int p_getmap(proc_nr, mem_map)
+int proc_nr; /* process to get map of */
+struct mem_map *mem_map; /* put memory map here */
+{
+ struct proc p;
+ int s;
+
+ if ((s=sys_getproc(&p, proc_nr)) != OK)
+ return(s);
+ memcpy(mem_map, p.p_memmap, sizeof(p.p_memmap));
+ return(OK);
+}
+
+/*===========================================================================*
+ * p_getsp *
+ *===========================================================================*/
+PUBLIC int p_getsp(proc_nr, sp)
+int proc_nr; /* process to get sp of */
+vir_bytes *sp; /* put stack pointer here */
+{
+ struct proc p;
+ int s;
+
+ if ((s=sys_getproc(&p, proc_nr)) != OK)
+ return(s);
+ *sp = p.p_reg.sp;
+ return(OK);
+}
+
--- /dev/null
+/* Function prototypes. */
+
+struct mproc;
+struct stat;
+struct mem_map;
+
+/* alloc.c */
+_PROTOTYPE( phys_clicks alloc_mem, (phys_clicks clicks) );
+_PROTOTYPE( void free_mem, (phys_clicks base, phys_clicks clicks) );
+_PROTOTYPE( void mem_init, (phys_clicks *free) );
+#if ENABLE_SWAP
+_PROTOTYPE( int swap_on, (char *file, u32_t offset, u32_t size) );
+_PROTOTYPE( int swap_off, (void) );
+_PROTOTYPE( void swap_in, (void) );
+_PROTOTYPE( void swap_inqueue, (struct mproc *rmp) );
+#else /* !SWAP */
+#define swap_in() ((void)0)
+#define swap_inqueue(rmp) ((void)0)
+#endif /* !SWAP */
+
+/* break.c */
+_PROTOTYPE( int adjust, (struct mproc *rmp,
+ vir_clicks data_clicks, vir_bytes sp) );
+_PROTOTYPE( int do_brk, (void) );
+_PROTOTYPE( int size_ok, (int file_type, vir_clicks tc, vir_clicks dc,
+ vir_clicks sc, vir_clicks dvir, vir_clicks s_vir) );
+
+/* devio.c */
+_PROTOTYPE( int do_dev_io, (void) );
+_PROTOTYPE( int do_dev_io, (void) );
+
+/* exec.c */
+_PROTOTYPE( int do_exec, (void) );
+_PROTOTYPE( void rw_seg, (int rw, int fd, int proc, int seg,
+ phys_bytes seg_bytes) );
+_PROTOTYPE( struct mproc *find_share, (struct mproc *mp_ign, Ino_t ino,
+ Dev_t dev, time_t ctime) );
+
+/* forkexit.c */
+_PROTOTYPE( int do_fork, (void) );
+_PROTOTYPE( int do_mm_exit, (void) );
+_PROTOTYPE( int do_waitpid, (void) );
+_PROTOTYPE( void mm_exit, (struct mproc *rmp, int exit_status) );
+
+/* getset.c */
+_PROTOTYPE( int do_getset, (void) );
+
+/* main.c */
+_PROTOTYPE( void main, (void) );
+
+/* misc.c */
+_PROTOTYPE( int do_reboot, (void) );
+_PROTOTYPE( int do_getsysinfo, (void) );
+_PROTOTYPE( int do_svrctl, (void) );
+_PROTOTYPE( int do_mstats, (void) );
+
+#if (MACHINE == MACINTOSH)
+_PROTOTYPE( phys_clicks start_click, (void) );
+#endif
+
+_PROTOTYPE( void setreply, (int proc_nr, int result) );
+
+/* signal.c */
+_PROTOTYPE( int do_alarm, (void) );
+_PROTOTYPE( int do_kill, (void) );
+_PROTOTYPE( int ksig_pending, (void) );
+_PROTOTYPE( int do_ksig, (void) );
+_PROTOTYPE( int do_pause, (void) );
+_PROTOTYPE( int set_alarm, (int proc_nr, int sec) );
+_PROTOTYPE( int check_sig, (pid_t proc_id, int signo) );
+_PROTOTYPE( void sig_proc, (struct mproc *rmp, int sig_nr) );
+_PROTOTYPE( int do_sigaction, (void) );
+_PROTOTYPE( int do_sigpending, (void) );
+_PROTOTYPE( int do_sigprocmask, (void) );
+_PROTOTYPE( int do_sigreturn, (void) );
+_PROTOTYPE( int do_sigsuspend, (void) );
+_PROTOTYPE( void check_pending, (struct mproc *rmp) );
+
+/* trace.c */
+_PROTOTYPE( int do_trace, (void) );
+_PROTOTYPE( void stop_proc, (struct mproc *rmp, int sig_nr) );
+
+/* utility.c */
+_PROTOTYPE( int allowed, (char *name_buf, struct stat *s_buf, int mask) );
+_PROTOTYPE( int no_sys, (void) );
+_PROTOTYPE( void panic, (char *format, int num) );
+_PROTOTYPE( void tell_fs, (int what, int p1, int p2, int p3) );
+
+/* procutils.c */
+_PROTOTYPE( int p_getsp, (int proc_nr, vir_bytes *sp) );
+_PROTOTYPE( int p_getmap, (int proc_nr, struct mem_map *mem_map) );
--- /dev/null
+/* This file handles signals, which are asynchronous events and are generally
+ * a messy and unpleasant business. Signals can be generated by the KILL
+ * system call, or from the keyboard (SIGINT) or from the clock (SIGALRM).
+ * In all cases control eventually passes to check_sig() to see which processes
+ * can be signaled. The actual signaling is done by sig_proc().
+ *
+ * The entry points into this file are:
+ * do_sigaction: perform the SIGACTION system call
+ * do_sigpending: perform the SIGPENDING system call
+ * do_sigprocmask: perform the SIGPROCMASK system call
+ * do_sigreturn: perform the SIGRETURN system call
+ * do_sigsuspend: perform the SIGSUSPEND system call
+ * do_kill: perform the KILL system call
+ * do_ksig: accept a signal originating in the kernel (e.g., SIGINT)
+ * do_alarm: perform the ALARM system call by calling set_alarm()
+ * set_alarm: tell the clock task to start or stop a timer
+ * do_pause: perform the PAUSE system call
+ * ksig_pending: the kernel notified about pending signals
+ * sig_proc: interrupt or terminate a signaled process
+ * check_sig: check which processes to signal with sig_proc()
+ * check_pending: check if a pending signal can now be delivered
+ */
+
+#include "mm.h"
+#include <minix/utils.h>
+#include <sys/stat.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <signal.h>
+#include <sys/sigcontext.h>
+#include <string.h>
+#include "mproc.h"
+#include "param.h"
+
+#define CORE_MODE 0777 /* mode to use on core image files */
+#define DUMPED 0200 /* bit set in status when core dumped */
+
+FORWARD _PROTOTYPE( void dump_core, (struct mproc *rmp) );
+FORWARD _PROTOTYPE( void unpause, (int pro) );
+FORWARD _PROTOTYPE( void handle_ksig, (int proc_nr, sigset_t sig_map) );
+
+
+/*===========================================================================*
+ * do_sigaction *
+ *===========================================================================*/
+PUBLIC int do_sigaction()
+{
+ int r;
+ struct sigaction svec;
+ struct sigaction *svp;
+
+ if (m_in.sig_nr == SIGKILL) return(OK);
+ if (m_in.sig_nr < 1 || m_in.sig_nr > _NSIG) return (EINVAL);
+ svp = &mp->mp_sigact[m_in.sig_nr];
+ if ((struct sigaction *) m_in.sig_osa != (struct sigaction *) NULL) {
+ r = sys_datacopy(PM_PROC_NR,(vir_bytes) svp,
+ who, (vir_bytes) m_in.sig_osa, (phys_bytes) sizeof(svec));
+ if (r != OK) return(r);
+ }
+
+ if ((struct sigaction *) m_in.sig_nsa == (struct sigaction *) NULL)
+ return(OK);
+
+ /* Read in the sigaction structure. */
+ r = sys_datacopy(who, (vir_bytes) m_in.sig_nsa,
+ PM_PROC_NR, (vir_bytes) &svec, (phys_bytes) sizeof(svec));
+ if (r != OK) return(r);
+
+ if (svec.sa_handler == SIG_IGN) {
+ sigaddset(&mp->mp_ignore, m_in.sig_nr);
+ sigdelset(&mp->mp_sigpending, m_in.sig_nr);
+ sigdelset(&mp->mp_catch, m_in.sig_nr);
+ } else {
+ sigdelset(&mp->mp_ignore, m_in.sig_nr);
+ if (svec.sa_handler == SIG_DFL)
+ sigdelset(&mp->mp_catch, m_in.sig_nr);
+ else
+ sigaddset(&mp->mp_catch, m_in.sig_nr);
+ }
+ mp->mp_sigact[m_in.sig_nr].sa_handler = svec.sa_handler;
+ sigdelset(&svec.sa_mask, SIGKILL);
+ mp->mp_sigact[m_in.sig_nr].sa_mask = svec.sa_mask;
+ mp->mp_sigact[m_in.sig_nr].sa_flags = svec.sa_flags;
+ mp->mp_sigreturn = (vir_bytes) m_in.sig_ret;
+ return(OK);
+}
+
+/*===========================================================================*
+ * do_sigpending *
+ *===========================================================================*/
+PUBLIC int do_sigpending()
+{
+ mp->mp_reply.reply_mask = (long) mp->mp_sigpending;
+ return OK;
+}
+
+/*===========================================================================*
+ * do_sigprocmask *
+ *===========================================================================*/
+PUBLIC int do_sigprocmask()
+{
+/* Note that the library interface passes the actual mask in sigmask_set,
+ * not a pointer to the mask, in order to save a copy. Similarly,
+ * the old mask is placed in the return message which the library
+ * interface copies (if requested) to the user specified address.
+ *
+ * The library interface must set SIG_INQUIRE if the 'act' argument
+ * is NULL.
+ */
+
+ int i;
+
+ mp->mp_reply.reply_mask = (long) mp->mp_sigmask;
+
+ switch (m_in.sig_how) {
+ case SIG_BLOCK:
+ sigdelset((sigset_t *)&m_in.sig_set, SIGKILL);
+ for (i = 1; i <= _NSIG; i++) {
+ if (sigismember((sigset_t *)&m_in.sig_set, i))
+ sigaddset(&mp->mp_sigmask, i);
+ }
+ break;
+
+ case SIG_UNBLOCK:
+ for (i = 1; i <= _NSIG; i++) {
+ if (sigismember((sigset_t *)&m_in.sig_set, i))
+ sigdelset(&mp->mp_sigmask, i);
+ }
+ check_pending(mp);
+ break;
+
+ case SIG_SETMASK:
+ sigdelset((sigset_t *) &m_in.sig_set, SIGKILL);
+ mp->mp_sigmask = (sigset_t) m_in.sig_set;
+ check_pending(mp);
+ break;
+
+ case SIG_INQUIRE:
+ break;
+
+ default:
+ return(EINVAL);
+ break;
+ }
+ return OK;
+}
+
+/*===========================================================================*
+ * do_sigsuspend *
+ *===========================================================================*/
+PUBLIC int do_sigsuspend()
+{
+ mp->mp_sigmask2 = mp->mp_sigmask; /* save the old mask */
+ mp->mp_sigmask = (sigset_t) m_in.sig_set;
+ sigdelset(&mp->mp_sigmask, SIGKILL);
+ mp->mp_flags |= SIGSUSPENDED;
+ check_pending(mp);
+ return(SUSPEND);
+}
+
+
+/*===========================================================================*
+ * do_sigreturn *
+ *===========================================================================*/
+PUBLIC int do_sigreturn()
+{
+/* A user signal handler is done. Restore context and check for
+ * pending unblocked signals.
+ */
+
+ int r;
+
+ mp->mp_sigmask = (sigset_t) m_in.sig_set;
+ sigdelset(&mp->mp_sigmask, SIGKILL);
+
+ r = sys_sigreturn(who, (struct sigmsg *) m_in.sig_context, m_in.sig_flags);
+ check_pending(mp);
+ return(r);
+}
+
+/*===========================================================================*
+ * do_kill *
+ *===========================================================================*/
+PUBLIC int do_kill()
+{
+/* Perform the kill(pid, signo) system call. */
+
+ return check_sig(m_in.pid, m_in.sig_nr);
+}
+
+/*===========================================================================*
+ * do_ksig_pending *
+ *===========================================================================*/
+PUBLIC int ksig_pending()
+{
+/* The kernel has notified the MM about pending signals. Request pending
+ * signals until all signals are handled. If there are no more signals,
+ * NONE is returned in the process number field.
+ */
+ int proc_nr;
+ sigset_t sig_map;
+
+ while (TRUE) {
+ sys_getsig(&proc_nr, &sig_map); /* get an arbitrary pending signal */
+ if (NONE == proc_nr) { /* stop if no more pending signals */
+ break;
+ } else {
+ handle_ksig(proc_nr, sig_map); /* handle the receive signal */
+ }
+ }
+ return(SUSPEND); /* prevents sending reply */
+}
+
+/*===========================================================================*
+ * do_ksig *
+ *===========================================================================*/
+PUBLIC int do_ksig()
+{
+/* Certain signals, such as segmentation violations and DEL, originate in the
+ * kernel. When the kernel detects such signals, it sets bits in a bit map.
+ * As soon as MM is awaiting new work, the kernel sends MM a message containing
+ * the process slot and bit map. That message comes here. The File System
+ * also uses this mechanism to signal writing on broken pipes (SIGPIPE).
+ */
+ int proc_nr;
+ sigset_t sig_map;
+
+ /* Only kernel may make this call. */
+ if (who != HARDWARE) return(EPERM);
+ proc_nr = m_in.SIG_PROC;
+ sig_map = (sigset_t) m_in.SIG_MAP;
+ handle_ksig(proc_nr, sig_map);
+ return(SUSPEND);
+}
+
+/*===========================================================================*
+ * handle_ksig *
+ *===========================================================================*/
+PRIVATE void handle_ksig(proc_nr, sig_map)
+int proc_nr;
+sigset_t sig_map;
+{
+ register struct mproc *rmp;
+ int i;
+ pid_t proc_id, id;
+
+ rmp = &mproc[proc_nr];
+ if ((rmp->mp_flags & (IN_USE | ZOMBIE)) != IN_USE) return;
+ proc_id = rmp->mp_pid;
+ mp = &mproc[0]; /* pretend kernel signals are from MM */
+ mp->mp_procgrp = rmp->mp_procgrp; /* get process group right */
+
+ /* Check each bit in turn to see if a signal is to be sent. Unlike
+ * kill(), the kernel may collect several unrelated signals for a
+ * process and pass them to MM in one blow. Thus loop on the bit
+ * map. For SIGINT and SIGQUIT, use proc_id 0 to indicate a broadcast
+ * to the recipient's process group. For SIGKILL, use proc_id -1 to
+ * indicate a systemwide broadcast.
+ */
+ for (i = 1; i <= _NSIG; i++) {
+ if (!sigismember(&sig_map, i)) continue;
+ switch (i) {
+ case SIGINT:
+ case SIGQUIT:
+ id = 0; break; /* broadcast to process group */
+ case SIGKILL:
+ id = -1; break; /* broadcast to all except INIT */
+ case SIGALRM:
+ /* Disregard SIGALRM when the target process has not
+ * requested an alarm. This only applies for a KERNEL
+ * generated signal.
+ */
+ if ((rmp->mp_flags & ALARM_ON) == 0) continue;
+ rmp->mp_flags &= ~ALARM_ON;
+ /* fall through */
+ default:
+ id = proc_id;
+ break;
+ }
+ check_sig(id, i);
+ sys_endsig(proc_nr); /* tell kernel it's done */
+ }
+}
+
+
+/*===========================================================================*
+ * do_alarm *
+ *===========================================================================*/
+PUBLIC int do_alarm()
+{
+/* Perform the alarm(seconds) system call. */
+ return(set_alarm(who, m_in.seconds));
+}
+
+
+/*===========================================================================*
+ * set_alarm *
+ *===========================================================================*/
+PUBLIC int set_alarm(proc_nr, sec)
+int proc_nr; /* process that wants the alarm */
+int sec; /* how many seconds delay before the signal */
+{
+/* This routine is used by do_alarm() to set the alarm timer. It is also used
+ * to turn the timer off when a process exits with the timer still on.
+ */
+ clock_t ticks; /* number of ticks for alarm */
+ int remaining; /* previous time left in seconds */
+ int s;
+
+ if (sec != 0) mproc[proc_nr].mp_flags |= ALARM_ON;
+ else mproc[proc_nr].mp_flags &= ~ALARM_ON;
+
+ /* Tell the clock task to provide a signal message when the time comes.
+ *
+ * Large delays cause a lot of problems. First, the alarm system call
+ * takes an unsigned seconds count and the library has cast it to an int.
+ * That probably works, but on return the library will convert "negative"
+ * unsigneds to errors. Presumably no one checks for these errors, so
+ * force this call through. Second, If unsigned and long have the same
+ * size, converting from seconds to ticks can easily overflow. Finally,
+ * the kernel has similar overflow bugs adding ticks.
+ *
+ * Fixing this requires a lot of ugly casts to fit the wrong interface
+ * types and to avoid overflow traps. ALRM_EXP_TIME has the right type
+ * (clock_t) although it is declared as long. How can variables like
+ * this be declared properly without combinatorial explosion of message
+ * types?
+ */
+ ticks = (clock_t) (HZ * (unsigned long) (unsigned) sec);
+ if ( (unsigned long) ticks / HZ != (unsigned) sec)
+ ticks = LONG_MAX; /* eternity (really TMR_NEVER) */
+
+ if ((s=sys_signalrm(proc_nr, &ticks)) != OK)
+ panic("MM couldn't set signal alarm", s);
+
+ remaining = (int) ((ticks + (HZ-1))/HZ);
+ if (remaining < 0) remaining = INT_MAX; /* true value is too large */
+ return(remaining);
+}
+
+
+/*===========================================================================*
+ * do_pause *
+ *===========================================================================*/
+PUBLIC int do_pause()
+{
+/* Perform the pause() system call. */
+
+ mp->mp_flags |= PAUSED;
+ return(SUSPEND);
+}
+
+
+/*===========================================================================*
+ * sig_proc *
+ *===========================================================================*/
+PUBLIC void sig_proc(rmp, signo)
+register struct mproc *rmp; /* pointer to the process to be signaled */
+int signo; /* signal to send to process (1 to _NSIG) */
+{
+/* Send a signal to a process. Check to see if the signal is to be caught,
+ * ignored, or blocked. If the signal is to be caught, coordinate with
+ * KERNEL to push a sigcontext structure and a sigframe structure onto
+ * the catcher's stack. Also, KERNEL will reset the program counter and
+ * stack pointer, so that when the process next runs, it will be executing
+ * the signal handler. When the signal handler returns, sigreturn(2)
+ * will be called. Then KERNEL will restore the signal context from the
+ * sigcontext structure.
+ *
+ * If there is insufficient stack space, kill the process.
+ */
+
+ vir_bytes new_sp;
+ int s;
+ int slot;
+ int sigflags;
+ struct sigmsg sm;
+
+ slot = (int) (rmp - mproc);
+ if ((rmp->mp_flags & (IN_USE | ZOMBIE)) != IN_USE) {
+ printf("MM: signal %d sent to %s process %d\n",
+ (rmp->mp_flags & ZOMBIE) ? "zombie" : "dead", signo, slot);
+ panic("", NO_NUM);
+ }
+ if ((rmp->mp_flags & TRACED) && signo != SIGKILL) {
+ /* A traced process has special handling. */
+ unpause(slot);
+ stop_proc(rmp, signo); /* a signal causes it to stop */
+ return;
+ }
+ /* Some signals are ignored by default. */
+ if (sigismember(&rmp->mp_ignore, signo)) return;
+
+ if (sigismember(&rmp->mp_sigmask, signo)) {
+ /* Signal should be blocked. */
+ sigaddset(&rmp->mp_sigpending, signo);
+ return;
+ }
+ sigflags = rmp->mp_sigact[signo].sa_flags;
+ if (sigismember(&rmp->mp_catch, signo)) {
+ if (rmp->mp_flags & ONSWAP) {
+ /* Process is swapped out, leave signal pending. */
+ sigaddset(&rmp->mp_sigpending, signo);
+ swap_inqueue(rmp);
+ return;
+ }
+ if (rmp->mp_flags & SIGSUSPENDED)
+ sm.sm_mask = rmp->mp_sigmask2;
+ else
+ sm.sm_mask = rmp->mp_sigmask;
+ sm.sm_signo = signo;
+ sm.sm_sighandler = (vir_bytes) rmp->mp_sigact[signo].sa_handler;
+ sm.sm_sigreturn = rmp->mp_sigreturn;
+ if ((s=p_getsp(slot, &new_sp)) != OK)
+ panic("MM couldn't get new stack pointer",s);
+ sm.sm_stkptr = new_sp;
+
+ /* Make room for the sigcontext and sigframe struct. */
+ new_sp -= sizeof(struct sigcontext)
+ + 3 * sizeof(char *) + 2 * sizeof(int);
+
+ if (adjust(rmp, rmp->mp_seg[D].mem_len, new_sp) != OK)
+ goto doterminate;
+
+ rmp->mp_sigmask |= rmp->mp_sigact[signo].sa_mask;
+ if (sigflags & SA_NODEFER)
+ sigdelset(&rmp->mp_sigmask, signo);
+ else
+ sigaddset(&rmp->mp_sigmask, signo);
+
+ if (sigflags & SA_RESETHAND) {
+ sigdelset(&rmp->mp_catch, signo);
+ rmp->mp_sigact[signo].sa_handler = SIG_DFL;
+ }
+
+ sys_sigsend(slot, &sm);
+ sigdelset(&rmp->mp_sigpending, signo);
+ /* If process is hanging on PAUSE, WAIT, SIGSUSPEND, tty, pipe, etc.,
+ * release it.
+ */
+ unpause(slot);
+ return;
+ }
+doterminate:
+ /* Signal should not or cannot be caught. Take default action. */
+ if (sigismember(&ign_sset, signo)) return;
+
+ rmp->mp_sigstatus = (char) signo;
+ if (sigismember(&core_sset, signo)) {
+ if (rmp->mp_flags & ONSWAP) {
+ /* Process is swapped out, leave signal pending. */
+ sigaddset(&rmp->mp_sigpending, signo);
+ swap_inqueue(rmp);
+ return;
+ }
+ /* Switch to the user's FS environment and dump core. */
+ tell_fs(CHDIR, slot, FALSE, 0);
+ dump_core(rmp);
+ }
+ mm_exit(rmp, 0); /* terminate process */
+}
+
+
+/*===========================================================================*
+ * check_sig *
+ *===========================================================================*/
+PUBLIC int check_sig(proc_id, signo)
+pid_t proc_id; /* pid of proc to sig, or 0 or -1, or -pgrp */
+int signo; /* signal to send to process (0 to _NSIG) */
+{
+/* Check to see if it is possible to send a signal. The signal may have to be
+ * sent to a group of processes. This routine is invoked by the KILL system
+ * call, and also when the kernel catches a DEL or other signal.
+ */
+
+ register struct mproc *rmp;
+ int count; /* count # of signals sent */
+ int error_code;
+
+ if (signo < 0 || signo > _NSIG) return(EINVAL);
+
+ /* Return EINVAL for attempts to send SIGKILL to INIT alone. */
+ if (proc_id == INIT_PID && signo == SIGKILL) return(EINVAL);
+
+ /* Search the proc table for processes to signal. (See forkexit.c about
+ * pid magic.)
+ */
+ count = 0;
+ error_code = ESRCH;
+ for (rmp = &mproc[INIT_PROC_NR]; rmp < &mproc[NR_PROCS]; rmp++) {
+ if (!(rmp->mp_flags & IN_USE)) continue;
+ if ((rmp->mp_flags & ZOMBIE) && signo != 0) continue;
+
+ /* Check for selection. */
+ if (proc_id > 0 && proc_id != rmp->mp_pid) continue;
+ if (proc_id == 0 && mp->mp_procgrp != rmp->mp_procgrp) continue;
+ if (proc_id == -1 && rmp->mp_pid <= INIT_PID) continue;
+ if (proc_id < -1 && rmp->mp_procgrp != -proc_id) continue;
+
+ /* Check for permission. */
+ if (mp->mp_effuid != SUPER_USER
+ && mp->mp_realuid != rmp->mp_realuid
+ && mp->mp_effuid != rmp->mp_realuid
+ && mp->mp_realuid != rmp->mp_effuid
+ && mp->mp_effuid != rmp->mp_effuid) {
+ error_code = EPERM;
+ continue;
+ }
+
+ count++;
+ if (signo == 0) continue;
+
+ /* 'sig_proc' will handle the disposition of the signal. The
+ * signal may be caught, blocked, ignored, or cause process
+ * termination, possibly with core dump.
+ */
+ sig_proc(rmp, signo);
+
+ if (proc_id > 0) break; /* only one process being signaled */
+ }
+
+ /* If the calling process has killed itself, don't reply. */
+ if ((mp->mp_flags & (IN_USE | ZOMBIE)) != IN_USE) return(SUSPEND);
+ return(count > 0 ? OK : error_code);
+}
+
+
+/*===========================================================================*
+ * check_pending *
+ *===========================================================================*/
+PUBLIC void check_pending(rmp)
+register struct mproc *rmp;
+{
+ /* Check to see if any pending signals have been unblocked. The
+ * first such signal found is delivered.
+ *
+ * If multiple pending unmasked signals are found, they will be
+ * delivered sequentially.
+ *
+ * There are several places in this file where the signal mask is
+ * changed. At each such place, check_pending() should be called to
+ * check for newly unblocked signals.
+ */
+
+ int i;
+
+ for (i = 1; i <= _NSIG; i++) {
+ if (sigismember(&rmp->mp_sigpending, i) &&
+ !sigismember(&rmp->mp_sigmask, i)) {
+ sigdelset(&rmp->mp_sigpending, i);
+ sig_proc(rmp, i);
+ break;
+ }
+ }
+}
+
+
+/*===========================================================================*
+ * unpause *
+ *===========================================================================*/
+PRIVATE void unpause(pro)
+int pro; /* which process number */
+{
+/* A signal is to be sent to a process. If that process is hanging on a
+ * system call, the system call must be terminated with EINTR. Possible
+ * calls are PAUSE, WAIT, READ and WRITE, the latter two for pipes and ttys.
+ * First check if the process is hanging on an MM call. If not, tell FS,
+ * so it can check for READs and WRITEs from pipes, ttys and the like.
+ */
+
+ register struct mproc *rmp;
+
+ rmp = &mproc[pro];
+
+ /* Check to see if process is hanging on a PAUSE, WAIT or SIGSUSPEND call. */
+ if (rmp->mp_flags & (PAUSED | WAITING | SIGSUSPENDED)) {
+ rmp->mp_flags &= ~(PAUSED | WAITING | SIGSUSPENDED);
+ setreply(pro, EINTR);
+ return;
+ }
+
+ /* Process is not hanging on an MM call. Ask FS to take a look. */
+ tell_fs(UNPAUSE, pro, 0, 0);
+}
+
+
+/*===========================================================================*
+ * dump_core *
+ *===========================================================================*/
+PRIVATE void dump_core(rmp)
+register struct mproc *rmp; /* whose core is to be dumped */
+{
+/* Make a core dump on the file "core", if possible. */
+
+ int s, fd, fake_fd, nr_written, seg, slot;
+ char *buf;
+ vir_bytes current_sp;
+ phys_bytes left; /* careful; 64K might overflow vir_bytes */
+ unsigned nr_to_write; /* unsigned for arg to write() but < INT_MAX */
+ long trace_data, trace_off;
+
+ slot = (int) (rmp - mproc);
+
+ /* Can core file be written? We are operating in the user's FS environment,
+ * so no special permission checks are needed.
+ */
+ if (rmp->mp_realuid != rmp->mp_effuid) return;
+ if ( (fd = open(core_name, O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK,
+ CORE_MODE)) < 0) return;
+ rmp->mp_sigstatus |= DUMPED;
+
+ /* Make sure the stack segment is up to date.
+ * We don't want adjust() to fail unless current_sp is preposterous,
+ * but it might fail due to safety checking. Also, we don't really want
+ * the adjust() for sending a signal to fail due to safety checking.
+ * Maybe make SAFETY_BYTES a parameter.
+ */
+ if ((s=p_getsp(slot, ¤t_sp)) != OK)
+ panic("MM couldn't get new stack pointer",s);
+ adjust(rmp, rmp->mp_seg[D].mem_len, current_sp);
+
+ /* Write the memory map of all segments to begin the core file. */
+ if (write(fd, (char *) rmp->mp_seg, (unsigned) sizeof rmp->mp_seg)
+ != (unsigned) sizeof rmp->mp_seg) {
+ close(fd);
+ return;
+ }
+
+ /* Write out the whole kernel process table entry to get the regs. */
+ trace_off = 0;
+ while (sys_trace(3, slot, trace_off, &trace_data) == OK) {
+ if (write(fd, (char *) &trace_data, (unsigned) sizeof (long))
+ != (unsigned) sizeof (long)) {
+ close(fd);
+ return;
+ }
+ trace_off += sizeof (long);
+ }
+
+ /* Loop through segments and write the segments themselves out. */
+ for (seg = 0; seg < NR_LOCAL_SEGS; seg++) {
+ rw_seg(1, fd, slot, seg,
+ (phys_bytes) rmp->mp_seg[seg].mem_len << CLICK_SHIFT);
+ }
+ close(fd);
+}
--- /dev/null
+/* This file contains the table used to map system call numbers onto the
+ * routines that perform them.
+ */
+
+#define _TABLE
+
+#include "mm.h"
+#include <minix/callnr.h>
+#include <signal.h>
+#include "mproc.h"
+#include "param.h"
+
+/* Miscellaneous */
+char core_name[] = "core"; /* file name where core images are produced */
+
+_PROTOTYPE (int (*call_vec[NCALLS]), (void) ) = {
+ no_sys, /* 0 = unused */
+ do_mm_exit, /* 1 = exit */
+ do_fork, /* 2 = fork */
+ no_sys, /* 3 = read */
+ no_sys, /* 4 = write */
+ no_sys, /* 5 = open */
+ no_sys, /* 6 = close */
+ do_waitpid, /* 7 = wait */
+ no_sys, /* 8 = creat */
+ no_sys, /* 9 = link */
+ no_sys, /* 10 = unlink */
+ do_waitpid, /* 11 = waitpid */
+ no_sys, /* 12 = chdir */
+ no_sys, /* 13 = time */
+ no_sys, /* 14 = mknod */
+ no_sys, /* 15 = chmod */
+ no_sys, /* 16 = chown */
+ do_brk, /* 17 = break */
+ no_sys, /* 18 = stat */
+ no_sys, /* 19 = lseek */
+ do_getset, /* 20 = getpid */
+ no_sys, /* 21 = mount */
+ no_sys, /* 22 = umount */
+ do_getset, /* 23 = setuid */
+ do_getset, /* 24 = getuid */
+ no_sys, /* 25 = stime */
+ do_trace, /* 26 = ptrace */
+ do_alarm, /* 27 = alarm */
+ no_sys, /* 28 = fstat */
+ do_pause, /* 29 = pause */
+ no_sys, /* 30 = utime */
+ no_sys, /* 31 = (stty) */
+ no_sys, /* 32 = (gtty) */
+ no_sys, /* 33 = access */
+ no_sys, /* 34 = (nice) */
+ no_sys, /* 35 = (ftime) */
+ no_sys, /* 36 = sync */
+ do_kill, /* 37 = kill */
+ no_sys, /* 38 = rename */
+ no_sys, /* 39 = mkdir */
+ no_sys, /* 40 = rmdir */
+ no_sys, /* 41 = dup */
+ no_sys, /* 42 = pipe */
+ no_sys, /* 43 = times */
+ no_sys, /* 44 = (prof) */
+ no_sys, /* 45 = unused */
+ do_getset, /* 46 = setgid */
+ do_getset, /* 47 = getgid */
+ no_sys, /* 48 = (signal)*/
+ no_sys, /* 49 = unused */
+ no_sys, /* 50 = unused */
+ no_sys, /* 51 = (acct) */
+ no_sys, /* 52 = (phys) */
+ no_sys, /* 53 = (lock) */
+ no_sys, /* 54 = ioctl */
+ no_sys, /* 55 = fcntl */
+ no_sys, /* 56 = (mpx) */
+ no_sys, /* 57 = unused */
+ no_sys, /* 58 = unused */
+ do_exec, /* 59 = execve */
+ no_sys, /* 60 = umask */
+ no_sys, /* 61 = chroot */
+ do_getset, /* 62 = setsid */
+ do_getset, /* 63 = getpgrp */
+
+ do_ksig, /* 64 = KSIG: signals originating in the kernel */
+ no_sys, /* 65 = UNPAUSE */
+ no_sys, /* 66 = unused */
+ no_sys, /* 67 = REVIVE */
+ no_sys, /* 68 = TASK_REPLY */
+ no_sys, /* 69 = unused */
+ no_sys, /* 70 = unused */
+ do_sigaction, /* 71 = sigaction */
+ do_sigsuspend, /* 72 = sigsuspend */
+ do_sigpending, /* 73 = sigpending */
+ do_sigprocmask, /* 74 = sigprocmask */
+ do_sigreturn, /* 75 = sigreturn */
+ do_reboot, /* 76 = reboot */
+ do_svrctl, /* 77 = svrctl */
+
+ no_sys, /* 78 = cmostime */
+ do_getsysinfo, /* 79 = getsysinfo */
+#if ENABLE_MESSAGE_STATS
+ do_mstats, /* 80 = mstats */
+#else
+ no_sys,
+#endif
+ no_sys, /* 81 = unused */
+ no_sys, /* 82 = unused */
+};
+/* This should not fail with "array size is negative": */
+extern int dummy[sizeof(call_vec) == NCALLS * sizeof(call_vec[0]) ? 1 : -1];
--- /dev/null
+/* This file handles the memory manager's part of debugging, using the
+ * ptrace system call. Most of the commands are passed on to the system
+ * task for completion.
+ *
+ * The debugging commands available are:
+ * T_STOP stop the process
+ * T_OK enable tracing by parent for this process
+ * T_GETINS return value from instruction space
+ * T_GETDATA return value from data space
+ * T_GETUSER return value from user process table
+ * T_SETINS set value in instruction space
+ * T_SETDATA set value in data space
+ * T_SETUSER set value in user process table
+ * T_RESUME resume execution
+ * T_EXIT exit
+ * T_STEP set trace bit
+ *
+ * The T_OK and T_EXIT commands are handled here, and the T_RESUME and
+ * T_STEP commands are partially handled here and completed by the system
+ * task. The rest are handled entirely by the system task.
+ */
+
+#include "mm.h"
+#include <minix/com.h>
+#include <sys/ptrace.h>
+#include <signal.h>
+#include "mproc.h"
+#include "param.h"
+
+#define NIL_MPROC ((struct mproc *) 0)
+
+FORWARD _PROTOTYPE( struct mproc *findproc, (pid_t lpid) );
+
+/*===========================================================================*
+ * do_trace *
+ *===========================================================================*/
+PUBLIC int do_trace()
+{
+ register struct mproc *child;
+
+ /* the T_OK call is made by the child fork of the debugger before it execs
+ * the process to be traced
+ */
+ if (m_in.request == T_OK) { /* enable tracing by parent for this proc */
+ mp->mp_flags |= TRACED;
+ mp->mp_reply.reply_trace = 0;
+ return(OK);
+ }
+ if ((child=findproc(m_in.pid))==NIL_MPROC || !(child->mp_flags & STOPPED)) {
+ return(ESRCH);
+ }
+ /* all the other calls are made by the parent fork of the debugger to
+ * control execution of the child
+ */
+ switch (m_in.request) {
+ case T_EXIT: /* exit */
+ mm_exit(child, (int) m_in.data);
+ mp->mp_reply.reply_trace = 0;
+ return(OK);
+ case T_RESUME:
+ case T_STEP: /* resume execution */
+ if (m_in.data < 0 || m_in.data > _NSIG) return(EIO);
+ if (m_in.data > 0) { /* issue signal */
+ child->mp_flags &= ~TRACED; /* so signal is not diverted */
+ sig_proc(child, (int) m_in.data);
+ child->mp_flags |= TRACED;
+ }
+ child->mp_flags &= ~STOPPED;
+ break;
+ }
+ if (sys_trace(m_in.request,(int)(child-mproc),m_in.taddr,&m_in.data) != OK)
+ return(-errno);
+ mp->mp_reply.reply_trace = m_in.data;
+ return(OK);
+}
+
+/*===========================================================================*
+ * findproc *
+ *===========================================================================*/
+PRIVATE struct mproc *findproc(lpid)
+pid_t lpid;
+{
+ register struct mproc *rmp;
+
+ for (rmp = &mproc[INIT_PROC_NR + 1]; rmp < &mproc[NR_PROCS]; rmp++)
+ if (rmp->mp_flags & IN_USE && rmp->mp_pid == lpid) return(rmp);
+ return(NIL_MPROC);
+}
+
+/*===========================================================================*
+ * stop_proc *
+ *===========================================================================*/
+PUBLIC void stop_proc(rmp, signo)
+register struct mproc *rmp;
+int signo;
+{
+/* A traced process got a signal so stop it. */
+
+ register struct mproc *rpmp = mproc + rmp->mp_parent;
+
+ if (sys_trace(-1, (int) (rmp - mproc), 0L, (long *) 0) != OK) return;
+ rmp->mp_flags |= STOPPED;
+ if (rpmp->mp_flags & WAITING) {
+ rpmp->mp_flags &= ~WAITING; /* parent is no longer waiting */
+ rpmp->mp_reply.reply_res2 = 0177 | (signo << 8);
+ setreply(rmp->mp_parent, rmp->mp_pid);
+ } else {
+ rmp->mp_sigstatus = signo;
+ }
+ return;
+}
--- /dev/null
+/* If there were any type definitions local to the Memory Manager, they would
+ * be here. This file is included only for symmetry with the kernel and File
+ * System, which do have some local type definitions.
+ */
+
--- /dev/null
+/* This file contains some utility routines for MM.
+ *
+ * The entry points are:
+ * allowed: see if an access is permitted
+ * no_sys: this routine is called for invalid system call numbers
+ * panic: MM has run aground of a fatal error and cannot continue
+ * tell_fs: interface to FS
+ */
+
+#include "mm.h"
+#include <sys/stat.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <fcntl.h>
+#include <signal.h> /* needed only because mproc.h needs it */
+#include "mproc.h"
+#include "param.h"
+
+/*===========================================================================*
+ * allowed *
+ *===========================================================================*/
+PUBLIC int allowed(name_buf, s_buf, mask)
+char *name_buf; /* pointer to file name to be EXECed */
+struct stat *s_buf; /* buffer for doing and returning stat struct*/
+int mask; /* R_BIT, W_BIT, or X_BIT */
+{
+/* Check to see if file can be accessed. Return EACCES or ENOENT if the access
+ * is prohibited. If it is legal open the file and return a file descriptor.
+ */
+
+ int fd;
+ int save_errno;
+
+ /* Use the fact that mask for access() is the same as the permissions mask.
+ * E.g., X_BIT in <minix/const.h> is the same as X_OK in <unistd.h> and
+ * S_IXOTH in <sys/stat.h>. tell_fs(DO_CHDIR, ...) has set MM's real ids
+ * to the user's effective ids, so access() works right for setuid programs.
+ */
+ if (access(name_buf, mask) < 0) return(-errno);
+
+ /* The file is accessible but might not be readable. Make it readable. */
+ tell_fs(SETUID, PM_PROC_NR, (int) SUPER_USER, (int) SUPER_USER);
+
+ /* Open the file and fstat it. Restore the ids early to handle errors. */
+ fd = open(name_buf, O_RDONLY | O_NONBLOCK);
+ save_errno = errno; /* open might fail, e.g. from ENFILE */
+ tell_fs(SETUID, PM_PROC_NR, (int) mp->mp_effuid, (int) mp->mp_effuid);
+ if (fd < 0) return(-save_errno);
+ if (fstat(fd, s_buf) < 0) panic("allowed: fstat failed", NO_NUM);
+
+ /* Only regular files can be executed. */
+ if (mask == X_BIT && (s_buf->st_mode & I_TYPE) != I_REGULAR) {
+ close(fd);
+ return(EACCES);
+ }
+ return(fd);
+}
+
+
+/*===========================================================================*
+ * no_sys *
+ *===========================================================================*/
+PUBLIC int no_sys()
+{
+/* A system call number not implemented by MM has been requested. */
+
+ return(EINVAL);
+}
+
+
+/*===========================================================================*
+ * panic *
+ *===========================================================================*/
+PUBLIC void panic(format, num)
+char *format; /* format string */
+int num; /* number to go with format string */
+{
+/* Something awful has happened. Panics are caused when an internal
+ * inconsistency is detected, e.g., a programming error or illegal value of a
+ * defined constant.
+ */
+
+ printf("Memory manager panic: %s ", format);
+ if (num != NO_NUM) printf("%d",num);
+ printf("\n");
+ tell_fs(SYNC, 0, 0, 0); /* flush the cache to the disk */
+ sys_abort(RBT_PANIC);
+}
+
+
+/*===========================================================================*
+ * tell_fs *
+ *===========================================================================*/
+PUBLIC void tell_fs(what, p1, p2, p3)
+int what, p1, p2, p3;
+{
+/* This routine is only used by MM to inform FS of certain events:
+ * tell_fs(CHDIR, slot, dir, 0)
+ * tell_fs(EXEC, proc, 0, 0)
+ * tell_fs(EXIT, proc, 0, 0)
+ * tell_fs(FORK, parent, child, pid)
+ * tell_fs(SETGID, proc, realgid, effgid)
+ * tell_fs(SETSID, proc, 0, 0)
+ * tell_fs(SETUID, proc, realuid, effuid)
+ * tell_fs(SYNC, 0, 0, 0)
+ * tell_fs(UNPAUSE, proc, signr, 0)
+ */
+ message m;
+
+ m.tell_fs_arg1 = p1;
+ m.tell_fs_arg2 = p2;
+ m.tell_fs_arg3 = p3;
+ _taskcall(FS_PROC_NR, what, &m);
+}