retrobsd/sys/include/systm.h

/*
 * Copyright (c) 1986 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

/*
 * The `securelevel' variable controls the security level of the system.
 * It can only be decreased by process 1 (/sbin/init).
 *
 * Security levels are as follows:
 *   -1 permannently insecure mode - always run system in level 0 mode.
 *    0 insecure mode - immutable and append-only flags make be turned off.
 *  All devices may be read or written subject to permission modes.
 *    1 secure mode - immutable and append-only flags may not be changed;
 *  raw disks of mounted filesystems, /dev/mem, and /dev/kmem are
 *  read-only.
 *    2 highly secure mode - same as (1) plus raw disks are always
 *  read-only whether mounted or not. This level precludes tampering
 *  with filesystems by unmounting them, but also inhibits running
 *  newfs while the system is secured.
 *
 * In normal operation, the system runs in level 0 mode while single user
 * and in level 1 mode while multiuser. If level 2 mode is desired while
 * running multiuser, it can be set in the multiuser startup script
 * (/etc/rc.local) using sysctl(8). If it is desired to run the system
 * in level 0 mode while multiuser, initialize the variable securelevel
 * in /sys/kern/kern_sysctl.c to -1. Note that it is NOT initialized to
 * zero as that would allow the vmunix binary to be patched to -1.
 * Without initialization, securelevel loads in the BSS area which only
 * comes into existence when the kernel is loaded and hence cannot be
 * patched by a stalking hacker.
 */
#include "conf.h"

extern int securelevel;         /* system security level */

extern const char version[];    /* system version */

/*
 * Nblkdev is the number of entries (rows) in the block switch.
 * Used in bounds checking on major device numbers.
 */
extern const int nblkdev;

/*
 * Number of character switch entries.
 */
extern const int nchrdev;

/*
 * Number of system call entries.
 */
extern const int nsysent;

extern int  mpid;                   /* generic for unique process id's */
extern char runin;                  /* scheduling flag */
extern char runout;                 /* scheduling flag */
extern int  runrun;                 /* scheduling flag */
extern char curpri;                 /* more scheduling */

extern u_int    swapstart, nswap;   /* start and size of swap space */
extern int      updlock;            /* lock for sync */
extern daddr_t  rablock;            /* block to be read ahead */
extern dev_t    rootdev;            /* device of the root */
extern dev_t    dumpdev;            /* device to take dumps on */
extern long     dumplo;             /* offset into dumpdev */
extern dev_t    swapdev;            /* swapping device */
extern dev_t    pipedev;            /* pipe device */

extern  const char icode[];         /* user init code */
extern  const char icodeend[];      /* its end */
extern  const char initflags[];     /* init flags string */

struct inode;
daddr_t bmap (struct inode *ip, daddr_t bn, int rwflg, int flags);

extern void kmemdev();

/*
 * Structure of the system-entry table
 */
extern const struct sysent
{
    int     sy_narg;                /* total number of arguments */
    void    (*sy_call) (void);      /* handler */
} sysent[];

extern const char *syscallnames[];

extern int  noproc;                 /* no one is running just now */
extern char *panicstr;
extern int  boothowto;              /* reboot flags, from boot */
extern int  selwait;
extern size_t   physmem;            /* total amount of physical memory */

extern dev_t get_cdev_by_name(char *);
extern char *cdevname(dev_t dev);

void panic (char *msg);
void printf (char *fmt, ...);
void uprintf (char *fmt, ...);      /* print to the current user's terminal */
struct tty;
void tprintf (struct tty *tp, char *fmt, ...);  /* print to the specified terminal */
int loginit (void);
void log (int level, char *fmt, ...);
int logwrt (char *buf, int len, int log);
void logwakeup (int unit);
void kconfig (void);
void cninit (void);
void cnidentify (void);
void cnputc (char c);
int cngetc (void);
int baduaddr (caddr_t addr);        /* detect bad user address */
int badkaddr (caddr_t addr);        /* detect bad kernel address */

int strncmp (const char *s1, const char *s2, size_t n);
void bzero (void *s, size_t nbytes);
void bcopy (const void *src, void *dest, size_t nbytes);
int bcmp (const void *a, const void *b, size_t nbytes);
int copystr (caddr_t src, caddr_t dest, u_int maxlen, u_int *copied);
size_t strlen (const char *s);
int ffs (u_long i);         /* find the index of the lsb set bit */
void insque (void *element, void *pred);
void remque (void *element);

void startup (void);                /* machine-dependent startup code */
int chrtoblk (dev_t dev);           /* convert from character to block device number */
int isdisk (dev_t dev, int type);   /* determine if a device is a disk */
int iskmemdev (dev_t dev);          /* identify /dev/mem and /dev/kmem */
void boot (dev_t dev, int howto);

/*
 * Copy data from kernel space fromaddr to user space address toaddr.
 * Fromaddr and toaddr must be word aligned.  Returns zero on success,
 * EFAULT on failure.
 */
int copyout (const caddr_t from, caddr_t to, u_int nbytes);

/*
 * Copy data from user space fromaddr to kernel space address toaddr.
 * Fromaddr and toaddr must be word aligned.  Returns zero on success,
 * EFAULT on failure.
 */
int copyin (const caddr_t from, caddr_t to, u_int nbytes);

/*
 * Check if gid is a member of the group set.
 */
int groupmember (gid_t gid);

/*
 * Wake up all processes sleeping on chan.
 */
void wakeup (caddr_t chan);

/*
 * Allocate iostat disk monitoring slots for a driver.
 */
void dk_alloc (int *dkn, int slots, char *name);

/*
 * Initialize callouts.
 */
void coutinit (void);

/*
 * Syscalls.
 */
void    nosys (void);

/* 1.1 processes and protection */
void    getpid (void);
void    getppid (void), fork (void), rexit (void), execv (void), execve (void);
void    wait4 (void), getuid (void), getgid (void), getgroups (void), setgroups (void);
void    geteuid (void), getegid (void);
void    getpgrp (void), setpgrp (void);
void    setgid (void), setegid (void), setuid (void), seteuid (void);
void    ucall (void);                   /* 2BSD calls */

/* 1.2 memory management */
void    brk (void);
void    ustore (void);                                  /* 2BSD calls */
void    ufetch (void);                                  /* 2BSD calls */

/* 1.3 signals */
void    sigstack (void), sigreturn (void);
void    sigaction (void), sigprocmask (void), sigpending (void), sigaltstack (void), sigsuspend (void);
void    sigwait (void), kill (void), killpg (void);

/* 1.4 timing and statistics */
void    gettimeofday (void), settimeofday (void);
void    getitimer (void), setitimer (void);
void    adjtime (void);

/* 1.5 descriptors */
void    getdtablesize (void), dup (void), dup2 (void), close (void);
void    pselect (void), select (void), fcntl (void), flock (void);

/* 1.6 resource controls */
void    getpriority (void), setpriority (void), getrusage (void), getrlimit (void), setrlimit (void);

/* 1.7 system operation support */
void    umount (void), smount (void);
void    sync (void), reboot (void), __sysctl (void);

/* 2.1 generic operations */
void    read (void), write (void), readv (void), writev (void), ioctl (void);

/* 2.2 file system */
void    chdir (void), fchdir (void), chroot (void);
void    mkdir (void), rmdir (void), chflags (void), fchflags (void);
void    open (void), mknod (void), unlink (void), stat (void), fstat (void), lstat (void);
void    chown (void), fchown (void), chmod (void), fchmod (void), utimes (void);
void    link (void), symlink (void), readlink (void), rename (void);
void    lseek (void), truncate (void), ftruncate (void), saccess (void), fsync (void);
void    statfs (void), fstatfs (void), getfsstat (void);

/* 2.3 communications */
void    socket (void), bind (void), listen (void), accept (void), connect (void);
void    socketpair (void), sendto (void), send (void), recvfrom (void), recv (void);
void    sendmsg (void), recvmsg (void), shutdown (void), setsockopt (void), getsockopt (void);
void    getsockname (void), getpeername (void), pipe (void);

void    umask (void);           /* XXX */

/* 2.4 processes */
void    ptrace (void);

void    profil (void);          /* 'cuz sys calls are interruptible */
void    vhangup (void);         /* should just do in exit (void) */
void    vfork (void);           /* awaiting fork w/ copy on write */

/*
 * Drivers.
 */
struct buf;
struct uio;

void cninit();
int cnopen (dev_t dev, int flag, int mode);
int cnclose (dev_t dev, int flag, int mode);
int cnread (dev_t dev, struct uio *uio, int flag);
int cnwrite (dev_t dev, struct uio *uio, int flag);
int cnioctl (dev_t dev, u_int cmd, caddr_t addr, int flag);
int cnselect (dev_t dev, int rw);

#ifdef TS_ISOPEN
extern struct tty cnttys[];
#endif

int mmrw (dev_t dev, struct uio *uio, int flag);
int seltrue (dev_t dev, int rw);
void nostrategy (struct buf *bp);
void nonet (void);

int syopen (dev_t dev, int flag, int mode);
int syread (dev_t dev, struct uio *uio, int flag);
int sywrite (dev_t dev, struct uio *uio, int flag);
int syioctl (dev_t dev, u_int cmd, caddr_t addr, int flag);
int syselect (dev_t dev, int rw);

int logopen (dev_t dev, int flag, int mode);
int logclose (dev_t dev, int flag, int mode);
int logread (dev_t dev, struct uio *uio, int flag);
int logioctl (dev_t dev, u_int cmd, caddr_t addr, int flag);
int logselect (dev_t dev, int rw);

int fdopen (dev_t dev, int flag, int mode);
int dupfdopen (int indx, int dfd, int mode, int error);