minix/kernel/system/sysctl.c

/* The system call implemented in this file:
 *   m_type:	SYS_EXIT
 *
 * The parameters for this system call are:
 *    m1_i1:	EXIT_STATUS	(exit status, 0 if normal exit)
 *
 * Author:
 *    Jorrit N. Herder <jnherder@cs.vu.nl>
 */

#include "../kernel.h"
#include "../ipc.h"
#include "../system.h"
#include "../protect.h"
#include <sys/svrctl.h>
#include "../sendmask.h"

/*===========================================================================*
 * 				   do_exit				     *
 *===========================================================================*/
PUBLIC int do_exit(m_ptr)
message *m_ptr;			/* pointer to request message */
{
/* Handle sys_exit. A server or driver wants to exit. This may happen
 * on a panic, but also is done when MINIX is shutdown.
 */
  register struct proc *rp;
  int proc_nr = m_ptr->m_source;	/* can only exit own process */

  if (m_ptr->EXIT_STATUS != 0) {
      kprintf("WARNING: system process %d exited with an error.\n", proc_nr );
  }

  /* Now call the routine to clean up of the process table slot. This cancels
   * outstanding timers, possibly removes the process from the message queues,
   * and reset important process table fields.
   */
  clear_proc(proc_nr);

  /* If the shutdown sequence is active, see if it was awaiting the shutdown
   * of this system service. If so, directly continue the stop sequence. 
   */
  if (shutting_down && shutdown_process == proc_addr(proc_nr)) {
      stop_sequence(&shutdown_timer);
  }
  return(EDONTREPLY);			/* no reply is sent */
}



/* The system call implemented in this file:
 *   m_type:	SYS_SVRCTL
 *
 * The parameters for this system call are:
 *    m2_i1:	CTL_PROC_NR 	(process number of caller)	
 *    m2_i2:	CTL_REQUEST	(request type)	
 *    m2_i3:	CTL_MM_PRIV 	(privilege)
 *    m2_l1:    CTL_SEND_MASK   (new send mask to be installed)
 *    m2_l2:    CTL_PROC_TYPE   (new process type)
 *    m2_p1:	CTL_ARG_PTR 	(argument pointer)
 */

/* NOTE: this call will radically change! */

/*===========================================================================*
 *				do_svrctl				     *
 *===========================================================================*/
PUBLIC int do_svrctl(m_ptr)
message *m_ptr;			/* pointer to request message */
{
  register struct proc *rp;
  int proc_nr, priv;
  int request;
  vir_bytes argp;

  /* Extract message parameters. */
  proc_nr = m_ptr->CTL_PROC_NR;
  if (proc_nr == SELF) proc_nr = m_ptr->m_source;
  if (! isokprocn(proc_nr)) return(EINVAL);

  request = m_ptr->CTL_REQUEST;
  priv = m_ptr->CTL_MM_PRIV;
  argp = (vir_bytes) m_ptr->CTL_ARG_PTR;
  rp = proc_addr(proc_nr);

  /* Check if the PM privileges are super user. */
  if (!priv || !isuserp(rp)) 
      return(EPERM);

  /* See what is requested and handle the request. */
  switch (request) {
  case SYSSIGNON: {
	/* Make this process a server. The system processes should be able
	 * to communicate with this new server, so update their send masks
	 * as well.
	 */
  	/* fall through */
  }
  case SYSSENDMASK: {
	rp->p_call_mask = SYSTEM_CALL_MASK;
	rp->p_type = P_SERVER;
	rp->p_sendmask = ALLOW_ALL_MASK;
	send_mask_allow(proc_addr(USR8139)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(PM_PROC_NR)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(FS_PROC_NR)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(IS_PROC_NR)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(CLOCK)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(SYSTASK)->p_sendmask, proc_nr);
	send_mask_allow(proc_addr(FXP)->p_sendmask, proc_nr);
	return(OK); 
  }
  default:
	return(EINVAL);
  }
}

/* The system call implemented in this file:
 *   m_type:	SYS_SEGCTL
 *
 * The parameters for this system call are:
 *    m4_l3:	SEG_PHYS	(physical base address)
 *    m4_l4:	SEG_SIZE	(size of segment)
 *    m4_l1:	SEG_SELECT	(return segment selector here)
 *    m4_l2:	SEG_OFFSET	(return offset within segment here)
 *    m4_l5:	SEG_INDEX	(return index into remote memory map here)
 *
 * Author:
 *    Jorrit N. Herder <jnherder@cs.vu.nl>
 */

/*===========================================================================*
 *			        do_segctl				     *
 *===========================================================================*/
PUBLIC int do_segctl(m_ptr)
register message *m_ptr;	/* pointer to request message */
{
/* Return a segment selector and offset that can be used to reach a physical
 * address, for use by a driver doing memory I/O in the A0000 - DFFFF range.
 */
  u16_t selector;
  vir_bytes offset;
  int i, index;
  register struct proc *rp;
  phys_bytes phys = (phys_bytes) m_ptr->SEG_PHYS;
  vir_bytes size = (vir_bytes) m_ptr->SEG_SIZE;
  int result;

  /* First check if there is a slot available for this segment. */
  rp = proc_addr(m_ptr->m_source);
  index = -1;
  for (i=0; i < NR_REMOTE_SEGS; i++) {
  	if (! rp->p_farmem[i].in_use) {
  		index = i; 
  		rp->p_farmem[i].in_use = TRUE;
  		rp->p_farmem[i].mem_phys = phys;
  		rp->p_farmem[i].mem_len = size;
  		break;
  	}
  }
  if (index < 0) return(ENOSPC);


  if (! machine.protected) {
      selector = phys / HCLICK_SIZE;
      offset = phys % HCLICK_SIZE;
      result = OK;
  } else {
      /* Check if the segment size can be recorded in bytes, that is, check
       * if descriptor's limit field can delimited the allowed memory region
       * precisely. This works up to 1MB. If the size is larger, 4K pages
       * instead of bytes are used.
       */
      if (size < BYTE_GRAN_MAX) {
          init_dataseg(&rp->p_ldt[EXTRA_LDT_INDEX+i], phys, size, 
          	USER_PRIVILEGE);
          selector = ((EXTRA_LDT_INDEX+i)*0x08) | (1*0x04) | USER_PRIVILEGE;
          offset = 0;
          result = OK;			
      } else {
          init_dataseg(&rp->p_ldt[EXTRA_LDT_INDEX+i], phys & ~0xFFFF, 0, 
          	USER_PRIVILEGE);
          selector = ((EXTRA_LDT_INDEX+i)*0x08) | (1*0x04) | USER_PRIVILEGE;
          offset = phys & 0xFFFF;
          result = OK;
      }
  }

  /* Request successfully done. Now return the result. */
  m_ptr->SEG_INDEX = index | REMOTE_SEG;
  m_ptr->SEG_SELECT = selector;
  m_ptr->SEG_OFFSET = offset;
  return(result);
}


/* The system call implemented in this file:
 *   m_type:	SYS_IOPENABLE
 *
 * The parameters for this system call are:
 *    m2_i2:	PROC_NR		(process to give I/O Protection Level bits)
 *
 * Author:
 *    Jorrit N. Herder <jnherder@cs.vu.nl>
 */

/*===========================================================================*
 *			        do_iopenable				     *
 *===========================================================================*/
PUBLIC int do_iopenable(m_ptr)
register message *m_ptr;	/* pointer to request message */
{
#if ENABLE_USERPRIV && ENABLE_USERIOPL
  enable_iop(proc_addr(m_ptr->PROC_NR)); 
  return(OK);
#else
  return(EPERM);
#endif
}


/* The system call implemented in this file:
 *   m_type:	SYS_KMALLOC
 *
 * The parameters for this system call are:
 *    m4_l2:	MEM_CHUNK_SIZE	(request a buffer of this size)
 *    m4_l1:	MEM_CHUNK_BASE 	(return physical address on success)	
 *
 * Author:
 *    Jorrit N. Herder <jnherder@cs.vu.nl>
 */

/*===========================================================================*
 *			        do_kmalloc				     *
 *===========================================================================*/
PUBLIC int do_kmalloc(m_ptr)
register message *m_ptr;	/* pointer to request message */
{
/* Request a (DMA) buffer to be allocated in one of the memory chunks. */
  phys_clicks tot_clicks;
  struct memory *memp;

  kprintf("SYS_KMALLOC called by %d\n", m_ptr->m_source);
  
  tot_clicks = (m_ptr->MEM_CHUNK_SIZE + CLICK_SIZE-1) >> CLICK_SHIFT;
  memp = &mem[NR_MEMS];
  while ((--memp)->size < tot_clicks) {
      if (memp == mem) {
          return(ENOMEM);
      }
  }
  memp->size -= tot_clicks;
  m_ptr->MEM_CHUNK_BASE = (memp->base + memp->size) << CLICK_SHIFT; 
  return(OK);
}