Minix2.0/src/fs/misc.c
/* 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_fcntl: perform the FCNTL system call
* do_sync: perform the SYNC system call
* do_fork: adjust the tables after MM has performed a FORK system call
* do_exec: handle files with FD_CLOEXEC on after MM has done an EXEC
* 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 "fs.h"
#include <fcntl.h>
#include <unistd.h> /* cc runs out of memory with unistd.h :-( */
#include <minix/callnr.h>
#include <minix/com.h>
#include <minix/boot.h>
#include "buf.h"
#include "file.h"
#include "fproc.h"
#include "inode.h"
#include "dev.h"
#include "param.h"
/*===========================================================================*
* do_dup *
*===========================================================================*/
PUBLIC int do_dup()
{
/* Perform the dup(fd) or dup2(fd,fd2) system call. These system calls are
* obsolete. In fact, it is not even possible to invoke them using the
* current library because the library routines call fcntl(). They are
* provided to permit old binary programs to continue to run.
*/
register int rfd;
register struct filp *f;
struct filp *dummy;
int r;
/* Is the file descriptor valid? */
rfd = fd & ~DUP_MASK; /* kill off dup2 bit, if on */
if ((f = 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, 0, &fd2, &dummy)) != OK) return(r);
} else {
/* dup2(fd, fd2) */
if (fd2 < 0 || fd2 >= OPEN_MAX) return(EBADF);
if (rfd == fd2) return(fd2); /* ignore the call: dup2(x, x) */
fd = fd2; /* prepare to close fd2 */
(void) do_close(); /* cannot fail */
}
/* Success. Set up new file descriptors. */
f->filp_count++;
fp->fp_filp[fd2] = f;
return(fd2);
}
/*===========================================================================*
* do_fcntl *
*===========================================================================*/
PUBLIC int do_fcntl()
{
/* Perform the fcntl(fd, request, ...) system call. */
register struct filp *f;
int new_fd, r, fl;
long cloexec_mask; /* bit map for the FD_CLOEXEC flag */
long clo_value; /* FD_CLOEXEC flag in proper position */
struct filp *dummy;
/* Is the file descriptor valid? */
if ((f = get_filp(fd)) == NIL_FILP) return(err_code);
switch (request) {
case F_DUPFD:
/* This replaces the old dup() system call. */
if (addr < 0 || addr >= OPEN_MAX) return(EINVAL);
if ((r = get_fd(addr, 0, &new_fd, &dummy)) != OK) return(r);
f->filp_count++;
fp->fp_filp[new_fd] = f;
return(new_fd);
case F_GETFD:
/* Get close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
return( ((fp->fp_cloexec >> fd) & 01) ? FD_CLOEXEC : 0);
case F_SETFD:
/* Set close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
cloexec_mask = 1L << fd; /* singleton set position ok */
clo_value = (addr & FD_CLOEXEC ? cloexec_mask : 0L);
fp->fp_cloexec = (fp->fp_cloexec & ~cloexec_mask) | clo_value;
return(OK);
case F_GETFL:
/* Get file status flags (O_NONBLOCK and O_APPEND). */
fl = f->filp_flags & (O_NONBLOCK | O_APPEND | O_ACCMODE);
return(fl);
case F_SETFL:
/* Set file status flags (O_NONBLOCK and O_APPEND). */
fl = O_NONBLOCK | O_APPEND;
f->filp_flags = (f->filp_flags & ~fl) | (addr & fl);
return(OK);
case F_GETLK:
case F_SETLK:
case F_SETLKW:
/* Set or clear a file lock. */
r = lock_op(f, request);
return(r);
default:
return(EINVAL);
}
}
/*===========================================================================*
* do_sync *
*===========================================================================*/
PUBLIC int do_sync()
{
/* Perform the sync() system call. Flush all the tables. */
register struct inode *rip;
register struct buf *bp;
/* The order in which the various tables are flushed is critical. The
* blocks must be flushed last, since rw_inode() leaves its results in
* the block cache.
*/
/* 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 blocks to the disk, one drive at a time. */
for (bp = &buf[0]; bp < &buf[NR_BUFS]; bp++)
if (bp->b_dev != NO_DEV && bp->b_dirt == DIRTY) flushall(bp->b_dev);
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 parent's 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;
int i;
/* Only MM may make this call directly. */
if (who != MM_PROC_NR) return(EGENERIC);
/* Copy the parent's fproc struct to the child. */
fproc[child] = fproc[parent];
/* Increase the counters in the 'filp' table. */
cp = &fproc[child];
for (i = 0; i < OPEN_MAX; i++)
if (cp->fp_filp[i] != NIL_FILP) cp->fp_filp[i]->filp_count++;
/* Fill in new process id. */
cp->fp_pid = pid;
/* A child is not a process leader. */
cp->fp_sesldr = 0;
/* 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_exec *
*===========================================================================*/
PUBLIC int do_exec()
{
/* Files can be marked with the FD_CLOEXEC bit (in fp->fp_cloexec). When
* MM does an EXEC, it calls FS to allow FS to find these files and close them.
*/
register int i;
long bitmap;
/* Only MM may make this call directly. */
if (who != MM_PROC_NR) return(EGENERIC);
/* The array of FD_CLOEXEC bits is in the fp_cloexec bit map. */
fp = &fproc[slot1]; /* get_filp() needs 'fp' */
bitmap = fp->fp_cloexec;
if (bitmap == 0) return(OK); /* normal case, no FD_CLOEXECs */
/* Check the file desriptors one by one for presence of FD_CLOEXEC. */
for (i = 0; i < OPEN_MAX; i++) {
fd = i;
if ( (bitmap >> i) & 01) (void) do_close();
}
return(OK);
}
/*===========================================================================*
* do_exit *
*===========================================================================*/
PUBLIC int do_exit()
{
/* Perform the file system portion of the exit(status) system call. */
register int i, exitee, task;
register struct fproc *rfp;
register struct filp *rfilp;
register struct inode *rip;
int major;
dev_t dev;
message dev_mess;
/* Only MM may do the EXIT call directly. */
if (who != MM_PROC_NR) return(EGENERIC);
/* Nevertheless, pretend that the call came from the user. */
fp = &fproc[slot1]; /* get_filp() needs 'fp' */
exitee = slot1;
if (fp->fp_suspended == SUSPENDED) {
task = -fp->fp_task;
if (task == XPIPE || task == XPOPEN) susp_count--;
pro = exitee;
(void) do_unpause(); /* this always succeeds for MM */
fp->fp_suspended = NOT_SUSPENDED;
}
/* Loop on file descriptors, closing any that are open. */
for (i = 0; i < OPEN_MAX; i++) {
fd = i;
(void) do_close();
}
/* Release root and working directories. */
put_inode(fp->fp_rootdir);
put_inode(fp->fp_workdir);
fp->fp_rootdir = NIL_INODE;
fp->fp_workdir = NIL_INODE;
/* If a session leader exits then revoke access to its controlling tty from
* all other processes using it.
*/
if (!fp->fp_sesldr) return(OK); /* not a session leader */
fp->fp_sesldr = FALSE;
if (fp->fp_tty == 0) return(OK); /* no controlling tty */
dev = fp->fp_tty;
for (rfp = &fproc[LOW_USER]; rfp < &fproc[NR_PROCS]; rfp++) {
if (rfp->fp_tty == dev) rfp->fp_tty = 0;
for (i = 0; i < OPEN_MAX; i++) {
if ((rfilp = rfp->fp_filp[i]) == NIL_FILP) continue;
if (rfilp->filp_mode == FILP_CLOSED) continue;
rip = rfilp->filp_ino;
if ((rip->i_mode & I_TYPE) != I_CHAR_SPECIAL) continue;
if ((dev_t) rip->i_zone[0] != dev) continue;
dev_mess.m_type = DEV_CLOSE;
dev_mess.DEVICE = dev;
major = (dev >> MAJOR) & BYTE; /* major device nr */
task = dmap[major].dmap_task; /* device task nr */
(*dmap[major].dmap_close)(task, &dev_mess);
rfilp->filp_mode = FILP_CLOSED;
}
}
return(OK);
}
/*===========================================================================*
* do_set *
*===========================================================================*/
PUBLIC int do_set()
{
/* Set uid_t or gid_t field. */
register struct fproc *tfp;
/* Only MM may make this call directly. */
if (who != MM_PROC_NR) return(EGENERIC);
tfp = &fproc[slot1];
if (fs_call == SETUID) {
tfp->fp_realuid = (uid_t) real_user_id;
tfp->fp_effuid = (uid_t) eff_user_id;
}
if (fs_call == SETGID) {
tfp->fp_effgid = (gid_t) eff_grp_id;
tfp->fp_realgid = (gid_t) 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 !ALLOW_USER_SEND
if (who >= LOW_USER) return(EPERM);
#endif
revive(m.REP_PROC_NR, m.REP_STATUS);
dont_reply = TRUE; /* don't reply to the TTY task */
return(OK);
}