xref: /csrg-svn/sys/hp/hpux/hpux_compat.c (revision 68373)
141486Smckusick /*
241486Smckusick  * Copyright (c) 1988 University of Utah.
363734Sbostic  * Copyright (c) 1990, 1993
463734Sbostic  *	The Regents of the University of California.  All rights reserved.
541486Smckusick  *
641486Smckusick  * This code is derived from software contributed to Berkeley by
741486Smckusick  * the Systems Programming Group of the University of Utah Computer
841486Smckusick  * Science Department.
941486Smckusick  *
1041486Smckusick  * %sccs.include.redist.c%
1141486Smckusick  *
1264478Shibler  * from: Utah $Hdr: hpux_compat.c 1.64 93/08/05$
1341486Smckusick  *
14*68373Scgd  *	@(#)hpux_compat.c	8.5 (Berkeley) 02/19/95
1541486Smckusick  */
1641486Smckusick 
1741486Smckusick /*
1854857Shibler  * Various HP-UX compatibility routines
1941486Smckusick  */
2041486Smckusick 
2141486Smckusick #ifdef HPUXCOMPAT
2259982Smckusick #ifndef COMPAT_43
2359982Smckusick #define COMPAT_43
2459982Smckusick #endif
2541486Smckusick 
2656506Sbostic #include <sys/param.h>
2756506Sbostic #include <sys/systm.h>
2856506Sbostic #include <sys/signalvar.h>
2956506Sbostic #include <sys/kernel.h>
3056506Sbostic #include <sys/filedesc.h>
3156506Sbostic #include <sys/proc.h>
3256506Sbostic #include <sys/buf.h>
3356506Sbostic #include <sys/wait.h>
3456506Sbostic #include <sys/file.h>
3556506Sbostic #include <sys/namei.h>
3656506Sbostic #include <sys/vnode.h>
3756506Sbostic #include <sys/ioctl.h>
3856506Sbostic #include <sys/ptrace.h>
3956506Sbostic #include <sys/stat.h>
4056506Sbostic #include <sys/syslog.h>
4156506Sbostic #include <sys/malloc.h>
4256506Sbostic #include <sys/mount.h>
4356506Sbostic #include <sys/ipc.h>
4456506Sbostic #include <sys/user.h>
4557307Shibler #include <sys/mman.h>
4641486Smckusick 
4756506Sbostic #include <machine/cpu.h>
4856506Sbostic #include <machine/reg.h>
4956506Sbostic #include <machine/psl.h>
5056506Sbostic #include <machine/vmparam.h>
5156506Sbostic #include <hp/hpux/hpux.h>
5256506Sbostic #include <hp/hpux/hpux_termio.h>
5356506Sbostic 
5441486Smckusick #ifdef DEBUG
5541486Smckusick int unimpresponse = 0;
5641486Smckusick #endif
5741486Smckusick 
5841486Smckusick /* SYS5 style UTSNAME info */
5941486Smckusick struct hpuxutsname protoutsname = {
6057307Shibler 	"4.4bsd", "", "0.5", "B", "9000/3?0", ""
6141486Smckusick };
6241486Smckusick 
6341486Smckusick /* 6.0 and later style context */
6453922Shibler #if defined(HP380)
6553922Shibler char hpux040context[] =
6653922Shibler     "standalone HP-MC68040 HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
6753922Shibler #endif
6841486Smckusick #ifdef FPCOPROC
6941486Smckusick char hpuxcontext[] =
7041486Smckusick 	"standalone HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
7141486Smckusick #else
7241486Smckusick char hpuxcontext[] =
7341486Smckusick 	"standalone HP-MC68020 HP-MC68010 localroot default";
7441486Smckusick #endif
7541486Smckusick 
7641486Smckusick /* YP domainname */
7741486Smckusick char	domainname[MAXHOSTNAMELEN] = "unknown";
7841486Smckusick int	domainnamelen = 7;
7941486Smckusick 
8064478Shibler #define NERR	83
8141486Smckusick #define BERR	1000
8241486Smckusick 
8341486Smckusick /* indexed by BSD errno */
8441486Smckusick short bsdtohpuxerrnomap[NERR] = {
8541486Smckusick /*00*/	  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
8641486Smckusick /*10*/	 10,  45,  12,  13,  14,  15,  16,  17,  18,  19,
8741486Smckusick /*20*/	 20,  21,  22,  23,  24,  25,  26,  27,  28,  29,
8841486Smckusick /*30*/	 30,  31,  32,  33,  34, 246, 245, 244, 216, 217,
8941486Smckusick /*40*/	218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
9041486Smckusick /*50*/	228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
9141486Smckusick /*60*/	238, 239, 249, 248, 241, 242, 247,BERR,BERR,BERR,
9264478Shibler /*70*/   70,  71,BERR,BERR,BERR,BERR,BERR,  46, 251,BERR,
9364478Shibler /*80*/ BERR,BERR,  11
9441486Smckusick };
9541486Smckusick 
96*68373Scgd notimp(p, uap, retval, code, argsize)
9743452Shibler 	struct proc *p;
98*68373Scgd 	register_t *uap, *retval;
99*68373Scgd 	int code, argsize;
10041486Smckusick {
10143452Shibler 	int error = 0;
10241486Smckusick #ifdef DEBUG
10343452Shibler 	register int *argp = uap;
10441486Smckusick 	extern char *hpuxsyscallnames[];
10541486Smckusick 
10654857Shibler 	printf("HP-UX %s(", hpuxsyscallnames[code]);
107*68373Scgd 	if (argsize)
108*68373Scgd 		while (argsize -= sizeof (register_t))
109*68373Scgd 			printf("%x%c", *argp++, argsize? ',' : ')');
11041486Smckusick 	else
11141486Smckusick 		printf(")");
11241486Smckusick 	printf("\n");
11341486Smckusick 	switch (unimpresponse) {
11441486Smckusick 	case 0:
11543452Shibler 		error = nosys(p, uap, retval);
11641486Smckusick 		break;
11741486Smckusick 	case 1:
11843452Shibler 		error = EINVAL;
11941486Smckusick 		break;
12041486Smckusick 	}
12141486Smckusick #else
12243452Shibler 	error = nosys(p, uap, retval);
12341486Smckusick #endif
12443452Shibler 	uprintf("HP-UX system call %d not implemented\n", code);
12544421Skarels 	return (error);
12641486Smckusick }
12741486Smckusick 
12864478Shibler /*
12964478Shibler  * HP-UX fork and vfork need to map the EAGAIN return value appropriately.
13064478Shibler  */
13164478Shibler hpuxfork(p, uap, retval)
13264478Shibler 	struct proc *p;
13364478Shibler 	struct hpuxwait3_args *uap;
13464478Shibler 	int *retval;
13564478Shibler {
13664478Shibler 	int error;
13764478Shibler 
13864478Shibler 	error = fork(p, uap, retval);
13964478Shibler 	if (error == EAGAIN)
14064478Shibler 		error = OEAGAIN;
14164478Shibler 	return (error);
14264478Shibler }
14364478Shibler 
14464478Shibler hpuxvfork(p, uap, retval)
14564478Shibler 	struct proc *p;
14664478Shibler 	struct hpuxwait3_args *uap;
14764478Shibler 	int *retval;
14864478Shibler 
14964478Shibler {
15064478Shibler 	int error;
15164478Shibler 
15264478Shibler 	error = vfork(p, uap, retval);
15364478Shibler 	if (error == EAGAIN)
15464478Shibler 		error = OEAGAIN;
15564478Shibler 	return (error);
15664478Shibler }
15764478Shibler 
15854917Storek struct hpuxexecv_args {
15954917Storek 	char	*fname;
16054917Storek 	char	**argp;
16154917Storek 	char	**envp;
16254917Storek };
16348478Skarels hpuxexecv(p, uap, retval)
16448478Skarels 	struct proc *p;
16554917Storek 	struct hpuxexecv_args *uap;
16648478Skarels 	int *retval;
16748478Skarels {
16848478Skarels 	extern int execve();
16948478Skarels 
17048478Skarels 	uap->envp = NULL;
17148478Skarels 	return (execve(p, uap, retval));
17248478Skarels }
17348478Skarels 
17441486Smckusick /*
17554857Shibler  * HP-UX versions of wait and wait3 actually pass the parameters
17641486Smckusick  * (status pointer, options, rusage) into the kernel rather than
17742352Smckusick  * handling it in the C library stub.  We also need to map any
17854857Shibler  * termination signal from BSD to HP-UX.
17941486Smckusick  */
18054917Storek struct hpuxwait3_args {
18154917Storek 	int	*status;
18254917Storek 	int	options;
18354917Storek 	int	rusage;
18454917Storek };
18543452Shibler hpuxwait3(p, uap, retval)
18643452Shibler 	struct proc *p;
18754917Storek 	struct hpuxwait3_args *uap;
18843452Shibler 	int *retval;
18943452Shibler {
19041486Smckusick 	/* rusage pointer must be zero */
19143452Shibler 	if (uap->rusage)
19244421Skarels 		return (EINVAL);
19352381Smckusick 	p->p_md.md_regs[PS] = PSL_ALLCC;
19452381Smckusick 	p->p_md.md_regs[R0] = uap->options;
19552381Smckusick 	p->p_md.md_regs[R1] = uap->rusage;
19644421Skarels 	return (hpuxwait(p, uap, retval));
19741486Smckusick }
19841486Smckusick 
19954917Storek struct hpuxwait_args {
20054917Storek 	int	*status;
20154917Storek };
20243452Shibler hpuxwait(p, uap, retval)
20343452Shibler 	struct proc *p;
20454917Storek 	struct hpuxwait_args *uap;
20543452Shibler 	int *retval;
20641486Smckusick {
20743452Shibler 	int sig, *statp, error;
20841486Smckusick 
20941486Smckusick 	statp = uap->status;	/* owait clobbers first arg */
210*68373Scgd 	error = compat_43_wait(p, uap, retval);
21141486Smckusick 	/*
21241486Smckusick 	 * HP-UX wait always returns EINTR when interrupted by a signal
21341486Smckusick 	 * (well, unless its emulating a BSD process, but we don't bother...)
21441486Smckusick 	 */
21543452Shibler 	if (error == ERESTART)
21643452Shibler 		error = EINTR;
21743452Shibler 	if (error)
21844421Skarels 		return (error);
21943452Shibler 	sig = retval[1] & 0xFF;
22041486Smckusick 	if (sig == WSTOPPED) {
22143452Shibler 		sig = (retval[1] >> 8) & 0xFF;
22243452Shibler 		retval[1] = (bsdtohpuxsig(sig) << 8) | WSTOPPED;
22341486Smckusick 	} else if (sig)
22443452Shibler 		retval[1] = (retval[1] & 0xFF00) |
22541486Smckusick 			bsdtohpuxsig(sig & 0x7F) | (sig & 0x80);
22641486Smckusick 	if (statp)
22743452Shibler 		if (suword((caddr_t)statp, retval[1]))
22843452Shibler 			error = EFAULT;
22944421Skarels 	return (error);
23041486Smckusick }
23141486Smckusick 
23254917Storek struct hpuxwaitpid_args {
23354917Storek 	int	pid;
23454917Storek 	int	*status;
23554917Storek 	int	options;
23654917Storek 	struct	rusage *rusage;	/* wait4 arg */
23754917Storek };
23843452Shibler hpuxwaitpid(p, uap, retval)
23943452Shibler 	struct proc *p;
24054917Storek 	struct hpuxwaitpid_args *uap;
24143452Shibler 	int *retval;
24243452Shibler {
24355832Shibler 	int rv, sig, xstat, error;
24442352Smckusick 
24542352Smckusick 	uap->rusage = 0;
24643452Shibler 	error = wait4(p, uap, retval);
24742352Smckusick 	/*
24842352Smckusick 	 * HP-UX wait always returns EINTR when interrupted by a signal
24942352Smckusick 	 * (well, unless its emulating a BSD process, but we don't bother...)
25042352Smckusick 	 */
25143452Shibler 	if (error == ERESTART)
25243452Shibler 		error = EINTR;
25343452Shibler 	if (error)
25444421Skarels 		return (error);
25555832Shibler 	if (uap->status) {
25655832Shibler 		/*
25755832Shibler 		 * Wait4 already wrote the status out to user space,
25855832Shibler 		 * pull it back, change the signal portion, and write
25955832Shibler 		 * it back out.
26055832Shibler 		 */
26155832Shibler 		rv = fuword((caddr_t)uap->status);
26255832Shibler 		if (WIFSTOPPED(rv)) {
26355832Shibler 			sig = WSTOPSIG(rv);
26455832Shibler 			rv = W_STOPCODE(bsdtohpuxsig(sig));
26555832Shibler 		} else if (WIFSIGNALED(rv)) {
26655832Shibler 			sig = WTERMSIG(rv);
26755832Shibler 			xstat = WEXITSTATUS(rv);
26855832Shibler 			rv = W_EXITCODE(xstat, bsdtohpuxsig(sig)) |
26955832Shibler 				WCOREDUMP(rv);
27055832Shibler 		}
27155832Shibler 		(void)suword((caddr_t)uap->status, rv);
27255832Shibler 	}
27344421Skarels 	return (error);
27442352Smckusick }
27542352Smckusick 
27641486Smckusick /*
27763726Shibler  * Old creat system call.
27863726Shibler  */
27963726Shibler struct hpuxcreat_args {
28063726Shibler 	char	*fname;
28163726Shibler 	int	fmode;
28263726Shibler };
28363726Shibler hpuxcreat(p, uap, retval)
28463726Shibler 	struct proc *p;
28563726Shibler 	register struct hpuxcreat_args *uap;
28663726Shibler 	int *retval;
28763726Shibler {
28863726Shibler 	struct nargs {
28963726Shibler 		char	*fname;
29063726Shibler 		int	mode;
29163726Shibler 		int	crtmode;
29263726Shibler 	} openuap;
29363726Shibler 
29463726Shibler 	openuap.fname = uap->fname;
29563726Shibler 	openuap.crtmode = uap->fmode;
29663726Shibler 	openuap.mode = O_WRONLY | O_CREAT | O_TRUNC;
29763726Shibler 	return (open(p, &openuap, retval));
29863726Shibler }
29963726Shibler 
30063726Shibler /*
30163726Shibler  * XXX extensions to the fd_ofileflags flags.
30263726Shibler  * Hate to put this there, but they do need to be per-file.
30363726Shibler  */
30463726Shibler #define UF_NONBLOCK_ON	0x10
30563726Shibler #define	UF_FNDELAY_ON	0x20
30663726Shibler #define	UF_FIONBIO_ON	0x40
30763726Shibler 
30863726Shibler /*
30941486Smckusick  * Must remap some bits in the mode mask.
31041486Smckusick  * O_CREAT, O_TRUNC, and O_EXCL must be remapped,
31163726Shibler  * O_NONBLOCK is remapped and remembered,
31263726Shibler  * O_FNDELAY is remembered,
31363726Shibler  * O_SYNCIO is removed entirely.
31441486Smckusick  */
31554917Storek struct hpuxopen_args {
31654917Storek 	char	*fname;
31754917Storek 	int	mode;
31854917Storek 	int	crtmode;
31954917Storek };
32043067Skarels hpuxopen(p, uap, retval)
32143067Skarels 	struct proc *p;
32254917Storek 	register struct hpuxopen_args *uap;
32343067Skarels 	int *retval;
32443067Skarels {
32563726Shibler 	int mode, error;
32641486Smckusick 
32741486Smckusick 	mode = uap->mode;
32863726Shibler 	uap->mode &=
32963726Shibler 		~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT);
33041486Smckusick 	if (mode & HPUXFCREAT) {
33141486Smckusick 		/*
33241486Smckusick 		 * simulate the pre-NFS behavior that opening a
33341486Smckusick 		 * file for READ+CREATE ignores the CREATE (unless
33441486Smckusick 		 * EXCL is set in which case we will return the
33541486Smckusick 		 * proper error).
33641486Smckusick 		 */
33748478Skarels 		if ((mode & HPUXFEXCL) || (FFLAGS(mode) & FWRITE))
33849950Smckusick 			uap->mode |= O_CREAT;
33941486Smckusick 	}
34041486Smckusick 	if (mode & HPUXFTRUNC)
34149950Smckusick 		uap->mode |= O_TRUNC;
34241486Smckusick 	if (mode & HPUXFEXCL)
34349950Smckusick 		uap->mode |= O_EXCL;
34463726Shibler 	if (mode & HPUXNONBLOCK)
34563726Shibler 		uap->mode |= O_NDELAY;
34663726Shibler 	error = open(p, uap, retval);
34763726Shibler 	/*
34863726Shibler 	 * Record non-blocking mode for fcntl, read, write, etc.
34963726Shibler 	 */
35063726Shibler 	if (error == 0 && (uap->mode & O_NDELAY))
35163726Shibler 		p->p_fd->fd_ofileflags[*retval] |=
35263726Shibler 			(mode & HPUXNONBLOCK) ? UF_NONBLOCK_ON : UF_FNDELAY_ON;
35363726Shibler 	return (error);
35441486Smckusick }
35541486Smckusick 
35654917Storek struct hpuxfcntl_args {
35754917Storek 	int	fdes;
35854917Storek 	int	cmd;
35954917Storek 	int	arg;
36054917Storek };
36143452Shibler hpuxfcntl(p, uap, retval)
36243452Shibler 	struct proc *p;
36354917Storek 	register struct hpuxfcntl_args *uap;
36443452Shibler 	int *retval;
36543452Shibler {
36666074Shibler 	int mode, error, flg = F_POSIX;
36766074Shibler 	struct file *fp;
36866074Shibler 	char *pop;
36966074Shibler 	struct hpuxflock hfl;
37066074Shibler 	struct flock fl;
37166074Shibler 	struct vnode *vp;
37241486Smckusick 
37366074Shibler 	if ((unsigned)uap->fdes >= p->p_fd->fd_nfiles ||
37466074Shibler 	    (fp = p->p_fd->fd_ofiles[uap->fdes]) == NULL)
37566074Shibler 		return (EBADF);
37666074Shibler 	pop = &p->p_fd->fd_ofileflags[uap->fdes];
37741486Smckusick 	switch (uap->cmd) {
37841486Smckusick 	case F_SETFL:
37963726Shibler 		if (uap->arg & HPUXNONBLOCK)
38066074Shibler 			*pop |= UF_NONBLOCK_ON;
38163726Shibler 		else
38266074Shibler 			*pop &= ~UF_NONBLOCK_ON;
38364478Shibler 		if (uap->arg & HPUXNDELAY)
38466074Shibler 			*pop |= UF_FNDELAY_ON;
38563726Shibler 		else
38666074Shibler 			*pop &= ~UF_FNDELAY_ON;
38766074Shibler 		if (*pop & (UF_NONBLOCK_ON|UF_FNDELAY_ON|UF_FIONBIO_ON))
38863726Shibler 			uap->arg |= FNONBLOCK;
38966074Shibler 		else
39066074Shibler 			uap->arg &= ~FNONBLOCK;
39163726Shibler 		uap->arg &= ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFREMOTE);
39241486Smckusick 		break;
39341486Smckusick 	case F_GETFL:
39441486Smckusick 	case F_DUPFD:
39541486Smckusick 	case F_GETFD:
39641486Smckusick 	case F_SETFD:
39741486Smckusick 		break;
39866074Shibler 
39966074Shibler 	case HPUXF_SETLKW:
40066074Shibler 		flg |= F_WAIT;
40166074Shibler 		/* Fall into F_SETLK */
40266074Shibler 
40366074Shibler 	case HPUXF_SETLK:
40466074Shibler 		if (fp->f_type != DTYPE_VNODE)
40566074Shibler 			return (EBADF);
40666074Shibler 		vp = (struct vnode *)fp->f_data;
40766074Shibler 		/* Copy in the lock structure */
40866074Shibler 		error = copyin((caddr_t)uap->arg, (caddr_t)&hfl, sizeof (hfl));
40966074Shibler 		if (error)
41066074Shibler 			return (error);
41166074Shibler 		fl.l_start = hfl.hl_start;
41266074Shibler 		fl.l_len = hfl.hl_len;
41366074Shibler 		fl.l_pid = hfl.hl_pid;
41466074Shibler 		fl.l_type = hfl.hl_type;
41566074Shibler 		fl.l_whence = hfl.hl_whence;
41666074Shibler 		if (fl.l_whence == SEEK_CUR)
41766074Shibler 			fl.l_start += fp->f_offset;
41866074Shibler 		switch (fl.l_type) {
41966074Shibler 
42066074Shibler 		case F_RDLCK:
42166074Shibler 			if ((fp->f_flag & FREAD) == 0)
42266074Shibler 				return (EBADF);
42366074Shibler 			p->p_flag |= P_ADVLOCK;
42466074Shibler 			return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
42566074Shibler 
42666074Shibler 		case F_WRLCK:
42766074Shibler 			if ((fp->f_flag & FWRITE) == 0)
42866074Shibler 				return (EBADF);
42966074Shibler 			p->p_flag |= P_ADVLOCK;
43066074Shibler 			return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
43166074Shibler 
43266074Shibler 		case F_UNLCK:
43366074Shibler 			return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
43466074Shibler 				F_POSIX));
43566074Shibler 
43666074Shibler 		default:
43766074Shibler 			return (EINVAL);
43866074Shibler 		}
43966074Shibler 
44066074Shibler 	case F_GETLK:
44166074Shibler 		if (fp->f_type != DTYPE_VNODE)
44266074Shibler 			return (EBADF);
44366074Shibler 		vp = (struct vnode *)fp->f_data;
44466074Shibler 		/* Copy in the lock structure */
44566074Shibler 		error = copyin((caddr_t)uap->arg, (caddr_t)&hfl, sizeof (hfl));
44666074Shibler 		if (error)
44766074Shibler 			return (error);
44866074Shibler 		fl.l_start = hfl.hl_start;
44966074Shibler 		fl.l_len = hfl.hl_len;
45066074Shibler 		fl.l_pid = hfl.hl_pid;
45166074Shibler 		fl.l_type = hfl.hl_type;
45266074Shibler 		fl.l_whence = hfl.hl_whence;
45366074Shibler 		if (fl.l_whence == SEEK_CUR)
45466074Shibler 			fl.l_start += fp->f_offset;
45566074Shibler 		if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX))
45666074Shibler 			return (error);
45766074Shibler 		hfl.hl_start = fl.l_start;
45866074Shibler 		hfl.hl_len = fl.l_len;
45966074Shibler 		hfl.hl_pid = fl.l_pid;
46066074Shibler 		hfl.hl_type = fl.l_type;
46166074Shibler 		hfl.hl_whence = fl.l_whence;
46266074Shibler 		return (copyout((caddr_t)&hfl, (caddr_t)uap->arg, sizeof (hfl)));
46366074Shibler 
46441486Smckusick 	default:
46544421Skarels 		return (EINVAL);
46641486Smckusick 	}
46743452Shibler 	error = fcntl(p, uap, retval);
46849329Shibler 	if (error == 0 && uap->cmd == F_GETFL) {
46943452Shibler 		mode = *retval;
47063726Shibler 		*retval &= ~(O_CREAT|O_TRUNC|O_EXCL);
47163726Shibler 		if (mode & FNONBLOCK) {
47266074Shibler 			if (*pop & UF_NONBLOCK_ON)
47363726Shibler 				*retval |= HPUXNONBLOCK;
47466074Shibler 			if ((*pop & UF_FNDELAY_ON) == 0)
47564478Shibler 				*retval &= ~HPUXNDELAY;
47663726Shibler 		}
47749950Smckusick 		if (mode & O_CREAT)
47843452Shibler 			*retval |= HPUXFCREAT;
47949950Smckusick 		if (mode & O_TRUNC)
48043452Shibler 			*retval |= HPUXFTRUNC;
48149950Smckusick 		if (mode & O_EXCL)
48243452Shibler 			*retval |= HPUXFEXCL;
48341486Smckusick 	}
48444421Skarels 	return (error);
48541486Smckusick }
48641486Smckusick 
48741486Smckusick /*
48863726Shibler  * Read and write calls.  Same as BSD except for non-blocking behavior.
48963726Shibler  * There are three types of non-blocking reads/writes in HP-UX checked
49063726Shibler  * in the following order:
49149329Shibler  *
49263726Shibler  *	O_NONBLOCK: return -1 and errno == EAGAIN
49363726Shibler  *	O_NDELAY:   return 0
49463726Shibler  *	FIOSNBIO:   return -1 and errno == EWOULDBLOCK
49541486Smckusick  */
49663726Shibler struct hpuxrw_args {
49763726Shibler 	int fd;
49854917Storek };
49963726Shibler 
50043452Shibler hpuxread(p, uap, retval)
50143452Shibler 	struct proc *p;
50263726Shibler 	struct hpuxrw_args *uap;
50343452Shibler 	int *retval;
50441486Smckusick {
50543452Shibler 	int error;
50641486Smckusick 
50743452Shibler 	error = read(p, uap, retval);
50863726Shibler 	if (error == EWOULDBLOCK) {
50963726Shibler 		char *fp = &p->p_fd->fd_ofileflags[uap->fd];
51063726Shibler 
51163726Shibler 		if (*fp & UF_NONBLOCK_ON) {
51263726Shibler 			*retval = -1;
51364478Shibler 			error = OEAGAIN;
51463726Shibler 		} else if (*fp & UF_FNDELAY_ON) {
51563726Shibler 			*retval = 0;
51663726Shibler 			error = 0;
51763726Shibler 		}
51841486Smckusick 	}
51944421Skarels 	return (error);
52041486Smckusick }
52141486Smckusick 
52243452Shibler hpuxwrite(p, uap, retval)
52343452Shibler 	struct proc *p;
52463726Shibler 	struct hpuxrw_args *uap;
52543452Shibler 	int *retval;
52641486Smckusick {
52743452Shibler 	int error;
52841486Smckusick 
52943452Shibler 	error = write(p, uap, retval);
53063726Shibler 	if (error == EWOULDBLOCK) {
53163726Shibler 		char *fp = &p->p_fd->fd_ofileflags[uap->fd];
53263726Shibler 
53363726Shibler 		if (*fp & UF_NONBLOCK_ON) {
53463726Shibler 			*retval = -1;
53564478Shibler 			error = OEAGAIN;
53663726Shibler 		} else if (*fp & UF_FNDELAY_ON) {
53763726Shibler 			*retval = 0;
53863726Shibler 			error = 0;
53963726Shibler 		}
54041486Smckusick 	}
54144421Skarels 	return (error);
54241486Smckusick }
54341486Smckusick 
54443452Shibler hpuxreadv(p, uap, retval)
54543452Shibler 	struct proc *p;
54663726Shibler 	struct hpuxrw_args *uap;
54743452Shibler 	int *retval;
54841486Smckusick {
54943452Shibler 	int error;
55041486Smckusick 
55143452Shibler 	error = readv(p, uap, retval);
55263726Shibler 	if (error == EWOULDBLOCK) {
55363726Shibler 		char *fp = &p->p_fd->fd_ofileflags[uap->fd];
55463726Shibler 
55563726Shibler 		if (*fp & UF_NONBLOCK_ON) {
55663726Shibler 			*retval = -1;
55764478Shibler 			error = OEAGAIN;
55863726Shibler 		} else if (*fp & UF_FNDELAY_ON) {
55963726Shibler 			*retval = 0;
56063726Shibler 			error = 0;
56163726Shibler 		}
56241486Smckusick 	}
56344421Skarels 	return (error);
56441486Smckusick }
56541486Smckusick 
56643452Shibler hpuxwritev(p, uap, retval)
56743452Shibler 	struct proc *p;
56863726Shibler 	struct hpuxrw_args *uap;
56943452Shibler 	int *retval;
57041486Smckusick {
57143452Shibler 	int error;
57241486Smckusick 
57343452Shibler 	error = writev(p, uap, retval);
57463726Shibler 	if (error == EWOULDBLOCK) {
57563726Shibler 		char *fp = &p->p_fd->fd_ofileflags[uap->fd];
57663726Shibler 
57763726Shibler 		if (*fp & UF_NONBLOCK_ON) {
57863726Shibler 			*retval = -1;
57964478Shibler 			error = OEAGAIN;
58063726Shibler 		} else if (*fp & UF_FNDELAY_ON) {
58163726Shibler 			*retval = 0;
58263726Shibler 			error = 0;
58363726Shibler 		}
58441486Smckusick 	}
58544421Skarels 	return (error);
58641486Smckusick }
58741486Smckusick 
58841486Smckusick /*
58941486Smckusick  * 4.3bsd dup allows dup2 to come in on the same syscall entry
59054857Shibler  * and hence allows two arguments.  HP-UX dup has only one arg.
59141486Smckusick  */
59254917Storek struct hpuxdup_args {
59354917Storek 	int	i;
59454917Storek };
59543452Shibler hpuxdup(p, uap, retval)
59643452Shibler 	struct proc *p;
59754917Storek 	register struct hpuxdup_args *uap;
59843452Shibler 	int *retval;
59941486Smckusick {
60045923Smckusick 	register struct filedesc *fdp = p->p_fd;
60141486Smckusick 	struct file *fp;
60243452Shibler 	int fd, error;
60341486Smckusick 
60448478Skarels 	if (((unsigned)uap->i) >= fdp->fd_nfiles ||
60548478Skarels 	    (fp = fdp->fd_ofiles[uap->i]) == NULL)
60644421Skarels 		return (EBADF);
60748478Skarels 	if (error = fdalloc(p, 0, &fd))
60844421Skarels 		return (error);
60948478Skarels 	fdp->fd_ofiles[fd] = fp;
61048478Skarels 	fdp->fd_ofileflags[fd] = fdp->fd_ofileflags[uap->i] &~ UF_EXCLOSE;
61145923Smckusick 	fp->f_count++;
61245923Smckusick 	if (fd > fdp->fd_lastfile)
61345923Smckusick 		fdp->fd_lastfile = fd;
61443452Shibler 	*retval = fd;
61544421Skarels 	return (0);
61641486Smckusick }
61741486Smckusick 
61854917Storek struct hpuxutssys_args {
61954917Storek 	struct hpuxutsname *uts;
62054917Storek 	int dev;
62154917Storek 	int request;
62254917Storek };
62345753Smckusick hpuxutssys(p, uap, retval)
62443452Shibler 	struct proc *p;
62554917Storek 	register struct hpuxutssys_args *uap;
62643452Shibler 	int *retval;
62743452Shibler {
62841486Smckusick 	register int i;
62943452Shibler 	int error;
63041486Smckusick 
63141486Smckusick 	switch (uap->request) {
63241486Smckusick 	/* uname */
63341486Smckusick 	case 0:
63441486Smckusick 		/* fill in machine type */
63541486Smckusick 		switch (machineid) {
63641486Smckusick 		case HP_320:
63741486Smckusick 			protoutsname.machine[6] = '2';
63841486Smckusick 			break;
63941486Smckusick 		/* includes 318 and 319 */
64041486Smckusick 		case HP_330:
64141486Smckusick 			protoutsname.machine[6] = '3';
64241486Smckusick 			break;
64341486Smckusick 		case HP_340:
64441486Smckusick 			protoutsname.machine[6] = '4';
64541486Smckusick 			break;
64641486Smckusick 		case HP_350:
64741486Smckusick 			protoutsname.machine[6] = '5';
64841486Smckusick 			break;
64941486Smckusick 		case HP_360:
65041486Smckusick 			protoutsname.machine[6] = '6';
65141486Smckusick 			break;
65241486Smckusick 		case HP_370:
65341486Smckusick 			protoutsname.machine[6] = '7';
65441486Smckusick 			break;
65543452Shibler 		/* includes 345 */
65643452Shibler 		case HP_375:
65743452Shibler 			protoutsname.machine[6] = '7';
65843452Shibler 			protoutsname.machine[7] = '5';
65943452Shibler 			break;
66054857Shibler 		/* includes 425 */
66154857Shibler 		case HP_380:
66254857Shibler 			protoutsname.machine[6] = '8';
66354857Shibler 			break;
66457307Shibler 		case HP_433:
66557307Shibler 			protoutsname.machine[5] = '4';
66657307Shibler 			protoutsname.machine[6] = '3';
66757307Shibler 			protoutsname.machine[7] = '3';
66857307Shibler 			break;
66941486Smckusick 		}
67041486Smckusick 		/* copy hostname (sans domain) to nodename */
67149329Shibler 		for (i = 0; i < 8 && hostname[i] != '.'; i++)
67241486Smckusick 			protoutsname.nodename[i] = hostname[i];
67349329Shibler 		protoutsname.nodename[i] = '\0';
67443452Shibler 		error = copyout((caddr_t)&protoutsname, (caddr_t)uap->uts,
67543452Shibler 				sizeof(struct hpuxutsname));
67641486Smckusick 		break;
67745753Smckusick 
67845753Smckusick 	/* gethostname */
67945753Smckusick 	case 5:
68045753Smckusick 		/* uap->dev is length */
68145753Smckusick 		if (uap->dev > hostnamelen + 1)
68245753Smckusick 			uap->dev = hostnamelen + 1;
68345753Smckusick 		error = copyout((caddr_t)hostname, (caddr_t)uap->uts,
68445753Smckusick 				uap->dev);
68545753Smckusick 		break;
68645753Smckusick 
68745753Smckusick 	case 1:	/* ?? */
68845753Smckusick 	case 2:	/* ustat */
68945753Smckusick 	case 3:	/* ?? */
69045753Smckusick 	case 4:	/* sethostname */
69141486Smckusick 	default:
69243452Shibler 		error = EINVAL;
69341486Smckusick 		break;
69441486Smckusick 	}
69544421Skarels 	return (error);
69641486Smckusick }
69741486Smckusick 
69854917Storek struct hpuxsysconf_args {
69954917Storek 	int	name;
70054917Storek };
70153922Shibler hpuxsysconf(p, uap, retval)
70253922Shibler 	struct proc *p;
70354917Storek 	struct hpuxsysconf_args *uap;
70453922Shibler 	int *retval;
70553922Shibler {
70653922Shibler 	switch (uap->name) {
70753922Shibler 
70864905Shibler 	/* clock ticks per second */
70964905Shibler 	case HPUX_SYSCONF_CLKTICK:
71064905Shibler 		*retval = hz;
71164905Shibler 		break;
71264905Shibler 
71353922Shibler 	/* open files */
71453922Shibler 	case HPUX_SYSCONF_OPENMAX:
71553922Shibler 		*retval = NOFILE;
71653922Shibler 		break;
71753922Shibler 
71853922Shibler 	/* architecture */
71953922Shibler 	case HPUX_SYSCONF_CPUTYPE:
72053922Shibler 		switch (machineid) {
72153922Shibler 		case HP_320:
72253922Shibler 		case HP_330:
72353922Shibler 		case HP_350:
72453922Shibler 			*retval = HPUX_SYSCONF_CPUM020;
72553922Shibler 			break;
72653922Shibler 		case HP_340:
72753922Shibler 		case HP_360:
72853922Shibler 		case HP_370:
72953922Shibler 		case HP_375:
73053922Shibler 			*retval = HPUX_SYSCONF_CPUM030;
73153922Shibler 			break;
73253922Shibler 		case HP_380:
73357307Shibler 		case HP_433:
73453922Shibler 			*retval = HPUX_SYSCONF_CPUM040;
73553922Shibler 			break;
73653922Shibler 		}
73753922Shibler 		break;
73853922Shibler 	default:
73954857Shibler 		uprintf("HP-UX sysconf(%d) not implemented\n", uap->name);
74053922Shibler 		return (EINVAL);
74153922Shibler 	}
74253922Shibler 	return (0);
74353922Shibler }
74453922Shibler 
74554917Storek struct hpuxstat_args {
74654917Storek 	char	*fname;
74754917Storek 	struct hpuxstat *hsb;
74854917Storek };
74943452Shibler hpuxstat(p, uap, retval)
75043452Shibler 	struct proc *p;
75154917Storek 	struct hpuxstat_args *uap;
75243452Shibler 	int *retval;
75343452Shibler {
75455282Smckusick 	return (hpuxstat1(uap->fname, uap->hsb, FOLLOW, p));
75541486Smckusick }
75641486Smckusick 
75754917Storek struct hpuxlstat_args {
75854917Storek 	char	*fname;
75954917Storek 	struct hpuxstat *hsb;
76054917Storek };
76143452Shibler hpuxlstat(p, uap, retval)
76243452Shibler 	struct proc *p;
76354917Storek 	struct hpuxlstat_args *uap;
76443452Shibler 	int *retval;
76541486Smckusick {
76655282Smckusick 	return (hpuxstat1(uap->fname, uap->hsb, NOFOLLOW, p));
76741486Smckusick }
76841486Smckusick 
76954917Storek struct hpuxfstat_args {
77054917Storek 	int	fdes;
77154917Storek 	struct	hpuxstat *hsb;
77254917Storek };
77343452Shibler hpuxfstat(p, uap, retval)
77443452Shibler 	struct proc *p;
77554917Storek 	register struct hpuxfstat_args *uap;
77643452Shibler 	int *retval;
77741486Smckusick {
77845923Smckusick 	register struct filedesc *fdp = p->p_fd;
77941486Smckusick 	register struct file *fp;
78041486Smckusick 	struct stat sb;
78143452Shibler 	int error;
78241486Smckusick 
78348478Skarels 	if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
78448478Skarels 	    (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
78544421Skarels 		return (EBADF);
78643452Shibler 
78741486Smckusick 	switch (fp->f_type) {
78841486Smckusick 
78941486Smckusick 	case DTYPE_VNODE:
79055282Smckusick 		error = vn_stat((struct vnode *)fp->f_data, &sb, p);
79141486Smckusick 		break;
79241486Smckusick 
79341486Smckusick 	case DTYPE_SOCKET:
79455282Smckusick 		error = soo_stat((struct socket *)fp->f_data, &sb, p);
79541486Smckusick 		break;
79641486Smckusick 
79741486Smckusick 	default:
79841486Smckusick 		panic("fstat");
79941486Smckusick 		/*NOTREACHED*/
80041486Smckusick 	}
80141486Smckusick 	/* is this right for sockets?? */
80243452Shibler 	if (error == 0)
80343452Shibler 		error = bsdtohpuxstat(&sb, uap->hsb);
80444421Skarels 	return (error);
80541486Smckusick }
80641486Smckusick 
80754917Storek struct hpuxulimit_args {
80854917Storek 	int	cmd;
80954917Storek 	long	newlimit;
81054917Storek };
81143452Shibler hpuxulimit(p, uap, retval)
81243452Shibler 	struct proc *p;
81354917Storek 	register struct hpuxulimit_args *uap;
81453481Smckusick 	long *retval;
81543452Shibler {
81641486Smckusick 	struct rlimit *limp;
81743452Shibler 	int error = 0;
81841486Smckusick 
81948478Skarels 	limp = &p->p_rlimit[RLIMIT_FSIZE];
82041486Smckusick 	switch (uap->cmd) {
82141486Smckusick 	case 2:
82241486Smckusick 		uap->newlimit *= 512;
82341486Smckusick 		if (uap->newlimit > limp->rlim_max &&
82448478Skarels 		    (error = suser(p->p_ucred, &p->p_acflag)))
82541486Smckusick 			break;
82641486Smckusick 		limp->rlim_cur = limp->rlim_max = uap->newlimit;
82741486Smckusick 		/* else fall into... */
82841486Smckusick 
82941486Smckusick 	case 1:
83045753Smckusick 		*retval = limp->rlim_max / 512;
83141486Smckusick 		break;
83241486Smckusick 
83341486Smckusick 	case 3:
83448478Skarels 		limp = &p->p_rlimit[RLIMIT_DATA];
83548478Skarels 		*retval = ctob(p->p_vmspace->vm_tsize) + limp->rlim_max;
83641486Smckusick 		break;
83741486Smckusick 
83841486Smckusick 	default:
83943452Shibler 		error = EINVAL;
84041486Smckusick 		break;
84141486Smckusick 	}
84244421Skarels 	return (error);
84341486Smckusick }
84441486Smckusick 
84541486Smckusick /*
84641486Smckusick  * Map "real time" priorities 0 (high) thru 127 (low) into nice
84741486Smckusick  * values -16 (high) thru -1 (low).
84841486Smckusick  */
84954917Storek struct hpuxrtprio_args {
85054917Storek 	int pid;
85154917Storek 	int prio;
85254917Storek };
85343452Shibler hpuxrtprio(cp, uap, retval)
85443452Shibler 	struct proc *cp;
85554917Storek 	register struct hpuxrtprio_args *uap;
85643452Shibler 	int *retval;
85743452Shibler {
85841486Smckusick 	struct proc *p;
85943452Shibler 	int nice, error;
86041486Smckusick 
86141486Smckusick 	if (uap->prio < RTPRIO_MIN && uap->prio > RTPRIO_MAX &&
86243452Shibler 	    uap->prio != RTPRIO_NOCHG && uap->prio != RTPRIO_RTOFF)
86344421Skarels 		return (EINVAL);
86441486Smckusick 	if (uap->pid == 0)
86543452Shibler 		p = cp;
86643452Shibler 	else if ((p = pfind(uap->pid)) == 0)
86744421Skarels 		return (ESRCH);
86841486Smckusick 	nice = p->p_nice;
86941486Smckusick 	if (nice < NZERO)
87043452Shibler 		*retval = (nice + 16) << 3;
87141486Smckusick 	else
87243452Shibler 		*retval = RTPRIO_RTOFF;
87341486Smckusick 	switch (uap->prio) {
87441486Smckusick 
87541486Smckusick 	case RTPRIO_NOCHG:
87644421Skarels 		return (0);
87741486Smckusick 
87841486Smckusick 	case RTPRIO_RTOFF:
87941486Smckusick 		if (nice >= NZERO)
88044421Skarels 			return (0);
88141486Smckusick 		nice = NZERO;
88241486Smckusick 		break;
88341486Smckusick 
88441486Smckusick 	default:
88541486Smckusick 		nice = (uap->prio >> 3) - 16;
88641486Smckusick 		break;
88741486Smckusick 	}
88843452Shibler 	error = donice(cp, p, nice);
88943452Shibler 	if (error == EACCES)
89043452Shibler 		error = EPERM;
89144421Skarels 	return (error);
89241486Smckusick }
89341486Smckusick 
89454917Storek struct hpuxadvise_args {
89554917Storek 	int	arg;
89654917Storek };
89743452Shibler hpuxadvise(p, uap, retval)
89843452Shibler 	struct proc *p;
89954917Storek 	struct hpuxadvise_args *uap;
90043452Shibler 	int *retval;
90141486Smckusick {
90243452Shibler 	int error = 0;
90341486Smckusick 
90441486Smckusick 	switch (uap->arg) {
90541486Smckusick 	case 0:
90657307Shibler 		p->p_md.md_flags |= MDP_HPUXMMAP;
90741486Smckusick 		break;
90841486Smckusick 	case 1:
90941486Smckusick 		ICIA();
91041486Smckusick 		break;
91141486Smckusick 	case 2:
91241486Smckusick 		DCIA();
91341486Smckusick 		break;
91441486Smckusick 	default:
91543452Shibler 		error = EINVAL;
91641486Smckusick 		break;
91741486Smckusick 	}
91844421Skarels 	return (error);
91941486Smckusick }
92041486Smckusick 
92154917Storek struct hpuxptrace_args {
92254917Storek 	int	req;
92354917Storek 	int	pid;
92454917Storek 	int	*addr;
92554917Storek 	int	data;
92654917Storek };
92743452Shibler hpuxptrace(p, uap, retval)
92843452Shibler 	struct proc *p;
92954917Storek 	struct hpuxptrace_args *uap;
93043452Shibler 	int *retval;
93143452Shibler {
93257307Shibler 	int error, isps = 0;
93357307Shibler 	struct proc *cp;
93441486Smckusick 
93557307Shibler 	switch (uap->req) {
93657307Shibler 	/* map signal */
93757307Shibler 	case PT_STEP:
93857307Shibler 	case PT_CONTINUE:
93941486Smckusick 		if (uap->data) {
94041486Smckusick 			uap->data = hpuxtobsdsig(uap->data);
94141486Smckusick 			if (uap->data == 0)
94241486Smckusick 				uap->data = NSIG;
94341486Smckusick 		}
94457307Shibler 		break;
94557307Shibler 	/* map u-area offset */
94657307Shibler 	case PT_READ_U:
94757307Shibler 	case PT_WRITE_U:
94857307Shibler 		/*
94957307Shibler 		 * Big, cheezy hack: hpuxtobsduoff is really intended
95057307Shibler 		 * to be called in the child context (procxmt) but we
95157307Shibler 		 * do it here in the parent context to avoid hacks in
95257307Shibler 		 * the MI sys_process.c file.  This works only because
95357307Shibler 		 * we can access the child's md_regs pointer and it
95457307Shibler 		 * has the correct value (the child has already trapped
95557307Shibler 		 * into the kernel).
95657307Shibler 		 */
95757307Shibler 		if ((cp = pfind(uap->pid)) == 0)
95857307Shibler 			return (ESRCH);
95957307Shibler 		uap->addr = (int *) hpuxtobsduoff(uap->addr, &isps, cp);
96057307Shibler 
96157307Shibler 		/*
96257307Shibler 		 * Since HP-UX PS is only 16-bits in ar0, requests
96357307Shibler 		 * to write PS actually contain the PS in the high word
96457307Shibler 		 * and the high half of the PC (the following register)
96557307Shibler 		 * in the low word.  Move the PS value to where BSD
96657307Shibler 		 * expects it.
96757307Shibler 		 */
96857307Shibler 		if (isps && uap->req == PT_WRITE_U)
96957307Shibler 			uap->data >>= 16;
97057307Shibler 		break;
97141486Smckusick 	}
97243452Shibler 	error = ptrace(p, uap, retval);
97357307Shibler 	/*
97457307Shibler 	 * Align PS as HP-UX expects it (see WRITE_U comment above).
97557307Shibler 	 * Note that we do not return the high part of PC like HP-UX
97657307Shibler 	 * would, but the HP-UX debuggers don't require it.
97757307Shibler 	 */
97857307Shibler 	if (isps && error == 0 && uap->req == PT_READ_U)
97957307Shibler 		*retval <<= 16;
98044421Skarels 	return (error);
98141486Smckusick }
98241486Smckusick 
98354917Storek struct hpuxgetdomainname_args {
98454917Storek 	char	*domainname;
98554917Storek 	u_int	len;
98654917Storek };
98743452Shibler hpuxgetdomainname(p, uap, retval)
98843452Shibler 	struct proc *p;
98954917Storek 	register struct hpuxgetdomainname_args *uap;
99043452Shibler 	int *retval;
99143452Shibler {
99241486Smckusick 	if (uap->len > domainnamelen + 1)
99341486Smckusick 		uap->len = domainnamelen + 1;
99444421Skarels 	return (copyout(domainname, uap->domainname, uap->len));
99541486Smckusick }
99641486Smckusick 
99754917Storek struct hpuxsetdomainname_args {
99854917Storek 	char	*domainname;
99954917Storek 	u_int	len;
100054917Storek };
100143452Shibler hpuxsetdomainname(p, uap, retval)
100243452Shibler 	struct proc *p;
100354917Storek 	register struct hpuxsetdomainname_args *uap;
100443452Shibler 	int *retval;
100543452Shibler {
100643452Shibler 	int error;
100741486Smckusick 
100848478Skarels 	if (error = suser(p->p_ucred, &p->p_acflag))
100944421Skarels 		return (error);
101043452Shibler 	if (uap->len > sizeof (domainname) - 1)
101144421Skarels 		return (EINVAL);
101241486Smckusick 	domainnamelen = uap->len;
101343452Shibler 	error = copyin(uap->domainname, domainname, uap->len);
101441486Smckusick 	domainname[domainnamelen] = 0;
101544421Skarels 	return (error);
101641486Smckusick }
101741486Smckusick 
101841486Smckusick #ifdef SYSVSHM
101956506Sbostic #include <sys/shm.h>
102054857Shibler 
102143452Shibler hpuxshmat(p, uap, retval)
102243452Shibler 	struct proc *p;
102343452Shibler 	int *uap, *retval;
102441486Smckusick {
102544421Skarels 	return (shmat(p, uap, retval));
102641486Smckusick }
102741486Smckusick 
102843452Shibler hpuxshmdt(p, uap, retval)
102943452Shibler 	struct proc *p;
103043452Shibler 	int *uap, *retval;
103141486Smckusick {
103244421Skarels 	return (shmdt(p, uap, retval));
103341486Smckusick }
103441486Smckusick 
103543452Shibler hpuxshmget(p, uap, retval)
103643452Shibler 	struct proc *p;
103743452Shibler 	int *uap, *retval;
103841486Smckusick {
103944421Skarels 	return (shmget(p, uap, retval));
104041486Smckusick }
104154857Shibler 
104264478Shibler hpuxshmctl(p, uap, retval)
104364478Shibler 	struct proc *p;
104464478Shibler 	int *uap, *retval;
104564478Shibler {
104664478Shibler 	return (hpuxshmctl1(p, uap, retval, 0));
104764478Shibler }
104864478Shibler 
104964478Shibler hpuxnshmctl(p, uap, retval)
105064478Shibler 	struct proc *p;
105164478Shibler 	int *uap, *retval;
105264478Shibler {
105364478Shibler 	return (hpuxshmctl1(p, uap, retval, 1));
105464478Shibler }
105564478Shibler 
105654857Shibler /*
105754857Shibler  * Handle HP-UX specific commands.
105854857Shibler  */
105954917Storek struct hpuxshmctl_args {
106054917Storek 	int shmid;
106154917Storek 	int cmd;
106254917Storek 	caddr_t buf;
106354917Storek };
106464478Shibler hpuxshmctl1(p, uap, retval, isnew)
106554857Shibler 	struct proc *p;
106654917Storek 	struct hpuxshmctl_args *uap;
106754857Shibler 	int *retval;
106864478Shibler 	int isnew;
106954857Shibler {
107054857Shibler 	register struct shmid_ds *shp;
107154857Shibler 	register struct ucred *cred = p->p_ucred;
107264478Shibler 	struct hpuxshmid_ds sbuf;
107354857Shibler 	int error;
107454857Shibler 
107554857Shibler 	if (error = shmvalid(uap->shmid))
107654857Shibler 		return (error);
107754857Shibler 	shp = &shmsegs[uap->shmid % SHMMMNI];
107864478Shibler 	switch (uap->cmd) {
107964478Shibler 	case SHM_LOCK:
108064478Shibler 	case SHM_UNLOCK:
108154857Shibler 		/* don't really do anything, but make them think we did */
108254857Shibler 		if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
108354857Shibler 		    cred->cr_uid != shp->shm_perm.cuid)
108454857Shibler 			return (EPERM);
108554857Shibler 		return (0);
108664478Shibler 
108764478Shibler 	case IPC_STAT:
108864478Shibler 		if (!isnew)
108964478Shibler 			break;
109064478Shibler 		error = ipcaccess(&shp->shm_perm, IPC_R, cred);
109164478Shibler 		if (error == 0) {
109264478Shibler 			sbuf.shm_perm.uid = shp->shm_perm.uid;
109364478Shibler 			sbuf.shm_perm.gid = shp->shm_perm.gid;
109464478Shibler 			sbuf.shm_perm.cuid = shp->shm_perm.cuid;
109564478Shibler 			sbuf.shm_perm.cgid = shp->shm_perm.cgid;
109664478Shibler 			sbuf.shm_perm.mode = shp->shm_perm.mode;
109764478Shibler 			sbuf.shm_perm.seq = shp->shm_perm.seq;
109864478Shibler 			sbuf.shm_perm.key = shp->shm_perm.key;
109964478Shibler 			sbuf.shm_segsz = shp->shm_segsz;
110064478Shibler 			sbuf.shm_ptbl = shp->shm_handle;	/* XXX */
110164478Shibler 			sbuf.shm_lpid = shp->shm_lpid;
110264478Shibler 			sbuf.shm_cpid = shp->shm_cpid;
110364478Shibler 			sbuf.shm_nattch = shp->shm_nattch;
110464478Shibler 			sbuf.shm_cnattch = shp->shm_nattch;	/* XXX */
110564478Shibler 			sbuf.shm_atime = shp->shm_atime;
110664478Shibler 			sbuf.shm_dtime = shp->shm_dtime;
110764478Shibler 			sbuf.shm_ctime = shp->shm_ctime;
110864478Shibler 			error = copyout((caddr_t)&sbuf, uap->buf, sizeof sbuf);
110964478Shibler 		}
111064478Shibler 		return (error);
111164478Shibler 
111264478Shibler 	case IPC_SET:
111364478Shibler 		if (!isnew)
111464478Shibler 			break;
111564478Shibler 		if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
111664478Shibler 		    cred->cr_uid != shp->shm_perm.cuid) {
111764478Shibler 			return (EPERM);
111864478Shibler 		}
111964478Shibler 		error = copyin(uap->buf, (caddr_t)&sbuf, sizeof sbuf);
112064478Shibler 		if (error == 0) {
112164478Shibler 			shp->shm_perm.uid = sbuf.shm_perm.uid;
112264478Shibler 			shp->shm_perm.gid = sbuf.shm_perm.gid;
112364478Shibler 			shp->shm_perm.mode = (shp->shm_perm.mode & ~0777)
112464478Shibler 				| (sbuf.shm_perm.mode & 0777);
112564478Shibler 			shp->shm_ctime = time.tv_sec;
112664478Shibler 		}
112764478Shibler 		return (error);
112854857Shibler 	}
112954857Shibler 	return (shmctl(p, uap, retval));
113054857Shibler }
113141486Smckusick #endif
113241486Smckusick 
113341486Smckusick /*
113441486Smckusick  * Fake semaphore routines, just don't return an error.
113541486Smckusick  * Should be adequate for starbase to run.
113641486Smckusick  */
113754917Storek struct hpuxsemctl_args {
113854917Storek 	int semid;
113954917Storek 	u_int semnum;
114054917Storek 	int cmd;
114154917Storek 	int arg;
114254917Storek };
114343452Shibler hpuxsemctl(p, uap, retval)
114443452Shibler 	struct proc *p;
114554917Storek 	struct hpuxsemctl_args *uap;
114643452Shibler 	int *retval;
114743452Shibler {
114841486Smckusick 	/* XXX: should do something here */
114944421Skarels 	return (0);
115041486Smckusick }
115141486Smckusick 
115254917Storek struct hpuxsemget_args {
115354917Storek 	key_t key;
115454917Storek 	int nsems;
115554917Storek 	int semflg;
115654917Storek };
115743452Shibler hpuxsemget(p, uap, retval)
115843452Shibler 	struct proc *p;
115954917Storek 	struct hpuxsemget_args *uap;
116043452Shibler 	int *retval;
116143452Shibler {
116241486Smckusick 	/* XXX: should do something here */
116344421Skarels 	return (0);
116441486Smckusick }
116541486Smckusick 
116654917Storek struct hpuxsemop_args {
116754917Storek 	int semid;
116854917Storek 	struct sembuf *sops;
116954917Storek 	u_int nsops;
117054917Storek };
117143452Shibler hpuxsemop(p, uap, retval)
117243452Shibler 	struct proc *p;
117354917Storek 	struct hpuxsemop_args *uap;
117443452Shibler 	int *retval;
117543452Shibler {
117641486Smckusick 	/* XXX: should do something here */
117744421Skarels 	return (0);
117841486Smckusick }
117941486Smckusick 
118057307Shibler /*
118157307Shibler  * HP-UX mmap() emulation (mainly for shared library support).
118257307Shibler  */
118357307Shibler struct hpuxmmap_args {
118457307Shibler 	caddr_t	addr;
118557307Shibler 	int	len;
118657307Shibler 	int	prot;
118757307Shibler 	int	flags;
118857307Shibler 	int	fd;
118957307Shibler 	long	pos;
119057307Shibler };
119157307Shibler hpuxmmap(p, uap, retval)
119257307Shibler 	struct proc *p;
119357307Shibler 	struct hpuxmmap_args *uap;
119457307Shibler 	int *retval;
119557307Shibler {
119657307Shibler 	struct mmap_args {
119757307Shibler 		caddr_t	addr;
119857307Shibler 		int	len;
119957307Shibler 		int	prot;
120057307Shibler 		int	flags;
120157307Shibler 		int	fd;
120257307Shibler 		long	pad;
120357307Shibler 		off_t	pos;
120457307Shibler 	} nargs;
120557307Shibler 
120657307Shibler 	nargs.addr = uap->addr;
120757307Shibler 	nargs.len = uap->len;
120857307Shibler 	nargs.prot = uap->prot;
120957307Shibler 	nargs.flags = uap->flags &
121057307Shibler 		~(HPUXMAP_FIXED|HPUXMAP_REPLACE|HPUXMAP_ANON);
121157307Shibler 	if (uap->flags & HPUXMAP_FIXED)
121257307Shibler 		nargs.flags |= MAP_FIXED;
121357307Shibler 	if (uap->flags & HPUXMAP_ANON)
121457307Shibler 		nargs.flags |= MAP_ANON;
121557307Shibler 	nargs.fd = (nargs.flags & MAP_ANON) ? -1 : uap->fd;
121657307Shibler 	nargs.pos = uap->pos;
121763440Sbostic 	return (mmap(p, &nargs, retval));
121857307Shibler }
121957307Shibler 
122054857Shibler /* convert from BSD to HP-UX errno */
bsdtohpuxerrno(err)122141486Smckusick bsdtohpuxerrno(err)
122241486Smckusick 	int err;
122341486Smckusick {
122441486Smckusick 	if (err < 0 || err >= NERR)
122541486Smckusick 		return(BERR);
122641486Smckusick 	return((int)bsdtohpuxerrnomap[err]);
122741486Smckusick }
122841486Smckusick 
hpuxstat1(fname,hsb,follow,p)122955282Smckusick hpuxstat1(fname, hsb, follow, p)
123041486Smckusick 	char *fname;
123141486Smckusick 	struct hpuxstat *hsb;
123241486Smckusick 	int follow;
123355282Smckusick 	struct proc *p;
123441486Smckusick {
123548478Skarels 	int error;
123641486Smckusick 	struct stat sb;
123748478Skarels 	struct nameidata nd;
123841486Smckusick 
123955282Smckusick 	NDINIT(&nd, LOOKUP, follow | LOCKLEAF, UIO_USERSPACE, fname, p);
124052330Smckusick 	if (error = namei(&nd))
124141486Smckusick 		return (error);
124255282Smckusick 	error = vn_stat(nd.ni_vp, &sb, p);
124352330Smckusick 	vput(nd.ni_vp);
124441486Smckusick 	if (error == 0)
124541486Smckusick 		error = bsdtohpuxstat(&sb, hsb);
124641486Smckusick 	return (error);
124741486Smckusick }
124841486Smckusick 
124941486Smckusick #include "grf.h"
125053922Shibler #if NGRF > 0
125153922Shibler #ifdef __STDC__
125253922Shibler extern int grfopen(dev_t dev, int oflags, int devtype, struct proc *p);
125353922Shibler #else
125453922Shibler extern int grfopen();
125553922Shibler #endif
125653922Shibler #endif
125741486Smckusick 
125853922Shibler #define	NHIL	1	/* XXX */
125953922Shibler #if NHIL > 0
126053922Shibler #ifdef __STDC__
126153922Shibler extern int hilopen(dev_t dev, int oflags, int devtype, struct proc *p);
126253922Shibler #else
126353922Shibler extern int hilopen();
126453922Shibler #endif
126553922Shibler #endif
126653922Shibler 
126756506Sbostic #include <sys/conf.h>
126853922Shibler 
126941486Smckusick bsdtohpuxstat(sb, hsb)
127041486Smckusick 	struct stat *sb;
127141486Smckusick 	struct hpuxstat *hsb;
127241486Smckusick {
127341486Smckusick 	struct hpuxstat ds;
127441486Smckusick 
127541486Smckusick 	bzero((caddr_t)&ds, sizeof(ds));
127653481Smckusick 	ds.hst_dev = (u_short)sb->st_dev;
127741486Smckusick 	ds.hst_ino = (u_long)sb->st_ino;
127841486Smckusick 	ds.hst_mode = sb->st_mode;
127941486Smckusick 	ds.hst_nlink = sb->st_nlink;
128041486Smckusick 	ds.hst_uid = (u_short)sb->st_uid;
128141486Smckusick 	ds.hst_gid = (u_short)sb->st_gid;
128257307Shibler 	ds.hst_rdev = bsdtohpuxdev(sb->st_rdev);
128357307Shibler 
128453922Shibler 	/* XXX: I don't want to talk about it... */
128553922Shibler 	if ((sb->st_mode & S_IFMT) == S_IFCHR) {
128641486Smckusick #if NGRF > 0
128753922Shibler 		if (cdevsw[major(sb->st_rdev)].d_open == grfopen)
128853922Shibler 			ds.hst_rdev = grfdevno(sb->st_rdev);
128941486Smckusick #endif
129053922Shibler #if NHIL > 0
129153922Shibler 		if (cdevsw[major(sb->st_rdev)].d_open == hilopen)
129253922Shibler 			ds.hst_rdev = hildevno(sb->st_rdev);
129353922Shibler #endif
129453922Shibler 		;
129557307Shibler 	}
129653481Smckusick 	if (sb->st_size < (quad_t)1 << 32)
129753481Smckusick 		ds.hst_size = (long)sb->st_size;
129853481Smckusick 	else
129953481Smckusick 		ds.hst_size = -2;
130041486Smckusick 	ds.hst_atime = sb->st_atime;
130141486Smckusick 	ds.hst_mtime = sb->st_mtime;
130241486Smckusick 	ds.hst_ctime = sb->st_ctime;
130341486Smckusick 	ds.hst_blksize = sb->st_blksize;
130441486Smckusick 	ds.hst_blocks = sb->st_blocks;
130541486Smckusick 	return(copyout((caddr_t)&ds, (caddr_t)hsb, sizeof(ds)));
130641486Smckusick }
130741486Smckusick 
hpuxtobsdioctl(com)130841486Smckusick hpuxtobsdioctl(com)
130941486Smckusick 	int com;
131041486Smckusick {
131141486Smckusick 	switch (com) {
131241486Smckusick 	case HPUXTIOCSLTC:
131341486Smckusick 		com = TIOCSLTC; break;
131441486Smckusick 	case HPUXTIOCGLTC:
131541486Smckusick 		com = TIOCGLTC; break;
131641486Smckusick 	case HPUXTIOCSPGRP:
131741486Smckusick 		com = TIOCSPGRP; break;
131841486Smckusick 	case HPUXTIOCGPGRP:
131941486Smckusick 		com = TIOCGPGRP; break;
132041486Smckusick 	case HPUXTIOCLBIS:
132141486Smckusick 		com = TIOCLBIS; break;
132241486Smckusick 	case HPUXTIOCLBIC:
132341486Smckusick 		com = TIOCLBIC; break;
132441486Smckusick 	case HPUXTIOCLSET:
132541486Smckusick 		com = TIOCLSET; break;
132641486Smckusick 	case HPUXTIOCLGET:
132741486Smckusick 		com = TIOCLGET; break;
132864478Shibler 	case HPUXTIOCGWINSZ:
132964478Shibler 		com = TIOCGWINSZ; break;
133064478Shibler 	case HPUXTIOCSWINSZ:
133164478Shibler 		com = TIOCSWINSZ; break;
133241486Smckusick 	}
133341486Smckusick 	return(com);
133441486Smckusick }
133541486Smckusick 
133641486Smckusick /*
133754857Shibler  * HP-UX ioctl system call.  The differences here are:
133841486Smckusick  *	IOC_IN also means IOC_VOID if the size portion is zero.
133949329Shibler  *	no FIOCLEX/FIONCLEX/FIOASYNC/FIOGETOWN/FIOSETOWN
134041486Smckusick  *	the sgttyb struct is 2 bytes longer
134141486Smckusick  */
134254917Storek struct hpuxioctl_args {
134354917Storek 	int	fdes;
134454917Storek 	int	cmd;
134554917Storek 	caddr_t	cmarg;
134654917Storek };
134743452Shibler hpuxioctl(p, uap, retval)
134843452Shibler 	struct proc *p;
134954917Storek 	register struct hpuxioctl_args *uap;
135043452Shibler 	int *retval;
135143452Shibler {
135245923Smckusick 	register struct filedesc *fdp = p->p_fd;
135343452Shibler 	register struct file *fp;
135443452Shibler 	register int com, error;
135541486Smckusick 	register u_int size;
135641486Smckusick 	caddr_t memp = 0;
135741486Smckusick #define STK_PARAMS	128
135841486Smckusick 	char stkbuf[STK_PARAMS];
135941486Smckusick 	caddr_t data = stkbuf;
136041486Smckusick 
136141486Smckusick 	com = uap->cmd;
136241486Smckusick 
136341486Smckusick 	/* XXX */
136443452Shibler 	if (com == HPUXTIOCGETP || com == HPUXTIOCSETP)
136545923Smckusick 		return (getsettty(p, uap->fdes, com, uap->cmarg));
136641486Smckusick 
136748478Skarels 	if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
136848478Skarels 	    (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
136944421Skarels 		return (EBADF);
137043452Shibler 	if ((fp->f_flag & (FREAD|FWRITE)) == 0)
137144421Skarels 		return (EBADF);
137241486Smckusick 
137341486Smckusick 	/*
137441486Smckusick 	 * Interpret high order word to find
137541486Smckusick 	 * amount of data to be copied to/from the
137641486Smckusick 	 * user's address space.
137741486Smckusick 	 */
137841486Smckusick 	size = IOCPARM_LEN(com);
137943452Shibler 	if (size > IOCPARM_MAX)
138044421Skarels 		return (ENOTTY);
138141486Smckusick 	if (size > sizeof (stkbuf)) {
138243452Shibler 		memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
138341486Smckusick 		data = memp;
138441486Smckusick 	}
138541486Smckusick 	if (com&IOC_IN) {
138641486Smckusick 		if (size) {
138743452Shibler 			error = copyin(uap->cmarg, data, (u_int)size);
138843452Shibler 			if (error) {
138941486Smckusick 				if (memp)
139041486Smckusick 					free(memp, M_IOCTLOPS);
139144421Skarels 				return (error);
139241486Smckusick 			}
139341486Smckusick 		} else
139441486Smckusick 			*(caddr_t *)data = uap->cmarg;
139541486Smckusick 	} else if ((com&IOC_OUT) && size)
139641486Smckusick 		/*
139743452Shibler 		 * Zero the buffer so the user always
139843452Shibler 		 * gets back something deterministic.
139941486Smckusick 		 */
140041486Smckusick 		bzero(data, size);
140141486Smckusick 	else if (com&IOC_VOID)
140241486Smckusick 		*(caddr_t *)data = uap->cmarg;
140341486Smckusick 
140441486Smckusick 	switch (com) {
140541486Smckusick 
140649329Shibler 	case HPUXFIOSNBIO:
140749329Shibler 	{
140849329Shibler 		char *ofp = &fdp->fd_ofileflags[uap->fdes];
140949329Shibler 		int tmp;
141049329Shibler 
141149329Shibler 		if (*(int *)data)
141249329Shibler 			*ofp |= UF_FIONBIO_ON;
141349329Shibler 		else
141449329Shibler 			*ofp &= ~UF_FIONBIO_ON;
141549329Shibler 		/*
141663726Shibler 		 * Only set/clear if O_NONBLOCK/FNDELAY not in effect
141749329Shibler 		 */
141863726Shibler 		if ((*ofp & (UF_NONBLOCK_ON|UF_FNDELAY_ON)) == 0) {
141963726Shibler 			tmp = *ofp & UF_FIONBIO_ON;
142049329Shibler 			error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO,
142149329Shibler 						       (caddr_t)&tmp, p);
142249329Shibler 		}
142349329Shibler 		break;
142449329Shibler 	}
142549329Shibler 
142641486Smckusick 	case HPUXTIOCCONS:
142741486Smckusick 		*(int *)data = 1;
142848478Skarels 		error = (*fp->f_ops->fo_ioctl)(fp, TIOCCONS, data, p);
142941486Smckusick 		break;
143041486Smckusick 
143141486Smckusick 	/* BSD-style job control ioctls */
143241486Smckusick 	case HPUXTIOCLBIS:
143341486Smckusick 	case HPUXTIOCLBIC:
143441486Smckusick 	case HPUXTIOCLSET:
143541486Smckusick 		*(int *)data &= HPUXLTOSTOP;
143641486Smckusick 		if (*(int *)data & HPUXLTOSTOP)
143741486Smckusick 			*(int *)data = LTOSTOP;
143841486Smckusick 		/* fall into */
143964478Shibler 
144064478Shibler 	/* simple mapping cases */
144141486Smckusick 	case HPUXTIOCLGET:
144241486Smckusick 	case HPUXTIOCSLTC:
144341486Smckusick 	case HPUXTIOCGLTC:
144441486Smckusick 	case HPUXTIOCSPGRP:
144541486Smckusick 	case HPUXTIOCGPGRP:
144664478Shibler 	case HPUXTIOCGWINSZ:
144764478Shibler 	case HPUXTIOCSWINSZ:
144848478Skarels 		error = (*fp->f_ops->fo_ioctl)
144948478Skarels 			(fp, hpuxtobsdioctl(com), data, p);
145043452Shibler 		if (error == 0 && com == HPUXTIOCLGET) {
145141486Smckusick 			*(int *)data &= LTOSTOP;
145241486Smckusick 			if (*(int *)data & LTOSTOP)
145341486Smckusick 				*(int *)data = HPUXLTOSTOP;
145441486Smckusick 		}
145541486Smckusick 		break;
145641486Smckusick 
145755832Shibler 	/* SYS 5 termio and POSIX termios */
145841486Smckusick 	case HPUXTCGETA:
145941486Smckusick 	case HPUXTCSETA:
146041486Smckusick 	case HPUXTCSETAW:
146141486Smckusick 	case HPUXTCSETAF:
146255832Shibler 	case HPUXTCGETATTR:
146355832Shibler 	case HPUXTCSETATTR:
146455832Shibler 	case HPUXTCSETATTRD:
146555832Shibler 	case HPUXTCSETATTRF:
146664478Shibler 		error = hpuxtermio(uap->fdes, com, data, p);
146741486Smckusick 		break;
146841486Smckusick 
146941486Smckusick 	default:
147048478Skarels 		error = (*fp->f_ops->fo_ioctl)(fp, com, data, p);
147141486Smckusick 		break;
147241486Smckusick 	}
147341486Smckusick 	/*
147441486Smckusick 	 * Copy any data to user, size was
147541486Smckusick 	 * already set and checked above.
147641486Smckusick 	 */
147743452Shibler 	if (error == 0 && (com&IOC_OUT) && size)
147843452Shibler 		error = copyout(data, uap->cmarg, (u_int)size);
147941486Smckusick 	if (memp)
148041486Smckusick 		free(memp, M_IOCTLOPS);
148144421Skarels 	return (error);
148241486Smckusick }
148341486Smckusick 
148441486Smckusick /*
148541486Smckusick  * Man page lies, behaviour here is based on observed behaviour.
148641486Smckusick  */
148754917Storek struct hpuxgetcontext_args {
148854917Storek 	char *buf;
148954917Storek 	int len;
149054917Storek };
149143452Shibler hpuxgetcontext(p, uap, retval)
149243452Shibler 	struct proc *p;
149354917Storek 	struct hpuxgetcontext_args *uap;
149443452Shibler 	int *retval;
149543452Shibler {
149641486Smckusick 	int error = 0;
149741486Smckusick 	register int len;
149841486Smckusick 
149953922Shibler #if defined(HP380)
150053922Shibler 	if (machineid == HP_380) {
150155072Spendry 		len = min(uap->len, sizeof(hpux040context));
150253922Shibler 		if (len)
150353922Shibler 			error = copyout(hpux040context, uap->buf, len);
150453922Shibler 		if (error == 0)
150553922Shibler 			*retval = sizeof(hpux040context);
150653922Shibler 		return (error);
150753922Shibler 	}
150853922Shibler #endif
150955072Spendry 	len = min(uap->len, sizeof(hpuxcontext));
151041486Smckusick 	if (len)
151141486Smckusick 		error = copyout(hpuxcontext, uap->buf, (u_int)len);
151243452Shibler 	if (error == 0)
151343452Shibler 		*retval = sizeof(hpuxcontext);
151444421Skarels 	return (error);
151541486Smckusick }
151641486Smckusick 
151741486Smckusick /*
151841486Smckusick  * This is the equivalent of BSD getpgrp but with more restrictions.
151941486Smckusick  * Note we do not check the real uid or "saved" uid.
152041486Smckusick  */
152154917Storek struct hpuxgetpgrp2_args {
152254917Storek 	int pid;
152354917Storek };
152443452Shibler hpuxgetpgrp2(cp, uap, retval)
152543452Shibler 	struct proc *cp;
152654917Storek 	register struct hpuxgetpgrp2_args *uap;
152743452Shibler 	int *retval;
152841486Smckusick {
152941486Smckusick 	register struct proc *p;
153041486Smckusick 
153141486Smckusick 	if (uap->pid == 0)
153243452Shibler 		uap->pid = cp->p_pid;
153341486Smckusick 	p = pfind(uap->pid);
153443452Shibler 	if (p == 0)
153544421Skarels 		return (ESRCH);
153648478Skarels 	if (cp->p_ucred->cr_uid && p->p_ucred->cr_uid != cp->p_ucred->cr_uid &&
153748478Skarels 	    !inferior(p))
153844421Skarels 		return (EPERM);
153943452Shibler 	*retval = p->p_pgid;
154044421Skarels 	return (0);
154141486Smckusick }
154241486Smckusick 
154341486Smckusick /*
154441486Smckusick  * This is the equivalent of BSD setpgrp but with more restrictions.
154541486Smckusick  * Note we do not check the real uid or "saved" uid or pgrp.
154641486Smckusick  */
154754917Storek struct hpuxsetpgrp2_args {
154854917Storek 	int	pid;
154954917Storek 	int	pgrp;
155054917Storek };
155143452Shibler hpuxsetpgrp2(p, uap, retval)
155243452Shibler 	struct proc *p;
155354917Storek 	struct hpuxsetpgrp2_args *uap;
155443452Shibler 	int *retval;
155543452Shibler {
155641486Smckusick 	/* empirically determined */
155743452Shibler 	if (uap->pgrp < 0 || uap->pgrp >= 30000)
155844421Skarels 		return (EINVAL);
155948478Skarels 	return (setpgid(p, uap, retval));
156041486Smckusick }
156141486Smckusick 
156241486Smckusick /*
156355165Smckusick  * XXX Same as BSD setre[ug]id right now.  Need to consider saved ids.
156445753Smckusick  */
156554917Storek struct hpuxsetresuid_args {
156654917Storek 	int	ruid;
156754917Storek 	int	euid;
156854917Storek 	int	suid;
156954917Storek };
157045753Smckusick hpuxsetresuid(p, uap, retval)
157155165Smckusick 	struct proc *p;
157254917Storek 	struct hpuxsetresuid_args *uap;
157345753Smckusick 	int *retval;
157445753Smckusick {
1575*68373Scgd 	return (compat_43_setreuid(p, uap, retval));
157645753Smckusick }
157745753Smckusick 
157854917Storek struct hpuxsetresgid_args {
157954917Storek 	int	rgid;
158054917Storek 	int	egid;
158154917Storek 	int	sgid;
158254917Storek };
158345753Smckusick hpuxsetresgid(p, uap, retval)
158455165Smckusick 	struct proc *p;
158554917Storek 	struct hpuxsetresgid_args *uap;
158645753Smckusick 	int *retval;
158745753Smckusick {
1588*68373Scgd 	return (compat_43_setregid(p, uap, retval));
158945753Smckusick }
159045753Smckusick 
159157307Shibler struct hpuxrlimit_args {
159257307Shibler 	u_int	which;
159357307Shibler 	struct	orlimit *rlp;
159457307Shibler };
159557307Shibler hpuxgetrlimit(p, uap, retval)
159657307Shibler 	struct proc *p;
159757307Shibler 	struct hpuxrlimit_args *uap;
159857307Shibler 	int *retval;
159957307Shibler {
160057307Shibler 	if (uap->which > HPUXRLIMIT_NOFILE)
160157307Shibler 		return (EINVAL);
160257307Shibler 	if (uap->which == HPUXRLIMIT_NOFILE)
160357307Shibler 		uap->which = RLIMIT_NOFILE;
1604*68373Scgd 	return (compat_43_getrlimit(p, uap, retval));
160557307Shibler }
160657307Shibler 
160757307Shibler hpuxsetrlimit(p, uap, retval)
160857307Shibler 	struct proc *p;
160957307Shibler 	struct hpuxrlimit_args *uap;
161057307Shibler 	int *retval;
161157307Shibler {
161257307Shibler 	if (uap->which > HPUXRLIMIT_NOFILE)
161357307Shibler 		return (EINVAL);
161457307Shibler 	if (uap->which == HPUXRLIMIT_NOFILE)
161557307Shibler 		uap->which = RLIMIT_NOFILE;
1616*68373Scgd 	return (compat_43_setrlimit(p, uap, retval));
161757307Shibler }
161857307Shibler 
161945753Smckusick /*
162045753Smckusick  * XXX: simple recognition hack to see if we can make grmd work.
162145753Smckusick  */
162254917Storek struct hpuxlockf_args {
162354917Storek 	int fd;
162454917Storek 	int func;
162554917Storek 	long size;
162654917Storek };
162745753Smckusick hpuxlockf(p, uap, retval)
162845753Smckusick 	struct proc *p;
162954917Storek 	struct hpuxlockf_args *uap;
163045753Smckusick 	int *retval;
163145753Smckusick {
163245753Smckusick 	return (0);
163345753Smckusick }
163445753Smckusick 
163554917Storek struct hpuxgetaccess_args {
163654917Storek 	char	*path;
163754917Storek 	int	uid;
163854917Storek 	int	ngroups;
163954917Storek 	int	*gidset;
164054917Storek 	void	*label;
164154917Storek 	void	*privs;
164254917Storek };
hpuxgetaccess(p,uap,retval)164345753Smckusick hpuxgetaccess(p, uap, retval)
164445753Smckusick 	register struct proc *p;
164554917Storek 	register struct hpuxgetaccess_args *uap;
164645753Smckusick 	int *retval;
164745753Smckusick {
164845753Smckusick 	int lgroups[NGROUPS];
164945753Smckusick 	int error = 0;
165045753Smckusick 	register struct ucred *cred;
165145753Smckusick 	register struct vnode *vp;
165252330Smckusick 	struct nameidata nd;
165345753Smckusick 
165445753Smckusick 	/*
165545753Smckusick 	 * Build an appropriate credential structure
165645753Smckusick 	 */
165748478Skarels 	cred = crdup(p->p_ucred);
165845753Smckusick 	switch (uap->uid) {
165945753Smckusick 	case 65502:	/* UID_EUID */
166045753Smckusick 		break;
166145753Smckusick 	case 65503:	/* UID_RUID */
166248478Skarels 		cred->cr_uid = p->p_cred->p_ruid;
166345753Smckusick 		break;
166445753Smckusick 	case 65504:	/* UID_SUID */
166545753Smckusick 		error = EINVAL;
166645753Smckusick 		break;
166745753Smckusick 	default:
166845753Smckusick 		if (uap->uid > 65504)
166945753Smckusick 			error = EINVAL;
167045753Smckusick 		cred->cr_uid = uap->uid;
167145753Smckusick 		break;
167245753Smckusick 	}
167345753Smckusick 	switch (uap->ngroups) {
167445753Smckusick 	case -1:	/* NGROUPS_EGID */
167545753Smckusick 		cred->cr_ngroups = 1;
167645753Smckusick 		break;
167745753Smckusick 	case -5:	/* NGROUPS_EGID_SUPP */
167845753Smckusick 		break;
167945753Smckusick 	case -2:	/* NGROUPS_RGID */
168045753Smckusick 		cred->cr_ngroups = 1;
168148478Skarels 		cred->cr_gid = p->p_cred->p_rgid;
168245753Smckusick 		break;
168345753Smckusick 	case -6:	/* NGROUPS_RGID_SUPP */
168448478Skarels 		cred->cr_gid = p->p_cred->p_rgid;
168545753Smckusick 		break;
168645753Smckusick 	case -3:	/* NGROUPS_SGID */
168745753Smckusick 	case -7:	/* NGROUPS_SGID_SUPP */
168845753Smckusick 		error = EINVAL;
168945753Smckusick 		break;
169045753Smckusick 	case -4:	/* NGROUPS_SUPP */
169145753Smckusick 		if (cred->cr_ngroups > 1)
169245753Smckusick 			cred->cr_gid = cred->cr_groups[1];
169345753Smckusick 		else
169445753Smckusick 			error = EINVAL;
169545753Smckusick 		break;
169645753Smckusick 	default:
169745753Smckusick 		if (uap->ngroups > 0 && uap->ngroups <= NGROUPS)
169845753Smckusick 			error = copyin((caddr_t)uap->gidset,
169945753Smckusick 				       (caddr_t)&lgroups[0],
170045753Smckusick 				       uap->ngroups * sizeof(lgroups[0]));
170145753Smckusick 		else
170245753Smckusick 			error = EINVAL;
170345753Smckusick 		if (error == 0) {
170445753Smckusick 			int gid;
170545753Smckusick 
170645753Smckusick 			for (gid = 0; gid < uap->ngroups; gid++)
170745753Smckusick 				cred->cr_groups[gid] = lgroups[gid];
170845753Smckusick 			cred->cr_ngroups = uap->ngroups;
170945753Smckusick 		}
171045753Smckusick 		break;
171145753Smckusick 	}
171245753Smckusick 	/*
171345753Smckusick 	 * Lookup file using caller's effective IDs.
171445753Smckusick 	 */
171545753Smckusick 	if (error == 0) {
171652330Smckusick 		NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
171752330Smckusick 			uap->path, p);
171852330Smckusick 		error = namei(&nd);
171945753Smckusick 	}
172045753Smckusick 	if (error) {
172145753Smckusick 		crfree(cred);
172245753Smckusick 		return (error);
172345753Smckusick 	}
172445753Smckusick 	/*
172545753Smckusick 	 * Use the constructed credentials for access checks.
172645753Smckusick 	 */
172752330Smckusick 	vp = nd.ni_vp;
172845753Smckusick 	*retval = 0;
172948478Skarels 	if (VOP_ACCESS(vp, VREAD, cred, p) == 0)
173045753Smckusick 		*retval |= R_OK;
173148478Skarels 	if (vn_writechk(vp) == 0 && VOP_ACCESS(vp, VWRITE, cred, p) == 0)
173245753Smckusick 		*retval |= W_OK;
173345753Smckusick 	/* XXX we return X_OK for root on VREG even if not */
173448478Skarels 	if (VOP_ACCESS(vp, VEXEC, cred, p) == 0)
173545753Smckusick 		*retval |= X_OK;
173645753Smckusick 	vput(vp);
173745753Smckusick 	crfree(cred);
173845753Smckusick 	return (error);
173945753Smckusick }
174045753Smckusick 
174149134Skarels extern char kstack[];
174241486Smckusick #define UOFF(f)		((int)&((struct user *)0)->f)
174341486Smckusick #define HPUOFF(f)	((int)&((struct hpuxuser *)0)->f)
174441486Smckusick 
174541486Smckusick /* simplified FP structure */
174641486Smckusick struct bsdfp {
174741486Smckusick 	int save[54];
174841486Smckusick 	int reg[24];
174941486Smckusick 	int ctrl[3];
175041486Smckusick };
175141486Smckusick 
175257307Shibler /*
175357307Shibler  * Brutal hack!  Map HP-UX u-area offsets into BSD k-stack offsets.
175457307Shibler  */
hpuxtobsduoff(off,isps,p)175557307Shibler hpuxtobsduoff(off, isps, p)
175657307Shibler 	int *off, *isps;
175757307Shibler 	struct proc *p;
175841486Smckusick {
175957307Shibler 	register int *ar0 = p->p_md.md_regs;
176041486Smckusick 	struct hpuxfp *hp;
176141486Smckusick 	struct bsdfp *bp;
176241486Smckusick 	register u_int raddr;
176341486Smckusick 
176457307Shibler 	*isps = 0;
176557307Shibler 
176648478Skarels 	/* u_ar0 field; procxmt puts in U_ar0 */
176741486Smckusick 	if ((int)off == HPUOFF(hpuxu_ar0))
176848478Skarels 		return(UOFF(U_ar0));
176941486Smckusick 
177041486Smckusick #ifdef FPCOPROC
177157307Shibler 	/* FP registers from PCB */
177241486Smckusick 	hp = (struct hpuxfp *)HPUOFF(hpuxu_fp);
177341486Smckusick 	bp = (struct bsdfp *)UOFF(u_pcb.pcb_fpregs);
177441486Smckusick 	if (off >= hp->hpfp_ctrl && off < &hp->hpfp_ctrl[3])
177541486Smckusick 		return((int)&bp->ctrl[off - hp->hpfp_ctrl]);
177641486Smckusick 	if (off >= hp->hpfp_reg && off < &hp->hpfp_reg[24])
177741486Smckusick 		return((int)&bp->reg[off - hp->hpfp_reg]);
177841486Smckusick #endif
177941486Smckusick 
178041486Smckusick 	/*
178141486Smckusick 	 * Everything else we recognize comes from the kernel stack,
178241486Smckusick 	 * so we convert off to an absolute address (if not already)
178341486Smckusick 	 * for simplicity.
178441486Smckusick 	 */
178541486Smckusick 	if (off < (int *)ctob(UPAGES))
178649134Skarels 		off = (int *)((u_int)off + (u_int)kstack);
178741486Smckusick 
178841486Smckusick 	/*
178957307Shibler 	 * General registers.
179054857Shibler 	 * We know that the HP-UX registers are in the same order as ours.
179141486Smckusick 	 * The only difference is that their PS is 2 bytes instead of a
179241486Smckusick 	 * padded 4 like ours throwing the alignment off.
179341486Smckusick 	 */
179448478Skarels 	if (off >= ar0 && off < &ar0[18]) {
179541486Smckusick 		/*
179641486Smckusick 		 * PS: return low word and high word of PC as HP-UX would
179741486Smckusick 		 * (e.g. &u.u_ar0[16.5]).
179857307Shibler 		 *
179957307Shibler 		 * XXX we don't do this since HP-UX adb doesn't rely on
180057307Shibler 		 * it and passing such an offset to procxmt will cause
180157307Shibler 		 * it to fail anyway.  Instead, we just set the offset
180257307Shibler 		 * to PS and let hpuxptrace() shift up the value returned.
180341486Smckusick 		 */
180457307Shibler 		if (off == &ar0[PS]) {
180557307Shibler #if 0
180648478Skarels 			raddr = (u_int) &((short *)ar0)[PS*2+1];
180757307Shibler #else
180857307Shibler 			raddr = (u_int) &ar0[(int)(off - ar0)];
180957307Shibler #endif
181057307Shibler 			*isps = 1;
181157307Shibler 		}
181241486Smckusick 		/*
181357307Shibler 		 * PC: off will be &u.u_ar0[16.5] since HP-UX saved PS
181457307Shibler 		 * is only 16 bits.
181541486Smckusick 		 */
181648478Skarels 		else if (off == (int *)&(((short *)ar0)[PS*2+1]))
181748478Skarels 			raddr = (u_int) &ar0[PC];
181841486Smckusick 		/*
181941486Smckusick 		 * D0-D7, A0-A7: easy
182041486Smckusick 		 */
182141486Smckusick 		else
182248478Skarels 			raddr = (u_int) &ar0[(int)(off - ar0)];
182349134Skarels 		return((int)(raddr - (u_int)kstack));
182441486Smckusick 	}
182541486Smckusick 
182641486Smckusick 	/* everything else */
182741486Smckusick 	return(-1);
182841486Smckusick }
182941486Smckusick 
183041486Smckusick /*
183154857Shibler  * Kludge up a uarea dump so that HP-UX debuggers can find out
183241486Smckusick  * what they need.  IMPORTANT NOTE: we do not EVEN attempt to
183341486Smckusick  * convert the entire user struct.
183441486Smckusick  */
183541486Smckusick hpuxdumpu(vp, cred)
183641486Smckusick 	struct vnode *vp;
183741486Smckusick 	struct ucred *cred;
183841486Smckusick {
183948478Skarels 	struct proc *p = curproc;
184041486Smckusick 	int error;
184141486Smckusick 	struct hpuxuser *faku;
184241486Smckusick 	struct bsdfp *bp;
184341486Smckusick 	short *foop;
184441486Smckusick 
184541486Smckusick 	faku = (struct hpuxuser *)malloc((u_long)ctob(1), M_TEMP, M_WAITOK);
184641486Smckusick 	/*
184741486Smckusick 	 * Make sure there is no mistake about this
184841486Smckusick 	 * being a real user structure.
184941486Smckusick 	 */
185041486Smckusick 	bzero((caddr_t)faku, ctob(1));
185141486Smckusick 	/*
185241486Smckusick 	 * Fill in the process sizes.
185341486Smckusick 	 */
185448478Skarels 	faku->hpuxu_tsize = p->p_vmspace->vm_tsize;
185548478Skarels 	faku->hpuxu_dsize = p->p_vmspace->vm_dsize;
185648478Skarels 	faku->hpuxu_ssize = p->p_vmspace->vm_ssize;
185741486Smckusick 	/*
185841486Smckusick 	 * Fill in the exec header for CDB.
185941486Smckusick 	 * This was saved back in exec().  As far as I can tell CDB
186041486Smckusick 	 * only uses this information to verify that a particular
186141486Smckusick 	 * core file goes with a particular binary.
186241486Smckusick 	 */
186357307Shibler 	bcopy((caddr_t)p->p_addr->u_md.md_exec,
186441486Smckusick 	      (caddr_t)&faku->hpuxu_exdata, sizeof (struct hpux_exec));
186541486Smckusick 	/*
186641486Smckusick 	 * Adjust user's saved registers (on kernel stack) to reflect
186754857Shibler 	 * HP-UX order.  Note that HP-UX saves the SR as 2 bytes not 4
186841486Smckusick 	 * so we have to move it up.
186941486Smckusick 	 */
187052381Smckusick 	faku->hpuxu_ar0 = p->p_md.md_regs;
187152381Smckusick 	foop = (short *) p->p_md.md_regs;
187241486Smckusick 	foop[32] = foop[33];
187341486Smckusick 	foop[33] = foop[34];
187441486Smckusick 	foop[34] = foop[35];
187541486Smckusick #ifdef FPCOPROC
187641486Smckusick 	/*
187754857Shibler 	 * Copy 68881 registers from our PCB format to HP-UX format
187841486Smckusick 	 */
187949134Skarels 	bp = (struct bsdfp *) &p->p_addr->u_pcb.pcb_fpregs;
188041486Smckusick 	bcopy((caddr_t)bp->save, (caddr_t)faku->hpuxu_fp.hpfp_save,
188141486Smckusick 	      sizeof(bp->save));
188241486Smckusick 	bcopy((caddr_t)bp->ctrl, (caddr_t)faku->hpuxu_fp.hpfp_ctrl,
188341486Smckusick 	      sizeof(bp->ctrl));
188441486Smckusick 	bcopy((caddr_t)bp->reg, (caddr_t)faku->hpuxu_fp.hpfp_reg,
188541486Smckusick 	      sizeof(bp->reg));
188641486Smckusick #endif
188741486Smckusick 	/*
188841486Smckusick 	 * Slay the dragon
188941486Smckusick 	 */
189041486Smckusick 	faku->hpuxu_dragon = -1;
189141486Smckusick 	/*
189241486Smckusick 	 * Dump this artfully constructed page in place of the
189341486Smckusick 	 * user struct page.
189441486Smckusick 	 */
189548478Skarels 	error = vn_rdwr(UIO_WRITE, vp, (caddr_t)faku, ctob(1), (off_t)0,
189648478Skarels 			UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred,
189749134Skarels 			(int *)NULL, p);
189841486Smckusick 	/*
189941486Smckusick 	 * Dump the remaining UPAGES-1 pages normally
190041486Smckusick 	 */
190141486Smckusick 	if (!error)
190249134Skarels 		error = vn_rdwr(UIO_WRITE, vp, kstack + ctob(1),
190341486Smckusick 				ctob(UPAGES-1), (off_t)ctob(1), UIO_SYSSPACE,
190449134Skarels 				IO_NODELOCKED|IO_UNIT, cred, (int *)NULL, p);
190541486Smckusick 	free((caddr_t)faku, M_TEMP);
190641486Smckusick 	return(error);
190741486Smckusick }
190841486Smckusick 
190941486Smckusick /*
191041486Smckusick  * The remaining routines are essentially the same as those in kern_xxx.c
191141486Smckusick  * and vfs_xxx.c as defined under "#ifdef COMPAT".  We replicate them here
191241486Smckusick  * to avoid HPUXCOMPAT dependencies in those files and to make sure that
191341486Smckusick  * HP-UX compatibility still works even when COMPAT is not defined.
191457307Shibler  *
191557307Shibler  * These are still needed as of HP-UX 7.05.
191641486Smckusick  */
191755832Shibler #ifdef COMPAT_OHPUX
191855832Shibler 
191945753Smckusick #define HPUX_HZ	50
192045753Smckusick 
192157307Shibler #include "sys/times.h"
192241486Smckusick 
192341486Smckusick /* from old timeb.h */
192441486Smckusick struct hpuxtimeb {
192541486Smckusick 	time_t	time;
192641486Smckusick 	u_short	millitm;
192741486Smckusick 	short	timezone;
192841486Smckusick 	short	dstflag;
192941486Smckusick };
193041486Smckusick 
193141486Smckusick /* ye ole stat structure */
193241486Smckusick struct	ohpuxstat {
193353481Smckusick 	u_short	ohst_dev;
193441486Smckusick 	u_short	ohst_ino;
193541486Smckusick 	u_short ohst_mode;
193641486Smckusick 	short  	ohst_nlink;
193741486Smckusick 	short  	ohst_uid;
193841486Smckusick 	short  	ohst_gid;
193953481Smckusick 	u_short	ohst_rdev;
194041486Smckusick 	int	ohst_size;
194141486Smckusick 	int	ohst_atime;
194241486Smckusick 	int	ohst_mtime;
194341486Smckusick 	int	ohst_ctime;
194441486Smckusick };
194541486Smckusick 
194641486Smckusick /*
194741486Smckusick  * SYS V style setpgrp()
194841486Smckusick  */
compat_43_hpuxsetpgrp(p,uap,retval)1949*68373Scgd compat_43_hpuxsetpgrp(p, uap, retval)
195043452Shibler 	register struct proc *p;
195143452Shibler 	int *uap, *retval;
195241486Smckusick {
195341486Smckusick 	if (p->p_pid != p->p_pgid)
195448478Skarels 		enterpgrp(p, p->p_pid, 0);
195543452Shibler 	*retval = p->p_pgid;
195645753Smckusick 	return (0);
195741486Smckusick }
195841486Smckusick 
195954917Storek struct ohpuxtime_args {
196054917Storek 	long	*tp;
196154917Storek };
1962*68373Scgd compat_43_hpuxtime(p, uap, retval)
196343452Shibler 	struct proc *p;
196454917Storek 	register struct ohpuxtime_args *uap;
196554917Storek 	int *retval;
196641486Smckusick {
196745753Smckusick 	int error = 0;
196841486Smckusick 
196941486Smckusick 	if (uap->tp)
197043452Shibler 		error = copyout((caddr_t)&time.tv_sec, (caddr_t)uap->tp,
197143452Shibler 				sizeof (long));
197254917Storek 	*(time_t *)retval = time.tv_sec;
197344421Skarels 	return (error);
197441486Smckusick }
197541486Smckusick 
197654917Storek struct ohpuxstime_args {
197754917Storek 	int	time;
197854917Storek };
1979*68373Scgd compat_43_hpuxstime(p, uap, retval)
198043452Shibler 	struct proc *p;
198154917Storek 	register struct ohpuxstime_args *uap;
198243452Shibler 	int *retval;
198341486Smckusick {
198441486Smckusick 	struct timeval tv;
198543452Shibler 	int s, error;
198641486Smckusick 
198741486Smckusick 	tv.tv_sec = uap->time;
198841486Smckusick 	tv.tv_usec = 0;
198948478Skarels 	if (error = suser(p->p_ucred, &p->p_acflag))
199044421Skarels 		return (error);
199141486Smckusick 
199241486Smckusick 	/* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
199341486Smckusick 	boottime.tv_sec += tv.tv_sec - time.tv_sec;
199441486Smckusick 	s = splhigh(); time = tv; splx(s);
199541486Smckusick 	resettodr();
199644421Skarels 	return (0);
199741486Smckusick }
199841486Smckusick 
199954917Storek struct ohpuxftime_args {
200054917Storek 	struct	hpuxtimeb *tp;
200154917Storek };
2002*68373Scgd compat_43_hpuxftime(p, uap, retval)
200343452Shibler 	struct proc *p;
200454917Storek 	register struct ohpuxftime_args *uap;
200543452Shibler 	int *retval;
200643452Shibler {
200741486Smckusick 	struct hpuxtimeb tb;
200841486Smckusick 	int s;
200941486Smckusick 
201041486Smckusick 	s = splhigh();
201141486Smckusick 	tb.time = time.tv_sec;
201241486Smckusick 	tb.millitm = time.tv_usec / 1000;
201341486Smckusick 	splx(s);
201441486Smckusick 	tb.timezone = tz.tz_minuteswest;
201541486Smckusick 	tb.dstflag = tz.tz_dsttime;
201644421Skarels 	return (copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb)));
201741486Smckusick }
201841486Smckusick 
201954917Storek struct ohpuxalarm_args {
202054917Storek 	int	deltat;
202154917Storek };
compat_43_hpuxalarm(p,uap,retval)2022*68373Scgd compat_43_hpuxalarm(p, uap, retval)
202343452Shibler 	register struct proc *p;
202454917Storek 	register struct ohpuxalarm_args *uap;
202543452Shibler 	int *retval;
202641486Smckusick {
202741486Smckusick 	int s = splhigh();
202841486Smckusick 
202941486Smckusick 	untimeout(realitexpire, (caddr_t)p);
203041486Smckusick 	timerclear(&p->p_realtimer.it_interval);
203143452Shibler 	*retval = 0;
203241486Smckusick 	if (timerisset(&p->p_realtimer.it_value) &&
203341486Smckusick 	    timercmp(&p->p_realtimer.it_value, &time, >))
203443452Shibler 		*retval = p->p_realtimer.it_value.tv_sec - time.tv_sec;
203541486Smckusick 	if (uap->deltat == 0) {
203641486Smckusick 		timerclear(&p->p_realtimer.it_value);
203741486Smckusick 		splx(s);
203844421Skarels 		return (0);
203941486Smckusick 	}
204041486Smckusick 	p->p_realtimer.it_value = time;
204141486Smckusick 	p->p_realtimer.it_value.tv_sec += uap->deltat;
204241486Smckusick 	timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
204341486Smckusick 	splx(s);
204444421Skarels 	return (0);
204541486Smckusick }
204641486Smckusick 
204754917Storek struct ohpuxnice_args {
204854917Storek 	int	niceness;
204954917Storek };
compat_43_hpuxnice(p,uap,retval)2050*68373Scgd compat_43_hpuxnice(p, uap, retval)
205143452Shibler 	register struct proc *p;
205254917Storek 	register struct ohpuxnice_args *uap;
205343452Shibler 	int *retval;
205441486Smckusick {
205543452Shibler 	int error;
205641486Smckusick 
205743452Shibler 	error = donice(p, p, (p->p_nice-NZERO)+uap->niceness);
205843452Shibler 	if (error == 0)
205943452Shibler 		*retval = p->p_nice - NZERO;
206044421Skarels 	return (error);
206141486Smckusick }
206241486Smckusick 
206354917Storek struct ohpuxtimes_args {
206454917Storek 	struct	tms *tmsb;
206554917Storek };
2066*68373Scgd compat_43_hpuxtimes(p, uap, retval)
206743452Shibler 	struct proc *p;
206854917Storek 	register struct ohpuxtimes_args *uap;
206954917Storek 	int *retval;
207041486Smckusick {
207154771Storek 	struct timeval ru, rs;
207241486Smckusick 	struct tms atms;
207343452Shibler 	int error;
207441486Smckusick 
207554771Storek 	calcru(p, &ru, &rs, NULL);
207654771Storek 	atms.tms_utime = hpuxscale(&ru);
207754771Storek 	atms.tms_stime = hpuxscale(&rs);
207848478Skarels 	atms.tms_cutime = hpuxscale(&p->p_stats->p_cru.ru_utime);
207948478Skarels 	atms.tms_cstime = hpuxscale(&p->p_stats->p_cru.ru_stime);
208043452Shibler 	error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
208143452Shibler 	if (error == 0)
208254917Storek 		*(time_t *)retval = hpuxscale(&time) - hpuxscale(&boottime);
208344421Skarels 	return (error);
208441486Smckusick }
208541486Smckusick 
208645753Smckusick /*
208745753Smckusick  * Doesn't exactly do what the documentation says.
208845753Smckusick  * What we really do is return 1/HPUX_HZ-th of a second since that
208945753Smckusick  * is what HP-UX returns.
209045753Smckusick  */
hpuxscale(tvp)209145753Smckusick hpuxscale(tvp)
209241486Smckusick 	register struct timeval *tvp;
209341486Smckusick {
209445753Smckusick 	return (tvp->tv_sec * HPUX_HZ + tvp->tv_usec * HPUX_HZ / 1000000);
209541486Smckusick }
209641486Smckusick 
209741486Smckusick /*
209841486Smckusick  * Set IUPD and IACC times on file.
209941486Smckusick  * Can't set ICHG.
210041486Smckusick  */
210154917Storek struct ohpuxutime_args {
210254917Storek 	char	*fname;
210354917Storek 	time_t	*tptr;
210454917Storek };
2105*68373Scgd compat_43_hpuxutime(p, uap, retval)
210643452Shibler 	struct proc *p;
210754917Storek 	register struct ohpuxutime_args *uap;
210843452Shibler 	int *retval;
210943452Shibler {
211048478Skarels 	register struct vnode *vp;
211141486Smckusick 	struct vattr vattr;
211241486Smckusick 	time_t tv[2];
211343452Shibler 	int error;
211448478Skarels 	struct nameidata nd;
211541486Smckusick 
211641486Smckusick 	if (uap->tptr) {
211743452Shibler 		error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
211843452Shibler 		if (error)
211944421Skarels 			return (error);
212041486Smckusick 	} else
212141486Smckusick 		tv[0] = tv[1] = time.tv_sec;
212241486Smckusick 	vattr_null(&vattr);
212354107Smckusick 	vattr.va_atime.ts_sec = tv[0];
212454107Smckusick 	vattr.va_atime.ts_nsec = 0;
212554107Smckusick 	vattr.va_mtime.ts_sec = tv[1];
212654107Smckusick 	vattr.va_mtime.ts_nsec = 0;
212752330Smckusick 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
212852330Smckusick 	if (error = namei(&nd))
212944421Skarels 		return (error);
213052330Smckusick 	vp = nd.ni_vp;
213142154Smckusick 	if (vp->v_mount->mnt_flag & MNT_RDONLY)
213243452Shibler 		error = EROFS;
213341486Smckusick 	else
213452330Smckusick 		error = VOP_SETATTR(vp, &vattr, nd.ni_cnd.cn_cred, p);
213541486Smckusick 	vput(vp);
213644421Skarels 	return (error);
213741486Smckusick }
213841486Smckusick 
2139*68373Scgd compat_43_hpuxpause(p, uap, retval)
214043452Shibler 	struct proc *p;
214143452Shibler 	int *uap, *retval;
214241486Smckusick {
214349134Skarels 	(void) tsleep(kstack, PPAUSE | PCATCH, "pause", 0);
214442155Skarels 	/* always return EINTR rather than ERESTART... */
214544421Skarels 	return (EINTR);
214641486Smckusick }
214741486Smckusick 
214841486Smckusick /*
214941486Smckusick  * The old fstat system call.
215041486Smckusick  */
215154917Storek struct ohpuxfstat_args {
215254917Storek 	int	fd;
215354917Storek 	struct ohpuxstat *sb;
215454917Storek };
2155*68373Scgd compat_43_hpuxfstat(p, uap, retval)
215643452Shibler 	struct proc *p;
215754917Storek 	register struct ohpuxfstat_args *uap;
215843452Shibler 	int *retval;
215943452Shibler {
216045923Smckusick 	register struct filedesc *fdp = p->p_fd;
216141486Smckusick 	struct file *fp;
216241486Smckusick 
216348478Skarels 	if (((unsigned)uap->fd) >= fdp->fd_nfiles ||
216448478Skarels 	    (fp = fdp->fd_ofiles[uap->fd]) == NULL)
216544421Skarels 		return (EBADF);
216643452Shibler 	if (fp->f_type != DTYPE_VNODE)
216744421Skarels 		return (EINVAL);
2168*68373Scgd 	return (compat_43_hpuxstat1((struct vnode *)fp->f_data, uap->sb, p));
216941486Smckusick }
217041486Smckusick 
217141486Smckusick /*
217241486Smckusick  * Old stat system call.  This version follows links.
217341486Smckusick  */
217454917Storek struct ohpuxstat_args {
217554917Storek 	char	*fname;
217654917Storek 	struct ohpuxstat *sb;
217754917Storek };
2178*68373Scgd compat_43_hpuxstat(p, uap, retval)
217943452Shibler 	struct proc *p;
218054917Storek 	register struct ohpuxstat_args *uap;
218143452Shibler 	int *retval;
218243452Shibler {
218343452Shibler 	int error;
218448478Skarels 	struct nameidata nd;
218541486Smckusick 
218652330Smckusick 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
218752330Smckusick 	if (error = namei(&nd))
218844421Skarels 		return (error);
2189*68373Scgd 	error = compat_43_hpuxstat1(nd.ni_vp, uap->sb, p);
219052330Smckusick 	vput(nd.ni_vp);
219144421Skarels 	return (error);
219241486Smckusick }
219341486Smckusick 
219441486Smckusick int
compat_43_hpuxstat1(vp,ub,p)2195*68373Scgd compat_43_hpuxstat1(vp, ub, p)
219657307Shibler 	struct vnode *vp;
219741486Smckusick 	struct ohpuxstat *ub;
219855282Smckusick 	struct proc *p;
219941486Smckusick {
220057307Shibler 	struct ohpuxstat ohsb;
220157307Shibler 	struct stat sb;
220257307Shibler 	int error;
220341486Smckusick 
220457307Shibler 	error = vn_stat(vp, &sb, p);
220541486Smckusick 	if (error)
220657307Shibler 		return (error);
220757307Shibler 
220857307Shibler 	ohsb.ohst_dev = sb.st_dev;
220957307Shibler 	ohsb.ohst_ino = sb.st_ino;
221057307Shibler 	ohsb.ohst_mode = sb.st_mode;
221157307Shibler 	ohsb.ohst_nlink = sb.st_nlink;
221257307Shibler 	ohsb.ohst_uid = sb.st_uid;
221357307Shibler 	ohsb.ohst_gid = sb.st_gid;
221457307Shibler 	ohsb.ohst_rdev = sb.st_rdev;
221557307Shibler 	if (sb.st_size < (quad_t)1 << 32)
221657307Shibler 		ohsb.ohst_size = sb.st_size;
221757307Shibler 	else
221857307Shibler 		ohsb.ohst_size = -2;
221957307Shibler 	ohsb.ohst_atime = sb.st_atime;
222057307Shibler 	ohsb.ohst_mtime = sb.st_mtime;
222157307Shibler 	ohsb.ohst_ctime = sb.st_ctime;
222257307Shibler 	return (copyout((caddr_t)&ohsb, (caddr_t)ub, sizeof(ohsb)));
222341486Smckusick }
222441486Smckusick #endif
222555832Shibler #endif
2226