+/*
+ * Copyright (c) 1988 University of Utah.
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * the Systems Programming Group of the University of Utah Computer
+ * Science Department.
+ *
+ * %sccs.include.redist.c%
+ *
+ * from: Utah $Hdr: hpux_compat.c 1.33 89/08/23$
+ *
+ * @(#)hpux_compat.c 7.1 (Berkeley) %G%
+ */
+
+/*
+ * Various HPUX compatibility routines
+ */
+
+#ifdef HPUXCOMPAT
+
+#include "param.h"
+#include "systm.h"
+#include "syscontext.h"
+#include "kernel.h"
+#include "proc.h"
+#include "buf.h"
+#include "wait.h"
+#include "file.h"
+#include "vnode.h"
+#include "ioctl.h"
+#include "uio.h"
+#include "ptrace.h"
+#include "stat.h"
+#include "syslog.h"
+#include "malloc.h"
+#include "mount.h"
+#include "ipc.h"
+
+#include "machine/cpu.h"
+#include "machine/reg.h"
+#include "machine/psl.h"
+#include "machine/vmparam.h"
+#include "hpux.h"
+#include "hpux_termio.h"
+
+#ifdef DEBUG
+int unimpresponse = 0;
+#endif
+
+/* "tick" value for HZ==50 */
+int hpuxtick = 1000000 / 50;
+
+/* SYS5 style UTSNAME info */
+struct hpuxutsname protoutsname = {
+ "4.4bsd", "", "2.0", "B", "9000/3?0", ""
+};
+
+/* 6.0 and later style context */
+#ifdef FPCOPROC
+char hpuxcontext[] =
+ "standalone HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
+#else
+char hpuxcontext[] =
+ "standalone HP-MC68020 HP-MC68010 localroot default";
+#endif
+
+/* YP domainname */
+char domainname[MAXHOSTNAMELEN] = "unknown";
+int domainnamelen = 7;
+
+#define NERR 79
+#define BERR 1000
+
+/* indexed by BSD errno */
+short bsdtohpuxerrnomap[NERR] = {
+/*00*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+/*10*/ 10, 45, 12, 13, 14, 15, 16, 17, 18, 19,
+/*20*/ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+/*30*/ 30, 31, 32, 33, 34, 246, 245, 244, 216, 217,
+/*40*/ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
+/*50*/ 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
+/*60*/ 238, 239, 249, 248, 241, 242, 247,BERR,BERR,BERR,
+/*70*/ 70, 71,BERR,BERR,BERR,BERR,BERR, 46,BERR
+};
+
+notimp(code, nargs)
+{
+#ifdef DEBUG
+ int *argp = u.u_ap;
+ extern char *hpuxsyscallnames[];
+
+ printf("HPUX %s(", hpuxsyscallnames[code]);
+ if (nargs)
+ while (nargs--)
+ printf("%x%c", *argp++, nargs? ',' : ')');
+ else
+ printf(")");
+ printf("\n");
+ switch (unimpresponse) {
+ case 0:
+ nosys();
+ break;
+ case 1:
+ u.u_error = EINVAL;
+ break;
+ }
+#else
+ nosys();
+#endif
+ uprintf("HPUX system call %d not implemented\n", code);
+}
+
+/*
+ * HPUX versions of wait and wait3 actually pass the parameters
+ * (status pointer, options, rusage) into the kernel rather than
+ * handling it in the C library stub. We also need to map any
+ * termination signal from BSD to HPUX.
+ */
+hpuxwait3()
+{
+ struct a {
+ int *status;
+ int options;
+ int rusage;
+ } *uap = (struct a *)u.u_ap;
+
+ /* rusage pointer must be zero */
+ if (uap->rusage) {
+ u.u_error = EINVAL;
+ return;
+ }
+ u.u_ar0[PS] = PSL_ALLCC;
+ u.u_ar0[R0] = uap->options;
+ u.u_ar0[R1] = uap->rusage;
+ hpuxwait();
+}
+
+hpuxwait()
+{
+ int sig, *statp;
+ struct a {
+ int *status;
+ } *uap = (struct a *)u.u_ap;
+
+ statp = uap->status; /* owait clobbers first arg */
+ owait();
+ /*
+ * HP-UX wait always returns EINTR when interrupted by a signal
+ * (well, unless its emulating a BSD process, but we don't bother...)
+ */
+ if (u.u_eosys == RESTARTSYS) {
+ u.u_eosys = NORMALRETURN;
+ u.u_error = EINTR;
+ }
+ if (u.u_error)
+ return;
+ sig = u.u_r.r_val2 & 0xFF;
+ if (sig == WSTOPPED) {
+ sig = (u.u_r.r_val2 >> 8) & 0xFF;
+ u.u_r.r_val2 = (bsdtohpuxsig(sig) << 8) | WSTOPPED;
+ } else if (sig)
+ u.u_r.r_val2 = (u.u_r.r_val2 & 0xFF00) |
+ bsdtohpuxsig(sig & 0x7F) | (sig & 0x80);
+ if (statp)
+ if (suword((caddr_t)statp, u.u_r.r_val2))
+ u.u_error = EFAULT;
+}
+
+/*
+ * Must remap some bits in the mode mask.
+ * O_CREAT, O_TRUNC, and O_EXCL must be remapped,
+ * O_SYNCIO (0100000) is removed entirely.
+ */
+hpuxopen(scp)
+ register struct syscontext *scp;
+{
+ struct a {
+ char *fname;
+ int mode;
+ int crtmode;
+ } *uap = (struct a *) scp->sc_ap;
+ struct nameidata *ndp = &scp->sc_nd;
+ int mode;
+
+ mode = uap->mode;
+ uap->mode &= ~(HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT);
+ if (mode & HPUXFCREAT) {
+ /*
+ * simulate the pre-NFS behavior that opening a
+ * file for READ+CREATE ignores the CREATE (unless
+ * EXCL is set in which case we will return the
+ * proper error).
+ */
+ if ((mode & HPUXFEXCL) || ((mode-FOPEN) & FWRITE))
+ uap->mode |= FCREAT;
+ }
+ if (mode & HPUXFTRUNC)
+ uap->mode |= FTRUNC;
+ if (mode & HPUXFEXCL)
+ uap->mode |= FEXCL;
+ ndp->ni_segflg = UIO_USERSPACE;
+ ndp->ni_dirp = uap->fname;
+ RETURN (copen(scp, uap->mode-FOPEN, uap->crtmode &~ scp->sc_cmask, ndp,
+ &scp->sc_retval1));
+}
+
+hpuxfcntl()
+{
+ register struct a {
+ int fdes;
+ int cmd;
+ int arg;
+ } *uap = (struct a *)u.u_ap;
+ int mode;
+
+ switch (uap->cmd) {
+ case F_SETFL:
+ uap->arg &= ~(HPUXFSYNCIO|HPUXFREMOTE|FUSECACHE);
+ break;
+ case F_GETFL:
+ case F_DUPFD:
+ case F_GETFD:
+ case F_SETFD:
+ break;
+ default:
+ u.u_error = EINVAL;
+ return;
+ }
+ fcntl();
+ if (u.u_error == 0 && uap->arg == F_GETFL) {
+ mode = u.u_r.r_val1;
+ u.u_r.r_val1 &= ~(FCREAT|FTRUNC|FEXCL|FUSECACHE);
+ if (mode & FCREAT)
+ u.u_r.r_val1 |= HPUXFCREAT;
+ if (mode & FTRUNC)
+ u.u_r.r_val1 |= HPUXFTRUNC;
+ if (mode & FEXCL)
+ u.u_r.r_val1 |= HPUXFEXCL;
+ }
+}
+
+/*
+ * Read and write should return a 0 count when an operation
+ * on a VNODE would block, not an error. Sockets appear to
+ * return EWOULDBLOCK (at least in 6.2). This is probably
+ * not entirely correct, since the behavior is only defined
+ * for pipes and tty type devices.
+ */
+hpuxread()
+{
+ struct a {
+ int fd;
+ } *uap = (struct a *)u.u_ap;
+
+ read();
+ if (u.u_error == EWOULDBLOCK &&
+ u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) {
+ u.u_error = 0;
+ u.u_r.r_val1 = 0;
+ }
+}
+
+hpuxwrite()
+{
+ struct a {
+ int fd;
+ } *uap = (struct a *)u.u_ap;
+
+ write();
+ if (u.u_error == EWOULDBLOCK &&
+ u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) {
+ u.u_error = 0;
+ u.u_r.r_val1 = 0;
+ }
+}
+
+hpuxreadv()
+{
+ struct a {
+ int fd;
+ } *uap = (struct a *)u.u_ap;
+
+ readv();
+ if (u.u_error == EWOULDBLOCK &&
+ u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) {
+ u.u_error = 0;
+ u.u_r.r_val1 = 0;
+ }
+}
+
+hpuxwritev()
+{
+ struct a {
+ int fd;
+ } *uap = (struct a *)u.u_ap;
+
+ writev();
+ if (u.u_error == EWOULDBLOCK &&
+ u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) {
+ u.u_error = 0;
+ u.u_r.r_val1 = 0;
+ }
+}
+
+/*
+ * 4.3bsd dup allows dup2 to come in on the same syscall entry
+ * and hence allows two arguments. HPUX dup has only one arg.
+ */
+hpuxdup()
+{
+ register struct a {
+ int i;
+ } *uap = (struct a *)u.u_ap;
+ struct file *fp;
+ int j;
+
+ if ((unsigned)uap->i >= NOFILE || (fp = u.u_ofile[uap->i]) == NULL) {
+ u.u_error = EBADF;
+ return;
+ }
+ u.u_error = ufalloc(0, &j);
+ if (u.u_error)
+ return;
+ u.u_r.r_val1 = j;
+ dupit(j, fp, u.u_pofile[uap->i] &~ UF_EXCLOSE);
+}
+
+hpuxuname()
+{
+ register struct a {
+ struct hpuxutsname *uts;
+ int dev;
+ int request;
+ } *uap = (struct a *)u.u_ap;
+ register int i;
+
+ switch (uap->request) {
+ /* uname */
+ case 0:
+ /* fill in machine type */
+ switch (machineid) {
+ case HP_320:
+ protoutsname.machine[6] = '2';
+ break;
+ /* includes 318 and 319 */
+ case HP_330:
+ protoutsname.machine[6] = '3';
+ break;
+ case HP_340:
+ protoutsname.machine[6] = '4';
+ break;
+ case HP_350:
+ protoutsname.machine[6] = '5';
+ break;
+ case HP_360:
+ protoutsname.machine[6] = '6';
+ break;
+ case HP_370:
+ protoutsname.machine[6] = '7';
+ break;
+ }
+ /* copy hostname (sans domain) to nodename */
+ for (i = 0; i < 9 && hostname[i] != '.'; i++)
+ protoutsname.nodename[i] = hostname[i];
+ u.u_error = copyout((caddr_t)&protoutsname, (caddr_t)uap->uts,
+ sizeof(struct hpuxutsname));
+ break;
+ /* ustat - who cares? */
+ case 2:
+ default:
+ u.u_error = EINVAL;
+ break;
+ }
+}
+
+hpuxstat()
+{
+ struct a {
+ char *fname;
+ struct hpuxstat *hsb;
+ } *uap = (struct a *)u.u_ap;
+
+ u.u_error = hpuxstat1(uap->fname, uap->hsb, FOLLOW);
+}
+
+hpuxlstat()
+{
+ struct a {
+ char *fname;
+ struct hpuxstat *hsb;
+ } *uap = (struct a *) u.u_ap;
+
+ u.u_error = hpuxstat1(uap->fname, uap->hsb, NOFOLLOW);
+}
+
+hpuxfstat()
+{
+ register struct file *fp;
+ register struct a {
+ int fdes;
+ struct hpuxstat *hsb;
+ } *uap = (struct a *)u.u_ap;
+ struct stat sb;
+
+ if ((unsigned)uap->fdes >= NOFILE ||
+ (fp = u.u_ofile[uap->fdes]) == NULL) {
+ u.u_error = EBADF;
+ return;
+ }
+ switch (fp->f_type) {
+
+ case DTYPE_VNODE:
+ u.u_error = vn_stat((struct vnode *)fp->f_data, &sb);
+ break;
+
+ case DTYPE_SOCKET:
+ u.u_error = soo_stat((struct socket *)fp->f_data, &sb);
+ break;
+
+ default:
+ panic("fstat");
+ /*NOTREACHED*/
+ }
+ /* is this right for sockets?? */
+ if (u.u_error == 0)
+ u.u_error = bsdtohpuxstat(&sb, uap->hsb);
+}
+
+hpuxulimit()
+{
+ struct a {
+ int cmd;
+ long newlimit;
+ } *uap = (struct a *)u.u_ap;
+ struct rlimit *limp;
+
+ limp = &u.u_rlimit[RLIMIT_FSIZE];
+ switch (uap->cmd) {
+ case 2:
+ uap->newlimit *= 512;
+ if (uap->newlimit > limp->rlim_max &&
+ (u.u_error = suser(u.u_cred, &u.u_acflag)))
+ break;
+ limp->rlim_cur = limp->rlim_max = uap->newlimit;
+ /* else fall into... */
+
+ case 1:
+ u.u_r.r_off = limp->rlim_max / 512;
+ break;
+
+ case 3:
+ limp = &u.u_rlimit[RLIMIT_DATA];
+ u.u_r.r_off = ctob(u.u_tsize) + limp->rlim_max;
+ break;
+
+ default:
+ u.u_error = EINVAL;
+ break;
+ }
+}
+
+/*
+ * Map "real time" priorities 0 (high) thru 127 (low) into nice
+ * values -16 (high) thru -1 (low).
+ */
+hpuxrtprio()
+{
+ register struct a {
+ int pid;
+ int prio;
+ } *uap = (struct a *)u.u_ap;
+ struct proc *p;
+ int nice;
+
+ if (uap->prio < RTPRIO_MIN && uap->prio > RTPRIO_MAX &&
+ uap->prio != RTPRIO_NOCHG && uap->prio != RTPRIO_RTOFF) {
+ u.u_error = EINVAL;
+ return;
+ }
+ if (uap->pid == 0)
+ p = u.u_procp;
+ else if ((p = pfind(uap->pid)) == 0) {
+ u.u_error = ESRCH;
+ return;
+ }
+ nice = p->p_nice;
+ if (nice < NZERO)
+ u.u_r.r_val1 = (nice + 16) << 3;
+ else
+ u.u_r.r_val1 = RTPRIO_RTOFF;
+ switch (uap->prio) {
+
+ case RTPRIO_NOCHG:
+ return;
+
+ case RTPRIO_RTOFF:
+ if (nice >= NZERO)
+ return;
+ nice = NZERO;
+ break;
+
+ default:
+ nice = (uap->prio >> 3) - 16;
+ break;
+ }
+ donice(p, nice);
+ if (u.u_error == EACCES)
+ u.u_error = EPERM;
+}
+
+/*
+ * Kudos to HP folks for using such mnemonic names so I could figure
+ * out what this guy does.
+ */
+hpuxadvise()
+{
+ struct a {
+ int arg;
+ } *uap = (struct a *) u.u_ap;
+
+ switch (uap->arg) {
+ case 0:
+ u.u_pcb.pcb_flags |= PCB_HPUXMMAP;
+ break;
+ case 1:
+ ICIA();
+ break;
+ case 2:
+ DCIA();
+ break;
+ default:
+ u.u_error = EINVAL;
+ break;
+ }
+}
+
+hpuxptrace()
+{
+ struct a {
+ int req;
+ int pid;
+ int *addr;
+ int data;
+ } *uap = (struct a *)u.u_ap;
+
+ if (uap->req == PT_STEP || uap->req == PT_CONTINUE) {
+ if (uap->data) {
+ uap->data = hpuxtobsdsig(uap->data);
+ if (uap->data == 0)
+ uap->data = NSIG;
+ }
+ }
+ ptrace();
+}
+
+hpuxgetdomainname()
+{
+ register struct a {
+ char *domainname;
+ u_int len;
+ } *uap = (struct a *)u.u_ap;
+
+ if (uap->len > domainnamelen + 1)
+ uap->len = domainnamelen + 1;
+ u.u_error = copyout(domainname, uap->domainname, uap->len);
+}
+
+hpuxsetdomainname()
+{
+ register struct a {
+ char *domainname;
+ u_int len;
+ } *uap = (struct a *)u.u_ap;
+
+ if (u.u_error = suser(u.u_cred, &u.u_acflag))
+ return;
+ if (uap->len > sizeof (domainname) - 1) {
+ u.u_error = EINVAL;
+ return;
+ }
+ domainnamelen = uap->len;
+ u.u_error = copyin(uap->domainname, domainname, uap->len);
+ domainname[domainnamelen] = 0;
+}
+
+#ifdef SYSVSHM
+hpuxshmat()
+{
+ shmat(u.u_ap);
+}
+
+hpuxshmctl()
+{
+ shmctl(u.u_ap);
+}
+
+hpuxshmdt()
+{
+ shmdt(u.u_ap);
+}
+
+hpuxshmget()
+{
+ shmget(u.u_ap);
+}
+#endif
+
+/*
+ * Fake semaphore routines, just don't return an error.
+ * Should be adequate for starbase to run.
+ */
+hpuxsemctl()
+{
+ struct a {
+ int semid;
+ u_int semnum;
+ int cmd;
+ int arg;
+ } *uap = (struct a *)u.u_ap;
+
+ /* XXX: should do something here */
+}
+
+hpuxsemget()
+{
+ struct a {
+ key_t key;
+ int nsems;
+ int semflg;
+ } *uap = (struct a *)u.u_ap;
+
+ /* XXX: should do something here */
+}
+
+hpuxsemop()
+{
+ struct a {
+ int semid;
+ struct sembuf *sops;
+ u_int nsops;
+ } *uap = (struct a *)u.u_ap;
+
+ /* XXX: should do something here */
+}
+
+/* convert from BSD to HPUX errno */
+bsdtohpuxerrno(err)
+ int err;
+{
+ if (err < 0 || err >= NERR)
+ return(BERR);
+ return((int)bsdtohpuxerrnomap[err]);
+}
+
+hpuxstat1(fname, hsb, follow)
+ char *fname;
+ struct hpuxstat *hsb;
+ int follow;
+{
+ register struct nameidata *ndp = &u.u_nd;
+ struct stat sb;
+ int error;
+
+ ndp->ni_nameiop = LOOKUP | LOCKLEAF | follow;
+ ndp->ni_segflg = UIO_USERSPACE;
+ ndp->ni_dirp = fname;
+ if (error = namei(ndp))
+ return (error);
+ error = vn_stat(ndp->ni_vp, &sb);
+ vput(ndp->ni_vp);
+ if (error == 0)
+ error = bsdtohpuxstat(&sb, hsb);
+ return (error);
+}
+
+#include "grf.h"
+
+bsdtohpuxstat(sb, hsb)
+ struct stat *sb;
+ struct hpuxstat *hsb;
+{
+ struct hpuxstat ds;
+
+ bzero((caddr_t)&ds, sizeof(ds));
+ ds.hst_dev = sb->st_dev;
+ ds.hst_ino = (u_long)sb->st_ino;
+ ds.hst_mode = sb->st_mode;
+ ds.hst_nlink = sb->st_nlink;
+ ds.hst_uid = (u_short)sb->st_uid;
+ ds.hst_gid = (u_short)sb->st_gid;
+#if NGRF > 0
+ /* XXX: I don't want to talk about it... */
+ if ((sb->st_mode & S_IFMT) == S_IFCHR && major(sb->st_rdev) == 10)
+ ds.hst_rdev = grfdevno(sb->st_rdev);
+ else
+#endif
+ ds.hst_rdev = bsdtohpuxdev(sb->st_rdev);
+ ds.hst_size = sb->st_size;
+ ds.hst_atime = sb->st_atime;
+ ds.hst_mtime = sb->st_mtime;
+ ds.hst_ctime = sb->st_ctime;
+ ds.hst_blksize = sb->st_blksize;
+ ds.hst_blocks = sb->st_blocks;
+ return(copyout((caddr_t)&ds, (caddr_t)hsb, sizeof(ds)));
+}
+
+hpuxtobsdioctl(com)
+ int com;
+{
+ switch (com) {
+ case HPUXTIOCSLTC:
+ com = TIOCSLTC; break;
+ case HPUXTIOCGLTC:
+ com = TIOCGLTC; break;
+ case HPUXTIOCSPGRP:
+ com = TIOCSPGRP; break;
+ case HPUXTIOCGPGRP:
+ com = TIOCGPGRP; break;
+ case HPUXTIOCLBIS:
+ com = TIOCLBIS; break;
+ case HPUXTIOCLBIC:
+ com = TIOCLBIC; break;
+ case HPUXTIOCLSET:
+ com = TIOCLSET; break;
+ case HPUXTIOCLGET:
+ com = TIOCLGET; break;
+ }
+ return(com);
+}
+
+/*
+ * HPUX ioctl system call. The differences here are:
+ * IOC_IN also means IOC_VOID if the size portion is zero.
+ * no FIOCLEX/FIONCLEX/FIONBIO/FIOASYNC/FIOGETOWN/FIOSETOWN
+ * the sgttyb struct is 2 bytes longer
+ */
+hpuxioctl()
+{
+ register struct file *fp;
+ struct a {
+ int fdes;
+ int cmd;
+ caddr_t cmarg;
+ } *uap = (struct a *)u.u_ap;
+ register int com;
+ register u_int size;
+ caddr_t memp = 0;
+#define STK_PARAMS 128
+ char stkbuf[STK_PARAMS];
+ caddr_t data = stkbuf;
+
+ com = uap->cmd;
+
+ /* XXX */
+ if (com == HPUXTIOCGETP || com == HPUXTIOCSETP) {
+ getsettty(uap->fdes, com, uap->cmarg);
+ return;
+ }
+
+ if ((unsigned)uap->fdes >= NOFILE ||
+ (fp = u.u_ofile[uap->fdes]) == NULL) {
+ u.u_error = EBADF;
+ return;
+ }
+ if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
+ u.u_error = EBADF;
+ return;
+ }
+
+ /*
+ * Interpret high order word to find
+ * amount of data to be copied to/from the
+ * user's address space.
+ */
+ size = IOCPARM_LEN(com);
+ if (size > IOCPARM_MAX) {
+ u.u_error = EFAULT;
+ return;
+ }
+ if (size > sizeof (stkbuf)) {
+ memp = (caddr_t)malloc((u_long)IOCPARM_MAX, M_IOCTLOPS,
+ M_WAITOK);
+ data = memp;
+ }
+ if (com&IOC_IN) {
+ if (size) {
+ u.u_error = copyin(uap->cmarg, data, (u_int)size);
+ if (u.u_error) {
+ if (memp)
+ free(memp, M_IOCTLOPS);
+ return;
+ }
+ } else
+ *(caddr_t *)data = uap->cmarg;
+ } else if ((com&IOC_OUT) && size)
+ /*
+ * Zero the buffer on the stack so the user
+ * always gets back something deterministic.
+ */
+ bzero(data, size);
+ else if (com&IOC_VOID)
+ *(caddr_t *)data = uap->cmarg;
+
+ switch (com) {
+
+ case HPUXTIOCCONS:
+ *(int *)data = 1;
+ u.u_error = (*fp->f_ops->fo_ioctl)(fp, TIOCCONS, data);
+ break;
+
+ /* BSD-style job control ioctls */
+ case HPUXTIOCLBIS:
+ case HPUXTIOCLBIC:
+ case HPUXTIOCLSET:
+ *(int *)data &= HPUXLTOSTOP;
+ if (*(int *)data & HPUXLTOSTOP)
+ *(int *)data = LTOSTOP;
+ /* fall into */
+ case HPUXTIOCLGET:
+ case HPUXTIOCSLTC:
+ case HPUXTIOCGLTC:
+ case HPUXTIOCSPGRP:
+ case HPUXTIOCGPGRP:
+ u.u_error = (*fp->f_ops->fo_ioctl)(fp, hpuxtobsdioctl(com), data);
+ if (u.u_error == 0 && com == HPUXTIOCLGET) {
+ *(int *)data &= LTOSTOP;
+ if (*(int *)data & LTOSTOP)
+ *(int *)data = HPUXLTOSTOP;
+ }
+ break;
+
+ /* SYS 5 termio */
+ case HPUXTCGETA:
+ case HPUXTCSETA:
+ case HPUXTCSETAW:
+ case HPUXTCSETAF:
+ u.u_error = hpuxtermio(fp, com, data);
+ break;
+
+ default:
+ u.u_error = (*fp->f_ops->fo_ioctl)(fp, com, data);
+ break;
+ }
+ /*
+ * Copy any data to user, size was
+ * already set and checked above.
+ */
+ if (u.u_error == 0 && (com&IOC_OUT) && size)
+ u.u_error = copyout(data, uap->cmarg, (u_int)size);
+ if (memp)
+ free(memp, M_IOCTLOPS);
+}
+
+/*
+ * Man page lies, behaviour here is based on observed behaviour.
+ */
+hpuxgetcontext()
+{
+ struct a {
+ char *buf;
+ int len;
+ } *uap = (struct a *)u.u_ap;
+ int error = 0;
+ register int len;
+
+ len = MIN(uap->len, sizeof(hpuxcontext));
+ if (len)
+ error = copyout(hpuxcontext, uap->buf, (u_int)len);
+ if (!error)
+ u.u_r.r_val1 = sizeof(hpuxcontext);
+ return(error);
+}
+
+/*
+ * XXX: simple recognition hack to see if we can make grmd work.
+ */
+hpuxlockf()
+{
+ struct a {
+ int fd;
+ int func;
+ long size;
+ } *uap = (struct a *)u.u_ap;
+#ifdef DEBUG
+ log(LOG_DEBUG, "%d: lockf(%d, %d, %d)\n",
+ u.u_procp->p_pid, uap->fd, uap->func, uap->size);
+#endif
+ return(0);
+}
+
+/*
+ * This is the equivalent of BSD getpgrp but with more restrictions.
+ * Note we do not check the real uid or "saved" uid.
+ */
+hpuxgetpgrp2()
+{
+ register struct proc *p;
+ register struct a {
+ int pid;
+ } *uap = (struct a *)u.u_ap;
+
+ if (uap->pid == 0)
+ uap->pid = u.u_procp->p_pid;
+ p = pfind(uap->pid);
+ if (p == 0) {
+ u.u_error = ESRCH;
+ return;
+ }
+ if (u.u_uid && p->p_uid != u.u_uid && !inferior(p)) {
+ u.u_error = EPERM;
+ return;
+ }
+ u.u_r.r_val1 = p->p_pgid;
+}
+
+/*
+ * This is the equivalent of BSD setpgrp but with more restrictions.
+ * Note we do not check the real uid or "saved" uid or pgrp.
+ */
+hpuxsetpgrp2()
+{
+ struct a {
+ int pid;
+ int pgrp;
+ } *uap = (struct a *)u.u_ap;
+
+ /* empirically determined */
+ if (uap->pgrp < 0 || uap->pgrp >= 30000) {
+ u.u_error = EINVAL;
+ return;
+ }
+ setpgrp();
+}
+
+/*
+ * Brutal hack! Map HPUX u-area offsets into BSD u offsets.
+ * No apologies offered, if you don't like it, rewrite it!
+ */
+
+#define UOFF(f) ((int)&((struct user *)0)->f)
+#define HPUOFF(f) ((int)&((struct hpuxuser *)0)->f)
+
+/* simplified FP structure */
+struct bsdfp {
+ int save[54];
+ int reg[24];
+ int ctrl[3];
+};
+
+hpuxtobsduoff(off)
+ int *off;
+{
+ struct hpuxfp *hp;
+ struct bsdfp *bp;
+ register u_int raddr;
+
+ /* u_ar0 field */
+ if ((int)off == HPUOFF(hpuxu_ar0))
+ return(UOFF(u_ar0));
+
+#ifdef FPCOPROC
+ /* 68881 registers from PCB */
+ hp = (struct hpuxfp *)HPUOFF(hpuxu_fp);
+ bp = (struct bsdfp *)UOFF(u_pcb.pcb_fpregs);
+ if (off >= hp->hpfp_ctrl && off < &hp->hpfp_ctrl[3])
+ return((int)&bp->ctrl[off - hp->hpfp_ctrl]);
+ if (off >= hp->hpfp_reg && off < &hp->hpfp_reg[24])
+ return((int)&bp->reg[off - hp->hpfp_reg]);
+#endif
+
+ /*
+ * Everything else we recognize comes from the kernel stack,
+ * so we convert off to an absolute address (if not already)
+ * for simplicity.
+ */
+ if (off < (int *)ctob(UPAGES))
+ off = (int *)((u_int)off + (u_int)&u);
+
+ /*
+ * 68020 registers.
+ * We know that the HPUX registers are in the same order as ours.
+ * The only difference is that their PS is 2 bytes instead of a
+ * padded 4 like ours throwing the alignment off.
+ */
+ if (off >= u.u_ar0 && off < &u.u_ar0[18]) {
+ /*
+ * PS: return low word and high word of PC as HP-UX would
+ * (e.g. &u.u_ar0[16.5]).
+ */
+ if (off == &u.u_ar0[PS])
+ raddr = (u_int) &((short *)u.u_ar0)[PS*2+1];
+ /*
+ * PC: off will be &u.u_ar0[16.5]
+ */
+ else if (off == (int *)&(((short *)u.u_ar0)[PS*2+1]))
+ raddr = (u_int) &u.u_ar0[PC];
+ /*
+ * D0-D7, A0-A7: easy
+ */
+ else
+ raddr = (u_int) &u.u_ar0[(int)(off - u.u_ar0)];
+ return((int)(raddr - (u_int)&u));
+ }
+
+ /* everything else */
+ return(-1);
+}
+
+/*
+ * Kludge up a uarea dump so that HPUX debuggers can find out
+ * what they need. IMPORTANT NOTE: we do not EVEN attempt to
+ * convert the entire user struct.
+ */
+hpuxdumpu(vp, cred)
+ struct vnode *vp;
+ struct ucred *cred;
+{
+ int error;
+ struct hpuxuser *faku;
+ struct bsdfp *bp;
+ short *foop;
+
+ faku = (struct hpuxuser *)malloc((u_long)ctob(1), M_TEMP, M_WAITOK);
+ /*
+ * Make sure there is no mistake about this
+ * being a real user structure.
+ */
+ bzero((caddr_t)faku, ctob(1));
+ /*
+ * Fill in the process sizes.
+ */
+ faku->hpuxu_tsize = u.u_tsize;
+ faku->hpuxu_dsize = u.u_dsize;
+ faku->hpuxu_ssize = u.u_ssize;
+ /*
+ * Fill in the exec header for CDB.
+ * This was saved back in exec(). As far as I can tell CDB
+ * only uses this information to verify that a particular
+ * core file goes with a particular binary.
+ */
+ bcopy((caddr_t)u.u_pcb.pcb_exec,
+ (caddr_t)&faku->hpuxu_exdata, sizeof (struct hpux_exec));
+ /*
+ * Adjust user's saved registers (on kernel stack) to reflect
+ * HPUX order. Note that HPUX saves the SR as 2 bytes not 4
+ * so we have to move it up.
+ */
+ faku->hpuxu_ar0 = u.u_ar0;
+ foop = (short *) u.u_ar0;
+ foop[32] = foop[33];
+ foop[33] = foop[34];
+ foop[34] = foop[35];
+#ifdef FPCOPROC
+ /*
+ * Copy 68881 registers from our PCB format to HPUX format
+ */
+ bp = (struct bsdfp *) &u.u_pcb.pcb_fpregs;
+ bcopy((caddr_t)bp->save, (caddr_t)faku->hpuxu_fp.hpfp_save,
+ sizeof(bp->save));
+ bcopy((caddr_t)bp->ctrl, (caddr_t)faku->hpuxu_fp.hpfp_ctrl,
+ sizeof(bp->ctrl));
+ bcopy((caddr_t)bp->reg, (caddr_t)faku->hpuxu_fp.hpfp_reg,
+ sizeof(bp->reg));
+#endif
+ /*
+ * Slay the dragon
+ */
+ faku->hpuxu_dragon = -1;
+ /*
+ * Dump this artfully constructed page in place of the
+ * user struct page.
+ */
+ error = vn_rdwr(UIO_WRITE, vp,
+ (caddr_t)faku, ctob(1), (off_t)0,
+ UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *)0);
+ /*
+ * Dump the remaining UPAGES-1 pages normally
+ */
+ if (!error)
+ error = vn_rdwr(UIO_WRITE, vp, ((caddr_t)&u)+ctob(1),
+ ctob(UPAGES-1), (off_t)ctob(1), UIO_SYSSPACE,
+ IO_NODELOCKED|IO_UNIT, cred, (int *)0);
+ free((caddr_t)faku, M_TEMP);
+ return(error);
+}
+
+/*
+ * The remaining routines are essentially the same as those in kern_xxx.c
+ * and vfs_xxx.c as defined under "#ifdef COMPAT". We replicate them here
+ * to avoid HPUXCOMPAT dependencies in those files and to make sure that
+ * HP-UX compatibility still works even when COMPAT is not defined.
+ */
+/* #ifdef COMPAT */
+
+#include "../h/times.h"
+
+/* from old timeb.h */
+struct hpuxtimeb {
+ time_t time;
+ u_short millitm;
+ short timezone;
+ short dstflag;
+};
+
+/* ye ole stat structure */
+struct ohpuxstat {
+ dev_t ohst_dev;
+ u_short ohst_ino;
+ u_short ohst_mode;
+ short ohst_nlink;
+ short ohst_uid;
+ short ohst_gid;
+ dev_t ohst_rdev;
+ int ohst_size;
+ int ohst_atime;
+ int ohst_mtime;
+ int ohst_ctime;
+};
+
+/*
+ * Right now the following two routines are the same as the 4.3
+ * osetuid/osetgid calls. Eventually they need to be changed to
+ * implement the notion of "saved" ids (whatever that means).
+ */
+ohpuxsetuid()
+{
+ register uid;
+ register struct a {
+ int uid;
+ } *uap = (struct a *)u.u_ap;
+
+ uid = uap->uid;
+ if (uid != u.u_procp->p_ruid && uid != u.u_cred->cr_uid &&
+ (u.u_error = suser(u.u_cred, &u.u_acflag)))
+ return;
+ if (u.u_cred->cr_ref > 1)
+ u.u_cred = crcopy(u.u_cred);
+ u.u_cred->cr_uid = uid;
+ u.u_procp->p_uid = uid;
+ u.u_procp->p_ruid = uid;
+}
+
+ohpuxsetgid()
+{
+ register gid;
+ register struct a {
+ int gid;
+ } *uap = (struct a *)u.u_ap;
+
+ gid = uap->gid;
+ if (u.u_procp->p_rgid != gid && u.u_cred->cr_groups[0] != gid &&
+ (u.u_error = suser(u.u_cred, &u.u_acflag)))
+ return;
+ if (u.u_cred->cr_ref > 1)
+ u.u_cred = crcopy(u.u_cred);
+ u.u_procp->p_rgid = gid;
+ u.u_cred->cr_groups[0] = gid;
+}
+
+/*
+ * SYS V style setpgrp()
+ */
+ohpuxsetpgrp()
+{
+ register struct proc *p = u.u_procp;
+
+ if (p->p_pid != p->p_pgid)
+ pgmv(p, p->p_pid, 0);
+ u.u_r.r_val1 = p->p_pgid;
+}
+
+ohpuxtime()
+{
+ register struct a {
+ long *tp;
+ } *uap = (struct a *)u.u_ap;
+
+ if (uap->tp)
+ u.u_error = copyout((caddr_t)&time.tv_sec, (caddr_t)uap->tp,
+ sizeof (long));
+ u.u_r.r_time = time.tv_sec;
+}
+
+ohpuxstime()
+{
+ register struct a {
+ int time;
+ } *uap = (struct a *)u.u_ap;
+ struct timeval tv;
+ int s;
+
+ tv.tv_sec = uap->time;
+ tv.tv_usec = 0;
+ u.u_error = suser(u.u_cred, &u.u_acflag);
+ if (u.u_error)
+ return;
+
+ /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
+ boottime.tv_sec += tv.tv_sec - time.tv_sec;
+ s = splhigh(); time = tv; splx(s);
+ resettodr();
+}
+
+ohpuxftime()
+{
+ register struct a {
+ struct hpuxtimeb *tp;
+ } *uap;
+ struct hpuxtimeb tb;
+ int s;
+
+ uap = (struct a *)u.u_ap;
+ s = splhigh();
+ tb.time = time.tv_sec;
+ tb.millitm = time.tv_usec / 1000;
+ splx(s);
+ tb.timezone = tz.tz_minuteswest;
+ tb.dstflag = tz.tz_dsttime;
+ u.u_error = copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb));
+}
+
+ohpuxalarm()
+{
+ register struct a {
+ int deltat;
+ } *uap = (struct a *)u.u_ap;
+ register struct proc *p = u.u_procp;
+ int s = splhigh();
+
+ untimeout(realitexpire, (caddr_t)p);
+ timerclear(&p->p_realtimer.it_interval);
+ u.u_r.r_val1 = 0;
+ if (timerisset(&p->p_realtimer.it_value) &&
+ timercmp(&p->p_realtimer.it_value, &time, >))
+ u.u_r.r_val1 = p->p_realtimer.it_value.tv_sec - time.tv_sec;
+ if (uap->deltat == 0) {
+ timerclear(&p->p_realtimer.it_value);
+ splx(s);
+ return;
+ }
+ p->p_realtimer.it_value = time;
+ p->p_realtimer.it_value.tv_sec += uap->deltat;
+ timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
+ splx(s);
+}
+
+ohpuxnice()
+{
+ register struct a {
+ int niceness;
+ } *uap = (struct a *)u.u_ap;
+ register struct proc *p = u.u_procp;
+
+ donice(p, (p->p_nice-NZERO)+uap->niceness);
+ u.u_r.r_val1 = p->p_nice - NZERO;
+}
+
+ohpuxtimes()
+{
+ register struct a {
+ struct tms *tmsb;
+ } *uap = (struct a *)u.u_ap;
+ struct tms atms;
+
+ atms.tms_utime = scale50(&u.u_ru.ru_utime);
+ atms.tms_stime = scale50(&u.u_ru.ru_stime);
+ atms.tms_cutime = scale50(&u.u_cru.ru_utime);
+ atms.tms_cstime = scale50(&u.u_cru.ru_stime);
+ u.u_error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
+ if (u.u_error == 0)
+ u.u_r.r_time = scale50(&time) - scale50(&boottime);
+}
+
+scale50(tvp)
+ register struct timeval *tvp;
+{
+ extern int hpuxtick;
+
+ /*
+ * Doesn't exactly do what the documentation says.
+ * What we really do is return 50th of a second since that
+ * is what HZ is on all bobcats I know of.
+ */
+ return ((tvp->tv_sec * 50 + tvp->tv_usec / hpuxtick));
+}
+
+/*
+ * Set IUPD and IACC times on file.
+ * Can't set ICHG.
+ */
+ohpuxutime()
+{
+ register struct a {
+ char *fname;
+ time_t *tptr;
+ } *uap = (struct a *)u.u_ap;
+ struct vattr vattr;
+ time_t tv[2];
+ register struct vnode *vp;
+ register struct nameidata *ndp = &u.u_nd;
+
+ if (uap->tptr) {
+ u.u_error =
+ copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
+ if (u.u_error)
+ return;
+ } else
+ tv[0] = tv[1] = time.tv_sec;
+ ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
+ ndp->ni_segflg = UIO_USERSPACE;
+ ndp->ni_dirp = uap->fname;
+ vattr_null(&vattr);
+ vattr.va_atime.tv_sec = tv[0];
+ vattr.va_atime.tv_usec = 0;
+ vattr.va_mtime.tv_sec = tv[1];
+ vattr.va_mtime.tv_usec = 0;
+ if (u.u_error = namei(ndp))
+ return;
+ vp = ndp->ni_vp;
+ if (vp->v_mount->m_flag & M_RDONLY)
+ u.u_error = EROFS;
+ else
+ u.u_error = VOP_SETATTR(vp, &vattr, ndp->ni_cred);
+ vput(vp);
+}
+
+ohpuxpause()
+{
+
+ for (;;)
+ sleep((caddr_t)&u, PSLEP);
+}
+
+/*
+ * The old fstat system call.
+ */
+ohpuxfstat()
+{
+ register struct a {
+ int fd;
+ struct ohpuxstat *sb;
+ } *uap = (struct a *)u.u_ap;
+ struct file *fp;
+ extern struct file *getinode();
+
+ if ((unsigned)uap->fd >= NOFILE || (fp = u.u_ofile[uap->fd]) == NULL) {
+ u.u_error = EBADF;
+ return;
+ }
+ if (fp->f_type != DTYPE_VNODE) {
+ u.u_error = EINVAL;
+ return;
+ }
+ u.u_error = ohpuxstat1((struct vnode *)fp->f_data, uap->sb);
+}
+
+/*
+ * Old stat system call. This version follows links.
+ */
+ohpuxstat()
+{
+ register struct a {
+ char *fname;
+ struct ohpuxstat *sb;
+ } *uap = (struct a *)u.u_ap;
+ register struct nameidata *ndp = &u.u_nd;
+
+ ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW;
+ ndp->ni_segflg = UIO_USERSPACE;
+ ndp->ni_dirp = uap->fname;
+ if (u.u_error = namei(ndp))
+ return;
+ u.u_error = ohpuxstat1(ndp->ni_vp, uap->sb);
+ vput(ndp->ni_vp);
+}
+
+int
+ohpuxstat1(vp, ub)
+ register struct vnode *vp;
+ struct ohpuxstat *ub;
+{
+ struct ohpuxstat ds;
+ struct vattr vattr;
+ register int error;
+
+ error = VOP_GETATTR(vp, &vattr, u.u_cred);
+ if (error)
+ return(error);
+ /*
+ * Copy from inode table
+ */
+ ds.ohst_dev = vattr.va_fsid;
+ ds.ohst_ino = (short)vattr.va_fileid;
+ ds.ohst_mode = (u_short)vattr.va_mode;
+ ds.ohst_nlink = vattr.va_nlink;
+ ds.ohst_uid = (short)vattr.va_uid;
+ ds.ohst_gid = (short)vattr.va_gid;
+ ds.ohst_rdev = (dev_t)vattr.va_rdev;
+ ds.ohst_size = (int)vattr.va_size;
+ ds.ohst_atime = (int)vattr.va_atime.tv_sec;
+ ds.ohst_mtime = (int)vattr.va_mtime.tv_sec;
+ ds.ohst_ctime = (int)vattr.va_ctime.tv_sec;
+ return (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)));
+}
+/* #endif */
+
+#endif
projects / unix-history / commitdiff