. change cloexec mask from long to fd_set to remove 32 fd's per process restriction (from cloexec at least)
827 lines
22 KiB
C
827 lines
22 KiB
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_fsync: perform the FSYNC system call
|
|
* pm_reboot: sync disks and prepare for shutdown
|
|
* pm_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
|
|
* pm_setgid: set group ids for some process
|
|
* pm_setuid: set user ids for some process
|
|
* do_svrctl: file system control
|
|
* do_getsysinfo: request copy of FS data structure
|
|
* pm_dumpcore: create a core dump
|
|
*/
|
|
|
|
#include "fs.h"
|
|
#include <fcntl.h>
|
|
#include <assert.h>
|
|
#include <unistd.h> /* cc runs out of memory with unistd.h :-( */
|
|
#include <minix/callnr.h>
|
|
#include <minix/safecopies.h>
|
|
#include <minix/endpoint.h>
|
|
#include <minix/com.h>
|
|
#include <sys/ptrace.h>
|
|
#include <sys/svrctl.h>
|
|
#include "buf.h"
|
|
#include "file.h"
|
|
#include "fproc.h"
|
|
#include "inode.h"
|
|
#include "param.h"
|
|
#include "super.h"
|
|
|
|
#define CORE_NAME "core"
|
|
#define CORE_MODE 0777 /* mode to use on core image files */
|
|
|
|
FORWARD _PROTOTYPE( void free_proc, (struct fproc *freed, int flags));
|
|
FORWARD _PROTOTYPE( int dumpcore, (int proc_e, struct mem_map *seg_ptr));
|
|
FORWARD _PROTOTYPE( int write_bytes, (struct inode *rip, off_t off,
|
|
char *buf, size_t bytes));
|
|
FORWARD _PROTOTYPE( int write_seg, (struct inode *rip, off_t off, int proc_e,
|
|
int seg, off_t seg_off, phys_bytes seg_bytes));
|
|
|
|
#define FP_EXITING 1
|
|
|
|
/*===========================================================================*
|
|
* do_getsysinfo *
|
|
*===========================================================================*/
|
|
PUBLIC int do_getsysinfo()
|
|
{
|
|
struct fproc *proc_addr;
|
|
vir_bytes src_addr, dst_addr;
|
|
size_t len;
|
|
int s;
|
|
|
|
if (!super_user)
|
|
{
|
|
printf("FS: unauthorized call of do_getsysinfo by proc %d\n", who_e);
|
|
return(EPERM); /* only su may call do_getsysinfo. This call may leak
|
|
* information (and is not stable enough to be part
|
|
* of the API/ABI).
|
|
*/
|
|
}
|
|
|
|
switch(m_in.info_what) {
|
|
case SI_PROC_ADDR:
|
|
proc_addr = &fproc[0];
|
|
src_addr = (vir_bytes) &proc_addr;
|
|
len = sizeof(struct fproc *);
|
|
break;
|
|
case SI_PROC_TAB:
|
|
src_addr = (vir_bytes) fproc;
|
|
len = sizeof(struct fproc) * NR_PROCS;
|
|
break;
|
|
case SI_DMAP_TAB:
|
|
src_addr = (vir_bytes) dmap;
|
|
len = sizeof(struct dmap) * NR_DEVICES;
|
|
break;
|
|
default:
|
|
return(EINVAL);
|
|
}
|
|
|
|
dst_addr = (vir_bytes) m_in.info_where;
|
|
if (OK != (s=sys_datacopy(SELF, src_addr, who_e, dst_addr, len)))
|
|
return(s);
|
|
return(OK);
|
|
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* 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 = m_in.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 (m_in.fd == rfd) { /* bit not on */
|
|
/* dup(fd) */
|
|
if ( (r = get_fd(0, 0, &m_in.fd2, &dummy)) != OK) return(r);
|
|
} else {
|
|
/* dup2(fd, fd2) */
|
|
if (m_in.fd2 < 0 || m_in.fd2 >= OPEN_MAX) return(EBADF);
|
|
if (rfd == m_in.fd2) return(m_in.fd2); /* ignore the call: dup2(x, x) */
|
|
m_in.fd = m_in.fd2; /* prepare to close fd2 */
|
|
(void) do_close(); /* cannot fail */
|
|
}
|
|
|
|
/* Success. Set up new file descriptors. */
|
|
f->filp_count++;
|
|
fp->fp_filp[m_in.fd2] = f;
|
|
FD_SET(m_in.fd2, &fp->fp_filp_inuse);
|
|
return(m_in.fd2);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* do_fcntl *
|
|
*===========================================================================*/
|
|
PUBLIC int do_fcntl()
|
|
{
|
|
/* Perform the fcntl(fd, request, ...) system call. */
|
|
|
|
register struct filp *f;
|
|
int new_fd, r, fl;
|
|
struct filp *dummy;
|
|
|
|
/* Is the file descriptor valid? */
|
|
if ((f = get_filp(m_in.fd)) == NIL_FILP) return(err_code);
|
|
|
|
switch (m_in.request) {
|
|
case F_DUPFD:
|
|
/* This replaces the old dup() system call. */
|
|
if (m_in.addr < 0 || m_in.addr >= OPEN_MAX) return(EINVAL);
|
|
if ((r = get_fd(m_in.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( FD_ISSET(m_in.fd, &fp->fp_cloexec_set) ? FD_CLOEXEC : 0);
|
|
|
|
case F_SETFD:
|
|
/* Set close-on-exec flag (FD_CLOEXEC in POSIX Table 6-2). */
|
|
if(m_in.addr & FD_CLOEXEC)
|
|
FD_SET(m_in.fd, &fp->fp_cloexec_set);
|
|
else
|
|
FD_CLR(m_in.fd, &fp->fp_cloexec_set);
|
|
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) | (m_in.addr & fl);
|
|
return(OK);
|
|
|
|
case F_GETLK:
|
|
case F_SETLK:
|
|
case F_SETLKW:
|
|
/* Set or clear a file lock. */
|
|
r = lock_op(f, m_in.request);
|
|
return(r);
|
|
|
|
case F_FREESP:
|
|
{
|
|
/* Free a section of a file. Preparation is done here,
|
|
* actual freeing in freesp_inode().
|
|
*/
|
|
off_t start, end;
|
|
struct flock flock_arg;
|
|
signed long offset;
|
|
|
|
/* Check if it's a regular file. */
|
|
if((f->filp_ino->i_mode & I_TYPE) != I_REGULAR) {
|
|
return EINVAL;
|
|
}
|
|
|
|
/* Copy flock data from userspace. */
|
|
if((r = sys_datacopy(who_e, (vir_bytes) m_in.name1,
|
|
SELF, (vir_bytes) &flock_arg,
|
|
(phys_bytes) sizeof(flock_arg))) != OK)
|
|
return r;
|
|
|
|
/* Convert starting offset to signed. */
|
|
offset = (signed long) flock_arg.l_start;
|
|
|
|
/* Figure out starting position base. */
|
|
switch(flock_arg.l_whence) {
|
|
case SEEK_SET: start = 0; if(offset < 0) return EINVAL; break;
|
|
case SEEK_CUR: start = f->filp_pos; break;
|
|
case SEEK_END: start = f->filp_ino->i_size; break;
|
|
default: return EINVAL;
|
|
}
|
|
|
|
/* Check for overflow or underflow. */
|
|
if(offset > 0 && start + offset < start) { return EINVAL; }
|
|
if(offset < 0 && start + offset > start) { return EINVAL; }
|
|
start += offset;
|
|
if(flock_arg.l_len > 0) {
|
|
end = start + flock_arg.l_len;
|
|
if(end <= start) {
|
|
return EINVAL;
|
|
}
|
|
r = freesp_inode(f->filp_ino, start, end);
|
|
} else {
|
|
r = truncate_inode(f->filp_ino, start);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
default:
|
|
return(EINVAL);
|
|
}
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* do_sync *
|
|
*===========================================================================*/
|
|
PUBLIC int do_sync()
|
|
{
|
|
/* Perform the sync() system call. Flush all the tables.
|
|
* 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.
|
|
*/
|
|
register struct inode *rip;
|
|
register struct buf *bp;
|
|
|
|
/* 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_fsync *
|
|
*===========================================================================*/
|
|
PUBLIC int do_fsync()
|
|
{
|
|
/* Perform the fsync() system call. For now, don't be unnecessarily smart. */
|
|
|
|
do_sync();
|
|
|
|
return(OK);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pm_reboot *
|
|
*===========================================================================*/
|
|
PUBLIC void pm_reboot()
|
|
{
|
|
/* Perform the FS side of the reboot call. */
|
|
int i;
|
|
struct super_block *sp;
|
|
struct inode dummy;
|
|
|
|
/* Do exit processing for all leftover processes and servers,
|
|
* but don't actually exit them (if they were really gone, PM
|
|
* will tell us about it).
|
|
*/
|
|
for (i = 0; i < NR_PROCS; i++)
|
|
if((m_in.endpt1 = fproc[i].fp_endpoint) != NONE)
|
|
free_proc(&fproc[i], 0);
|
|
|
|
/* The root file system is mounted onto itself, which keeps it from being
|
|
* unmounted. Pull an inode out of thin air and put the root on it.
|
|
*/
|
|
put_inode(super_block[0].s_imount);
|
|
super_block[0].s_imount= &dummy;
|
|
dummy.i_count = 2; /* expect one "put" */
|
|
|
|
/* Unmount all filesystems. File systems are mounted on other file systems,
|
|
* so you have to pull off the loose bits repeatedly to get it all undone.
|
|
*/
|
|
for (i= 0; i < NR_SUPERS; i++) {
|
|
/* Unmount at least one. */
|
|
for (sp= &super_block[0]; sp < &super_block[NR_SUPERS]; sp++) {
|
|
if (sp->s_dev != NO_DEV) (void) unmount(sp->s_dev);
|
|
}
|
|
}
|
|
|
|
/* Sync any unwritten buffers. */
|
|
do_sync();
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pm_fork *
|
|
*===========================================================================*/
|
|
PUBLIC void pm_fork(pproc, cproc, cpid)
|
|
int pproc; /* Parent process */
|
|
int cproc; /* Child process */
|
|
int cpid; /* Child process id */
|
|
{
|
|
/* 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.
|
|
*/
|
|
|
|
register struct fproc *cp;
|
|
int i, parentno, childno;
|
|
|
|
/* Check up-to-dateness of fproc. */
|
|
okendpt(pproc, &parentno);
|
|
|
|
/* PM gives child endpoint, which implies process slot information.
|
|
* Don't call isokendpt, because that will verify if the endpoint
|
|
* number is correct in fproc, which it won't be.
|
|
*/
|
|
childno = _ENDPOINT_P(cproc);
|
|
if(childno < 0 || childno >= NR_PROCS)
|
|
panic(__FILE__, "FS: bogus child for forking", m_in.child_endpt);
|
|
if(fproc[childno].fp_pid != PID_FREE)
|
|
panic(__FILE__, "FS: forking on top of in-use child", childno);
|
|
|
|
/* Copy the parent's fproc struct to the child. */
|
|
fproc[childno] = fproc[parentno];
|
|
|
|
/* Increase the counters in the 'filp' table. */
|
|
cp = &fproc[childno];
|
|
for (i = 0; i < OPEN_MAX; i++)
|
|
if (cp->fp_filp[i] != NIL_FILP) cp->fp_filp[i]->filp_count++;
|
|
|
|
/* Fill in new process and endpoint id. */
|
|
cp->fp_pid = cpid;
|
|
cp->fp_endpoint = cproc;
|
|
|
|
/* A forking process never has an outstanding grant,
|
|
* as it isn't blocking on i/o.
|
|
*/
|
|
assert(!GRANT_VALID(fp->fp_grant));
|
|
assert(!GRANT_VALID(cp->fp_grant));
|
|
|
|
/* A child is not a process leader. */
|
|
cp->fp_sesldr = 0;
|
|
|
|
/* This child has not exec()ced yet. */
|
|
cp->fp_execced = 0;
|
|
|
|
/* Record the fact that both root and working dir have another user. */
|
|
dup_inode(cp->fp_rootdir);
|
|
dup_inode(cp->fp_workdir);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* free_proc *
|
|
*===========================================================================*/
|
|
PRIVATE void free_proc(struct fproc *exiter, int flags)
|
|
{
|
|
int i, task;
|
|
register struct fproc *rfp;
|
|
register struct filp *rfilp;
|
|
register struct inode *rip;
|
|
dev_t dev;
|
|
|
|
fp = exiter; /* get_filp() needs 'fp' */
|
|
|
|
if (fp->fp_suspended == SUSPENDED) {
|
|
task = -fp->fp_task;
|
|
if (task == XPIPE || task == XPOPEN) susp_count--;
|
|
unpause(fp->fp_endpoint);
|
|
fp->fp_suspended = NOT_SUSPENDED;
|
|
}
|
|
|
|
/* Loop on file descriptors, closing any that are open. */
|
|
for (i = 0; i < OPEN_MAX; i++) {
|
|
(void) close_fd(fp, i);
|
|
}
|
|
|
|
/* 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;
|
|
|
|
/* Check if any process is SUSPENDed on this driver.
|
|
* If a driver exits, unmap its entries in the dmap table.
|
|
* (unmapping has to be done after the first step, because the
|
|
* dmap table is used in the first step.)
|
|
*/
|
|
unsuspend_by_endpt(fp->fp_endpoint);
|
|
|
|
/* The rest of these actions is only done when processes actually
|
|
* exit.
|
|
*/
|
|
if(!(flags & FP_EXITING))
|
|
return;
|
|
|
|
/* Invalidate endpoint number for error and sanity checks. */
|
|
fp->fp_endpoint = NONE;
|
|
|
|
/* If a session leader exits and it has a controlling tty, then revoke
|
|
* access to its controlling tty from all other processes using it.
|
|
*/
|
|
if (fp->fp_sesldr && fp->fp_tty != 0) {
|
|
|
|
dev = fp->fp_tty;
|
|
|
|
for (rfp = &fproc[0]; rfp < &fproc[NR_PROCS]; rfp++) {
|
|
if(rfp->fp_pid == PID_FREE) continue;
|
|
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_close(dev);
|
|
rfilp->filp_mode = FILP_CLOSED;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Exit done. Mark slot as free. */
|
|
fp->fp_pid = PID_FREE;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pm_exit *
|
|
*===========================================================================*/
|
|
PUBLIC void pm_exit(proc)
|
|
int proc;
|
|
{
|
|
int exitee_p;
|
|
/* Perform the file system portion of the exit(status) system call. */
|
|
|
|
/* Nevertheless, pretend that the call came from the user. */
|
|
okendpt(proc, &exitee_p);
|
|
free_proc(&fproc[exitee_p], FP_EXITING);
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* pm_setgid *
|
|
*===========================================================================*/
|
|
PUBLIC void pm_setgid(proc_e, egid, rgid)
|
|
int proc_e;
|
|
int egid;
|
|
int rgid;
|
|
{
|
|
register struct fproc *tfp;
|
|
int slot;
|
|
|
|
okendpt(proc_e, &slot);
|
|
tfp = &fproc[slot];
|
|
|
|
tfp->fp_effgid = egid;
|
|
tfp->fp_realgid = rgid;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* pm_setuid *
|
|
*===========================================================================*/
|
|
PUBLIC void pm_setuid(proc_e, euid, ruid)
|
|
int proc_e;
|
|
int euid;
|
|
int ruid;
|
|
{
|
|
register struct fproc *tfp;
|
|
int slot;
|
|
|
|
okendpt(proc_e, &slot);
|
|
tfp = &fproc[slot];
|
|
|
|
tfp->fp_effuid = euid;
|
|
tfp->fp_realuid = ruid;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* do_svrctl *
|
|
*===========================================================================*/
|
|
PUBLIC int do_svrctl()
|
|
{
|
|
switch (m_in.svrctl_req) {
|
|
case FSSIGNON: {
|
|
/* A server in user space calls in to manage a device. */
|
|
struct fssignon device;
|
|
int r, major, proc_nr_n;
|
|
|
|
if (fp->fp_effuid != SU_UID && fp->fp_effuid != SERVERS_UID)
|
|
return(EPERM);
|
|
|
|
/* Try to copy request structure to FS. */
|
|
if ((r = sys_datacopy(who_e, (vir_bytes) m_in.svrctl_argp,
|
|
FS_PROC_NR, (vir_bytes) &device,
|
|
(phys_bytes) sizeof(device))) != OK)
|
|
return(r);
|
|
|
|
if (isokendpt(who_e, &proc_nr_n) != OK)
|
|
return(EINVAL);
|
|
|
|
/* Try to update device mapping. */
|
|
major = (device.dev >> MAJOR) & BYTE;
|
|
r=map_driver(major, who_e, device.style, 0 /* !force */);
|
|
if (r == OK)
|
|
{
|
|
/* If a driver has completed its exec(), it can be announced
|
|
* to be up.
|
|
*/
|
|
if(fproc[proc_nr_n].fp_execced) {
|
|
dev_up(major);
|
|
} else {
|
|
dmap[major].dmap_flags |= DMAP_BABY;
|
|
}
|
|
}
|
|
|
|
return(r);
|
|
}
|
|
case FSDEVUNMAP: {
|
|
struct fsdevunmap fdu;
|
|
int r, major;
|
|
/* Try to copy request structure to FS. */
|
|
if ((r = sys_datacopy(who_e, (vir_bytes) m_in.svrctl_argp,
|
|
FS_PROC_NR, (vir_bytes) &fdu,
|
|
(phys_bytes) sizeof(fdu))) != OK)
|
|
return(r);
|
|
major = (fdu.dev >> MAJOR) & BYTE;
|
|
r=map_driver(major, NONE, 0, 0);
|
|
return(r);
|
|
}
|
|
default:
|
|
return(EINVAL);
|
|
}
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* pm_dumpcore *
|
|
*===========================================================================*/
|
|
PUBLIC int pm_dumpcore(proc_e, seg_ptr)
|
|
int proc_e;
|
|
struct mem_map *seg_ptr;
|
|
{
|
|
int r, proc_s;
|
|
|
|
r= dumpcore(proc_e, seg_ptr);
|
|
|
|
/* Terminate the process */
|
|
okendpt(proc_e, &proc_s);
|
|
free_proc(&fproc[proc_s], FP_EXITING);
|
|
|
|
return r;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* dumpcore *
|
|
*===========================================================================*/
|
|
PRIVATE int dumpcore(proc_e, seg_ptr)
|
|
int proc_e;
|
|
struct mem_map *seg_ptr;
|
|
{
|
|
int r, seg, proc_s, exists;
|
|
mode_t omode;
|
|
vir_bytes len;
|
|
off_t off, seg_off;
|
|
long trace_off, trace_data;
|
|
struct fproc *rfp;
|
|
struct inode *rip, *ldirp;
|
|
struct mem_map segs[NR_LOCAL_SEGS];
|
|
|
|
okendpt(proc_e, &proc_s);
|
|
rfp= fp= &fproc[proc_s];
|
|
who_e= proc_e;
|
|
who_p= proc_s;
|
|
super_user = (fp->fp_effuid == SU_UID ? TRUE : FALSE); /* su? */
|
|
|
|
/* We need the equivalent of
|
|
* open(CORE_NAME, O_WRONLY|O_CREAT|O_TRUNC|O_NONBLOCK, CORE_MODE)
|
|
*/
|
|
|
|
/* Create a new inode by calling new_node(). */
|
|
omode = I_REGULAR | (CORE_MODE & ALL_MODES & rfp->fp_umask);
|
|
rip = new_node(&ldirp, CORE_NAME, omode, NO_ZONE, 0, NULL);
|
|
r = err_code;
|
|
put_inode(ldirp);
|
|
exists= (r == EEXIST);
|
|
if (r != OK && r != EEXIST) return(r); /* error */
|
|
|
|
/* Only do the normal open code if we didn't just create the file. */
|
|
if (exists) {
|
|
/* Check protections. */
|
|
r = forbidden(rip, W_BIT);
|
|
if (r != OK)
|
|
{
|
|
put_inode(rip);
|
|
return r;
|
|
}
|
|
|
|
/* Make sure it is a regular file */
|
|
switch (rip->i_mode & I_TYPE) {
|
|
case I_REGULAR:
|
|
break;
|
|
|
|
case I_DIRECTORY:
|
|
/* Directories may be read but not written. */
|
|
r = EISDIR;
|
|
break;
|
|
|
|
case I_CHAR_SPECIAL:
|
|
case I_BLOCK_SPECIAL:
|
|
case I_NAMED_PIPE:
|
|
r = EPERM;
|
|
break;
|
|
}
|
|
|
|
if (r != OK)
|
|
{
|
|
put_inode(rip);
|
|
return r;
|
|
}
|
|
|
|
/* Truncate the file */
|
|
truncate_inode(rip, 0);
|
|
wipe_inode(rip);
|
|
/* Send the inode from the inode cache to the
|
|
* block cache, so it gets written on the next
|
|
* cache flush.
|
|
*/
|
|
rw_inode(rip, WRITING);
|
|
}
|
|
|
|
/* Copy segments from PM */
|
|
r= sys_datacopy(PM_PROC_NR, (vir_bytes)seg_ptr,
|
|
SELF, (vir_bytes)segs, sizeof(segs));
|
|
if (r != OK) panic(__FILE__, "dumpcore: cannot copy segment info", r);
|
|
|
|
off= 0;
|
|
r= write_bytes(rip, off, (char *)segs, sizeof(segs));
|
|
if (r != OK)
|
|
{
|
|
put_inode(rip);
|
|
return r;
|
|
}
|
|
off += sizeof(segs);
|
|
|
|
/* Write out the whole kernel process table entry to get the regs. */
|
|
for (trace_off= 0;; trace_off += sizeof(long))
|
|
{
|
|
r= sys_trace(T_GETUSER, proc_e, trace_off, &trace_data);
|
|
if (r != OK)
|
|
{
|
|
printf("dumpcore pid %d: sys_trace failed "
|
|
"at offset %ld: %d\n",
|
|
rfp->fp_pid, trace_off, r);
|
|
break;
|
|
}
|
|
r= write_bytes(rip, off, (char *)&trace_data,
|
|
sizeof(trace_data));
|
|
if (r != OK)
|
|
{
|
|
put_inode(rip);
|
|
return r;
|
|
}
|
|
off += sizeof(trace_data);
|
|
}
|
|
|
|
/* Loop through segments and write the segments themselves out. */
|
|
for (seg = 0; seg < NR_LOCAL_SEGS; seg++) {
|
|
len= segs[seg].mem_len << CLICK_SHIFT;
|
|
seg_off= segs[seg].mem_vir << CLICK_SHIFT;
|
|
r= write_seg(rip, off, proc_e, seg, seg_off, len);
|
|
if (r != OK)
|
|
{
|
|
put_inode(rip);
|
|
return r;
|
|
}
|
|
off += len;
|
|
}
|
|
|
|
rip->i_size= off;
|
|
rip->i_dirt = DIRTY;
|
|
|
|
put_inode(rip);
|
|
return OK;
|
|
}
|
|
|
|
|
|
/*===========================================================================*
|
|
* write_bytes *
|
|
*===========================================================================*/
|
|
PRIVATE int write_bytes(rip, off, buf, bytes)
|
|
struct inode *rip; /* inode descriptor to read from */
|
|
off_t off; /* offset in file */
|
|
char *buf;
|
|
size_t bytes; /* how much is to be transferred? */
|
|
{
|
|
int block_size;
|
|
off_t n, o, b_off;
|
|
block_t b;
|
|
struct buf *bp;
|
|
|
|
block_size= rip->i_sp->s_block_size;
|
|
for (o= off - (off % block_size); o < off+bytes; o += block_size)
|
|
{
|
|
if (o < off)
|
|
b_off= off-o;
|
|
else
|
|
b_off= 0;
|
|
n= block_size-b_off;
|
|
if (o+b_off+n > off+bytes)
|
|
n= off+bytes-(o+b_off);
|
|
|
|
b = read_map(rip, o);
|
|
|
|
if (b == NO_BLOCK) {
|
|
/* Writing to a nonexistent block. Create and enter
|
|
* in inode.
|
|
*/
|
|
if ((bp= new_block(rip, o)) == NIL_BUF)
|
|
return(err_code);
|
|
}
|
|
else
|
|
{
|
|
/* Just read the block, no need to optimize for
|
|
* writing entire blocks.
|
|
*/
|
|
bp = get_block(rip->i_dev, b, NORMAL);
|
|
}
|
|
|
|
if (n != block_size && o >= rip->i_size && b_off == 0) {
|
|
zero_block(bp);
|
|
}
|
|
|
|
/* Copy a chunk from user space to the block buffer. */
|
|
memcpy((bp->b_data+b_off), buf, n);
|
|
bp->b_dirt = DIRTY;
|
|
if (b_off + n == block_size)
|
|
put_block(bp, FULL_DATA_BLOCK);
|
|
else
|
|
put_block(bp, PARTIAL_DATA_BLOCK);
|
|
|
|
buf += n;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*===========================================================================*
|
|
* write_seg *
|
|
*===========================================================================*/
|
|
PRIVATE int write_seg(rip, off, proc_e, seg, seg_off, seg_bytes)
|
|
struct inode *rip; /* inode descriptor to read from */
|
|
off_t off; /* offset in file */
|
|
int proc_e; /* process number (endpoint) */
|
|
int seg; /* T, D, or S */
|
|
off_t seg_off; /* Offset in segment */
|
|
phys_bytes seg_bytes; /* how much is to be transferred? */
|
|
{
|
|
int r, block_size, fl;
|
|
off_t n, o, b_off;
|
|
block_t b;
|
|
struct buf *bp;
|
|
|
|
block_size= rip->i_sp->s_block_size;
|
|
for (o= off - (off % block_size); o < off+seg_bytes; o += block_size)
|
|
{
|
|
if (o < off)
|
|
b_off= off-o;
|
|
else
|
|
b_off= 0;
|
|
n= block_size-b_off;
|
|
if (o+b_off+n > off+seg_bytes)
|
|
n= off+seg_bytes-(o+b_off);
|
|
|
|
b = read_map(rip, o);
|
|
if (b == NO_BLOCK) {
|
|
/* Writing to a nonexistent block. Create and enter in inode.*/
|
|
if ((bp= new_block(rip, o)) == NIL_BUF)
|
|
return(err_code);
|
|
} else {
|
|
/* Normally an existing block to be partially overwritten is
|
|
* first read in. However, a full block need not be read in.
|
|
* If it is already in the cache, acquire it, otherwise just
|
|
* acquire a free buffer.
|
|
*/
|
|
fl = (n == block_size ? NO_READ : NORMAL);
|
|
bp = get_block(rip->i_dev, b, fl);
|
|
}
|
|
|
|
if (n != block_size && o >= rip->i_size && b_off == 0) {
|
|
zero_block(bp);
|
|
}
|
|
|
|
/* Copy a chunk from user space to the block buffer. */
|
|
r = sys_vircopy(proc_e, seg, (phys_bytes) seg_off,
|
|
FS_PROC_NR, D, (phys_bytes) (bp->b_data+b_off),
|
|
(phys_bytes) n);
|
|
bp->b_dirt = DIRTY;
|
|
fl = (b_off + n == block_size ? FULL_DATA_BLOCK : PARTIAL_DATA_BLOCK);
|
|
put_block(bp, fl);
|
|
|
|
seg_off += n;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
|