Minix1.1/usr/src/fs/misc.c

Compare this file to the similar file:
Show the results in this format: 

/* This file contains a collection of miscellaneous procedures.  Some of them
 * perform simple system calls.  Some others do a little part of system calls
 * that are mostly performed by the Memory Manager.
 *
 * The entry points into this file are
 *   do_dup:	perform the DUP system call
 *   do_sync:	perform the SYNC system call
 *   do_fork:	adjust the tables after MM has performed a FORK system call
 *   do_exit:	a process has exited; note that in the tables
 *   do_set:	set uid or gid for some process
 *   do_revive:	revive a process that was waiting for something (e.g. TTY)
 */

#include "../h/const.h"
#include "../h/type.h"
#include "../h/callnr.h"
#include "../h/com.h"
#include "../h/error.h"
#include "const.h"
#include "type.h"
#include "buf.h"
#include "dev.h"
#include "file.h"
#include "fproc.h"
#include "glo.h"
#include "inode.h"
#include "param.h"
#include "super.h"

/*===========================================================================*
 *				do_dup					     *
 *===========================================================================*/
PUBLIC int do_dup()
{
/* Perform the dup(fd) or dup(fd,fd2) system call. */

  register int rfd;
  register struct fproc *rfp;
  struct filp *dummy;
  int r;
  extern struct filp *get_filp();

  /* Is the file descriptor valid? */
  rfd = fd & ~DUP_MASK;		/* kill off dup2 bit, if on */
  rfp = fp;
  if (get_filp(rfd) == NIL_FILP) return(err_code);

  /* Distinguish between dup and dup2. */
  if (fd == rfd) {			/* bit not on */
	/* dup(fd) */
	if ( (r = get_fd(0, &fd2, &dummy)) != OK) return(r);
  } else {
	/* dup2(fd, fd2) */
	if (fd2 < 0 || fd2 >= NR_FDS) return(EBADF);
	if (rfd == fd2) return(fd2);	/* ignore the call: dup2(x, x) */
	fd = fd2;		/* prepare to close fd2 */
	do_close();		/* cannot fail */
  }

  /* Success. Set up new file descriptors. */
  rfp->fp_filp[fd2] = rfp->fp_filp[rfd];
  rfp->fp_filp[fd2]->filp_count++;
  return(fd2);
}


/*===========================================================================*
 *				do_sync					     *
 *===========================================================================*/
PUBLIC int do_sync()
{
/* Perform the sync() system call.  Flush all the tables. */

  register struct inode *rip;
  register struct buf *bp;
  register struct super_block *sp;
  dev_nr d;
  extern real_time clock_time();
  extern struct super_block *get_super();

  /* The order in which the various tables are flushed is critical.  The
   * blocks must be flushed last, since rw_inode() and rw_super() leave their
   * results in the block cache.
   */

  /* Update the time in the root super_block. */
  sp = get_super(ROOT_DEV);
  sp->s_time = clock_time();
  if (sp->s_rd_only == FALSE) sp->s_dirt = DIRTY;

  /* Write all the dirty inodes to the disk. */
  for (rip = &inode[0]; rip < &inode[NR_INODES]; rip++)
	if (rip->i_count > 0 && rip->i_dirt == DIRTY) rw_inode(rip, WRITING);

  /* Write all the dirty super_blocks to the disk. */
  for (sp = &super_block[0]; sp < &super_block[NR_SUPERS]; sp++)
	if (sp->s_dev != NO_DEV && sp->s_dirt == DIRTY) rw_super(sp, WRITING);

  /* Write all the dirty blocks to the disk. First do drive 0, then the rest.
   * This avoids starting drive 0, then starting drive 1, etc.
   */
  for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) {
	d = bp->b_dev;
	if (d != NO_DEV && bp->b_dirt == DIRTY && ((d>>MINOR) & BYTE) == 0) 
		rw_block(bp, WRITING);
  }

  for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++) {
	d = bp->b_dev;
	if (d != NO_DEV && bp->b_dirt == DIRTY && ((d>>MINOR) & BYTE) != 0) 
		rw_block(bp, WRITING);
  }

  return(OK);		/* sync() can't fail */
}


/*===========================================================================*
 *				do_fork					     *
 *===========================================================================*/
PUBLIC int do_fork()
{
/* Perform those aspects of the fork() system call that relate to files.
 * In particular, let the child inherit its parents file descriptors.
 * The parent and child parameters tell who forked off whom. The file
 * system uses the same slot numbers as the kernel.  Only MM makes this call.
 */

  register struct fproc *cp;
  register char *sptr, *dptr;
  int i;

  /* Only MM may make this call directly. */
  if (who != MM_PROC_NR) return(ERROR);

  /* Copy the parent's fproc struct to the child. */
  sptr = (char *) &fproc[parent];	/* pointer to parent's 'fproc' struct */
  dptr = (char *) &fproc[child];	/* pointer to child's 'fproc' struct */
  i = sizeof(struct fproc);		/* how many bytes to copy */
  while (i--) *dptr++ = *sptr++;	/* fproc[child] = fproc[parent] */

  /* Increase the counters in the 'filp' table. */
  cp = &fproc[child];
  for (i = 0; i < NR_FDS; i++)
	if (cp->fp_filp[i] != NIL_FILP) cp->fp_filp[i]->filp_count++;

  /* Record the fact that both root and working dir have another user. */
  dup_inode(cp->fp_rootdir);
  dup_inode(cp->fp_workdir);
  return(OK);
}


/*===========================================================================*
 *				do_exit					     *
 *===========================================================================*/
PUBLIC int do_exit()
{
/* Perform the file system portion of the exit(status) system call. */

  register int i, exitee;

  /* Only MM may do the EXIT call directly. */
  if (who != MM_PROC_NR) return(ERROR);

  /* Nevertheless, pretend that the call came from the user. */
  fp = &fproc[slot1];		/* get_filp() needs 'fp' */
  exitee = slot1;

  /* Loop on file descriptors, closing any that are open. */
  for (i=0; i < NR_FDS; i++) {
	fd = i;
	do_close();
  }

  /* Release root and working directories. */
  put_inode(fp->fp_rootdir);
  put_inode(fp->fp_workdir);

  if (fp->fp_suspended == SUSPENDED) {
	if (fp->fp_task == XPIPE) susp_count--;
	pro = exitee;
	do_unpause();
	fp->fp_suspended = NOT_SUSPENDED;
  }
  return(OK);
}


/*===========================================================================*
 *				do_set					     *
 *===========================================================================*/
PUBLIC int do_set()
{
/* Set uid or gid field. */

  register struct fproc *tfp;

  /* Only MM may make this call directly. */
  if (who != MM_PROC_NR) return(ERROR);

  tfp = &fproc[slot1];
  if (fs_call == SETUID) {
	tfp->fp_realuid = (uid) real_user_id;
	tfp->fp_effuid =  (uid) eff_user_id;
  }
  if (fs_call == SETGID) {
	tfp->fp_effgid =  (gid) eff_grp_id;
	tfp->fp_realgid = (gid) real_grp_id;
  }
  return(OK);
}


/*===========================================================================*
 *				do_revive				     *
 *===========================================================================*/
PUBLIC int do_revive()
{
/* A task, typically TTY, has now gotten the characters that were needed for a
 * previous read.  The process did not get a reply when it made the call.
 * Instead it was suspended.  Now we can send the reply to wake it up.  This
 * business has to be done carefully, since the incoming message is from
 * a task (to which no reply can be sent), and the reply must go to a process
 * that blocked earlier.  The reply to the caller is inhibited by setting the
 * 'dont_reply' flag, and the reply to the blocked process is done explicitly
 * in revive().
 */

  if (who > 0) return(EPERM);
  revive(m.REP_PROC_NR, m.REP_STATUS);
  dont_reply = TRUE;		/* don't reply to the TTY task */
  return(OK);
}