1 /*
2 * Copyright (c) 1988 University of Utah.
3 * Copyright (c) 1990, 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * This code is derived from software contributed to Berkeley by
7 * the Systems Programming Group of the University of Utah Computer
8 * Science Department.
9 *
10 * %sccs.include.redist.c%
11 *
12 * from: Utah $Hdr: hpux_compat.c 1.64 93/08/05$
13 *
14 * @(#)hpux_compat.c 8.5 (Berkeley) 02/19/95
15 */
16
17 /*
18 * Various HP-UX compatibility routines
19 */
20
21 #ifdef HPUXCOMPAT
22 #ifndef COMPAT_43
23 #define COMPAT_43
24 #endif
25
26 #include <sys/param.h>
27 #include <sys/systm.h>
28 #include <sys/signalvar.h>
29 #include <sys/kernel.h>
30 #include <sys/filedesc.h>
31 #include <sys/proc.h>
32 #include <sys/buf.h>
33 #include <sys/wait.h>
34 #include <sys/file.h>
35 #include <sys/namei.h>
36 #include <sys/vnode.h>
37 #include <sys/ioctl.h>
38 #include <sys/ptrace.h>
39 #include <sys/stat.h>
40 #include <sys/syslog.h>
41 #include <sys/malloc.h>
42 #include <sys/mount.h>
43 #include <sys/ipc.h>
44 #include <sys/user.h>
45 #include <sys/mman.h>
46
47 #include <machine/cpu.h>
48 #include <machine/reg.h>
49 #include <machine/psl.h>
50 #include <machine/vmparam.h>
51 #include <hp/hpux/hpux.h>
52 #include <hp/hpux/hpux_termio.h>
53
54 #ifdef DEBUG
55 int unimpresponse = 0;
56 #endif
57
58 /* SYS5 style UTSNAME info */
59 struct hpuxutsname protoutsname = {
60 "4.4bsd", "", "0.5", "B", "9000/3?0", ""
61 };
62
63 /* 6.0 and later style context */
64 #if defined(HP380)
65 char hpux040context[] =
66 "standalone HP-MC68040 HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
67 #endif
68 #ifdef FPCOPROC
69 char hpuxcontext[] =
70 "standalone HP-MC68881 HP-MC68020 HP-MC68010 localroot default";
71 #else
72 char hpuxcontext[] =
73 "standalone HP-MC68020 HP-MC68010 localroot default";
74 #endif
75
76 /* YP domainname */
77 char domainname[MAXHOSTNAMELEN] = "unknown";
78 int domainnamelen = 7;
79
80 #define NERR 83
81 #define BERR 1000
82
83 /* indexed by BSD errno */
84 short bsdtohpuxerrnomap[NERR] = {
85 /*00*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
86 /*10*/ 10, 45, 12, 13, 14, 15, 16, 17, 18, 19,
87 /*20*/ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
88 /*30*/ 30, 31, 32, 33, 34, 246, 245, 244, 216, 217,
89 /*40*/ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
90 /*50*/ 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
91 /*60*/ 238, 239, 249, 248, 241, 242, 247,BERR,BERR,BERR,
92 /*70*/ 70, 71,BERR,BERR,BERR,BERR,BERR, 46, 251,BERR,
93 /*80*/ BERR,BERR, 11
94 };
95
96 notimp(p, uap, retval, code, argsize)
97 struct proc *p;
98 register_t *uap, *retval;
99 int code, argsize;
100 {
101 int error = 0;
102 #ifdef DEBUG
103 register int *argp = uap;
104 extern char *hpuxsyscallnames[];
105
106 printf("HP-UX %s(", hpuxsyscallnames[code]);
107 if (argsize)
108 while (argsize -= sizeof (register_t))
109 printf("%x%c", *argp++, argsize? ',' : ')');
110 else
111 printf(")");
112 printf("\n");
113 switch (unimpresponse) {
114 case 0:
115 error = nosys(p, uap, retval);
116 break;
117 case 1:
118 error = EINVAL;
119 break;
120 }
121 #else
122 error = nosys(p, uap, retval);
123 #endif
124 uprintf("HP-UX system call %d not implemented\n", code);
125 return (error);
126 }
127
128 /*
129 * HP-UX fork and vfork need to map the EAGAIN return value appropriately.
130 */
131 hpuxfork(p, uap, retval)
132 struct proc *p;
133 struct hpuxwait3_args *uap;
134 int *retval;
135 {
136 int error;
137
138 error = fork(p, uap, retval);
139 if (error == EAGAIN)
140 error = OEAGAIN;
141 return (error);
142 }
143
144 hpuxvfork(p, uap, retval)
145 struct proc *p;
146 struct hpuxwait3_args *uap;
147 int *retval;
148
149 {
150 int error;
151
152 error = vfork(p, uap, retval);
153 if (error == EAGAIN)
154 error = OEAGAIN;
155 return (error);
156 }
157
158 struct hpuxexecv_args {
159 char *fname;
160 char **argp;
161 char **envp;
162 };
163 hpuxexecv(p, uap, retval)
164 struct proc *p;
165 struct hpuxexecv_args *uap;
166 int *retval;
167 {
168 extern int execve();
169
170 uap->envp = NULL;
171 return (execve(p, uap, retval));
172 }
173
174 /*
175 * HP-UX versions of wait and wait3 actually pass the parameters
176 * (status pointer, options, rusage) into the kernel rather than
177 * handling it in the C library stub. We also need to map any
178 * termination signal from BSD to HP-UX.
179 */
180 struct hpuxwait3_args {
181 int *status;
182 int options;
183 int rusage;
184 };
185 hpuxwait3(p, uap, retval)
186 struct proc *p;
187 struct hpuxwait3_args *uap;
188 int *retval;
189 {
190 /* rusage pointer must be zero */
191 if (uap->rusage)
192 return (EINVAL);
193 p->p_md.md_regs[PS] = PSL_ALLCC;
194 p->p_md.md_regs[R0] = uap->options;
195 p->p_md.md_regs[R1] = uap->rusage;
196 return (hpuxwait(p, uap, retval));
197 }
198
199 struct hpuxwait_args {
200 int *status;
201 };
202 hpuxwait(p, uap, retval)
203 struct proc *p;
204 struct hpuxwait_args *uap;
205 int *retval;
206 {
207 int sig, *statp, error;
208
209 statp = uap->status; /* owait clobbers first arg */
210 error = compat_43_wait(p, uap, retval);
211 /*
212 * HP-UX wait always returns EINTR when interrupted by a signal
213 * (well, unless its emulating a BSD process, but we don't bother...)
214 */
215 if (error == ERESTART)
216 error = EINTR;
217 if (error)
218 return (error);
219 sig = retval[1] & 0xFF;
220 if (sig == WSTOPPED) {
221 sig = (retval[1] >> 8) & 0xFF;
222 retval[1] = (bsdtohpuxsig(sig) << 8) | WSTOPPED;
223 } else if (sig)
224 retval[1] = (retval[1] & 0xFF00) |
225 bsdtohpuxsig(sig & 0x7F) | (sig & 0x80);
226 if (statp)
227 if (suword((caddr_t)statp, retval[1]))
228 error = EFAULT;
229 return (error);
230 }
231
232 struct hpuxwaitpid_args {
233 int pid;
234 int *status;
235 int options;
236 struct rusage *rusage; /* wait4 arg */
237 };
238 hpuxwaitpid(p, uap, retval)
239 struct proc *p;
240 struct hpuxwaitpid_args *uap;
241 int *retval;
242 {
243 int rv, sig, xstat, error;
244
245 uap->rusage = 0;
246 error = wait4(p, uap, retval);
247 /*
248 * HP-UX wait always returns EINTR when interrupted by a signal
249 * (well, unless its emulating a BSD process, but we don't bother...)
250 */
251 if (error == ERESTART)
252 error = EINTR;
253 if (error)
254 return (error);
255 if (uap->status) {
256 /*
257 * Wait4 already wrote the status out to user space,
258 * pull it back, change the signal portion, and write
259 * it back out.
260 */
261 rv = fuword((caddr_t)uap->status);
262 if (WIFSTOPPED(rv)) {
263 sig = WSTOPSIG(rv);
264 rv = W_STOPCODE(bsdtohpuxsig(sig));
265 } else if (WIFSIGNALED(rv)) {
266 sig = WTERMSIG(rv);
267 xstat = WEXITSTATUS(rv);
268 rv = W_EXITCODE(xstat, bsdtohpuxsig(sig)) |
269 WCOREDUMP(rv);
270 }
271 (void)suword((caddr_t)uap->status, rv);
272 }
273 return (error);
274 }
275
276 /*
277 * Old creat system call.
278 */
279 struct hpuxcreat_args {
280 char *fname;
281 int fmode;
282 };
283 hpuxcreat(p, uap, retval)
284 struct proc *p;
285 register struct hpuxcreat_args *uap;
286 int *retval;
287 {
288 struct nargs {
289 char *fname;
290 int mode;
291 int crtmode;
292 } openuap;
293
294 openuap.fname = uap->fname;
295 openuap.crtmode = uap->fmode;
296 openuap.mode = O_WRONLY | O_CREAT | O_TRUNC;
297 return (open(p, &openuap, retval));
298 }
299
300 /*
301 * XXX extensions to the fd_ofileflags flags.
302 * Hate to put this there, but they do need to be per-file.
303 */
304 #define UF_NONBLOCK_ON 0x10
305 #define UF_FNDELAY_ON 0x20
306 #define UF_FIONBIO_ON 0x40
307
308 /*
309 * Must remap some bits in the mode mask.
310 * O_CREAT, O_TRUNC, and O_EXCL must be remapped,
311 * O_NONBLOCK is remapped and remembered,
312 * O_FNDELAY is remembered,
313 * O_SYNCIO is removed entirely.
314 */
315 struct hpuxopen_args {
316 char *fname;
317 int mode;
318 int crtmode;
319 };
320 hpuxopen(p, uap, retval)
321 struct proc *p;
322 register struct hpuxopen_args *uap;
323 int *retval;
324 {
325 int mode, error;
326
327 mode = uap->mode;
328 uap->mode &=
329 ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT);
330 if (mode & HPUXFCREAT) {
331 /*
332 * simulate the pre-NFS behavior that opening a
333 * file for READ+CREATE ignores the CREATE (unless
334 * EXCL is set in which case we will return the
335 * proper error).
336 */
337 if ((mode & HPUXFEXCL) || (FFLAGS(mode) & FWRITE))
338 uap->mode |= O_CREAT;
339 }
340 if (mode & HPUXFTRUNC)
341 uap->mode |= O_TRUNC;
342 if (mode & HPUXFEXCL)
343 uap->mode |= O_EXCL;
344 if (mode & HPUXNONBLOCK)
345 uap->mode |= O_NDELAY;
346 error = open(p, uap, retval);
347 /*
348 * Record non-blocking mode for fcntl, read, write, etc.
349 */
350 if (error == 0 && (uap->mode & O_NDELAY))
351 p->p_fd->fd_ofileflags[*retval] |=
352 (mode & HPUXNONBLOCK) ? UF_NONBLOCK_ON : UF_FNDELAY_ON;
353 return (error);
354 }
355
356 struct hpuxfcntl_args {
357 int fdes;
358 int cmd;
359 int arg;
360 };
361 hpuxfcntl(p, uap, retval)
362 struct proc *p;
363 register struct hpuxfcntl_args *uap;
364 int *retval;
365 {
366 int mode, error, flg = F_POSIX;
367 struct file *fp;
368 char *pop;
369 struct hpuxflock hfl;
370 struct flock fl;
371 struct vnode *vp;
372
373 if ((unsigned)uap->fdes >= p->p_fd->fd_nfiles ||
374 (fp = p->p_fd->fd_ofiles[uap->fdes]) == NULL)
375 return (EBADF);
376 pop = &p->p_fd->fd_ofileflags[uap->fdes];
377 switch (uap->cmd) {
378 case F_SETFL:
379 if (uap->arg & HPUXNONBLOCK)
380 *pop |= UF_NONBLOCK_ON;
381 else
382 *pop &= ~UF_NONBLOCK_ON;
383 if (uap->arg & HPUXNDELAY)
384 *pop |= UF_FNDELAY_ON;
385 else
386 *pop &= ~UF_FNDELAY_ON;
387 if (*pop & (UF_NONBLOCK_ON|UF_FNDELAY_ON|UF_FIONBIO_ON))
388 uap->arg |= FNONBLOCK;
389 else
390 uap->arg &= ~FNONBLOCK;
391 uap->arg &= ~(HPUXNONBLOCK|HPUXFSYNCIO|HPUXFREMOTE);
392 break;
393 case F_GETFL:
394 case F_DUPFD:
395 case F_GETFD:
396 case F_SETFD:
397 break;
398
399 case HPUXF_SETLKW:
400 flg |= F_WAIT;
401 /* Fall into F_SETLK */
402
403 case HPUXF_SETLK:
404 if (fp->f_type != DTYPE_VNODE)
405 return (EBADF);
406 vp = (struct vnode *)fp->f_data;
407 /* Copy in the lock structure */
408 error = copyin((caddr_t)uap->arg, (caddr_t)&hfl, sizeof (hfl));
409 if (error)
410 return (error);
411 fl.l_start = hfl.hl_start;
412 fl.l_len = hfl.hl_len;
413 fl.l_pid = hfl.hl_pid;
414 fl.l_type = hfl.hl_type;
415 fl.l_whence = hfl.hl_whence;
416 if (fl.l_whence == SEEK_CUR)
417 fl.l_start += fp->f_offset;
418 switch (fl.l_type) {
419
420 case F_RDLCK:
421 if ((fp->f_flag & FREAD) == 0)
422 return (EBADF);
423 p->p_flag |= P_ADVLOCK;
424 return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
425
426 case F_WRLCK:
427 if ((fp->f_flag & FWRITE) == 0)
428 return (EBADF);
429 p->p_flag |= P_ADVLOCK;
430 return (VOP_ADVLOCK(vp, (caddr_t)p, F_SETLK, &fl, flg));
431
432 case F_UNLCK:
433 return (VOP_ADVLOCK(vp, (caddr_t)p, F_UNLCK, &fl,
434 F_POSIX));
435
436 default:
437 return (EINVAL);
438 }
439
440 case F_GETLK:
441 if (fp->f_type != DTYPE_VNODE)
442 return (EBADF);
443 vp = (struct vnode *)fp->f_data;
444 /* Copy in the lock structure */
445 error = copyin((caddr_t)uap->arg, (caddr_t)&hfl, sizeof (hfl));
446 if (error)
447 return (error);
448 fl.l_start = hfl.hl_start;
449 fl.l_len = hfl.hl_len;
450 fl.l_pid = hfl.hl_pid;
451 fl.l_type = hfl.hl_type;
452 fl.l_whence = hfl.hl_whence;
453 if (fl.l_whence == SEEK_CUR)
454 fl.l_start += fp->f_offset;
455 if (error = VOP_ADVLOCK(vp, (caddr_t)p, F_GETLK, &fl, F_POSIX))
456 return (error);
457 hfl.hl_start = fl.l_start;
458 hfl.hl_len = fl.l_len;
459 hfl.hl_pid = fl.l_pid;
460 hfl.hl_type = fl.l_type;
461 hfl.hl_whence = fl.l_whence;
462 return (copyout((caddr_t)&hfl, (caddr_t)uap->arg, sizeof (hfl)));
463
464 default:
465 return (EINVAL);
466 }
467 error = fcntl(p, uap, retval);
468 if (error == 0 && uap->cmd == F_GETFL) {
469 mode = *retval;
470 *retval &= ~(O_CREAT|O_TRUNC|O_EXCL);
471 if (mode & FNONBLOCK) {
472 if (*pop & UF_NONBLOCK_ON)
473 *retval |= HPUXNONBLOCK;
474 if ((*pop & UF_FNDELAY_ON) == 0)
475 *retval &= ~HPUXNDELAY;
476 }
477 if (mode & O_CREAT)
478 *retval |= HPUXFCREAT;
479 if (mode & O_TRUNC)
480 *retval |= HPUXFTRUNC;
481 if (mode & O_EXCL)
482 *retval |= HPUXFEXCL;
483 }
484 return (error);
485 }
486
487 /*
488 * Read and write calls. Same as BSD except for non-blocking behavior.
489 * There are three types of non-blocking reads/writes in HP-UX checked
490 * in the following order:
491 *
492 * O_NONBLOCK: return -1 and errno == EAGAIN
493 * O_NDELAY: return 0
494 * FIOSNBIO: return -1 and errno == EWOULDBLOCK
495 */
496 struct hpuxrw_args {
497 int fd;
498 };
499
500 hpuxread(p, uap, retval)
501 struct proc *p;
502 struct hpuxrw_args *uap;
503 int *retval;
504 {
505 int error;
506
507 error = read(p, uap, retval);
508 if (error == EWOULDBLOCK) {
509 char *fp = &p->p_fd->fd_ofileflags[uap->fd];
510
511 if (*fp & UF_NONBLOCK_ON) {
512 *retval = -1;
513 error = OEAGAIN;
514 } else if (*fp & UF_FNDELAY_ON) {
515 *retval = 0;
516 error = 0;
517 }
518 }
519 return (error);
520 }
521
522 hpuxwrite(p, uap, retval)
523 struct proc *p;
524 struct hpuxrw_args *uap;
525 int *retval;
526 {
527 int error;
528
529 error = write(p, uap, retval);
530 if (error == EWOULDBLOCK) {
531 char *fp = &p->p_fd->fd_ofileflags[uap->fd];
532
533 if (*fp & UF_NONBLOCK_ON) {
534 *retval = -1;
535 error = OEAGAIN;
536 } else if (*fp & UF_FNDELAY_ON) {
537 *retval = 0;
538 error = 0;
539 }
540 }
541 return (error);
542 }
543
544 hpuxreadv(p, uap, retval)
545 struct proc *p;
546 struct hpuxrw_args *uap;
547 int *retval;
548 {
549 int error;
550
551 error = readv(p, uap, retval);
552 if (error == EWOULDBLOCK) {
553 char *fp = &p->p_fd->fd_ofileflags[uap->fd];
554
555 if (*fp & UF_NONBLOCK_ON) {
556 *retval = -1;
557 error = OEAGAIN;
558 } else if (*fp & UF_FNDELAY_ON) {
559 *retval = 0;
560 error = 0;
561 }
562 }
563 return (error);
564 }
565
566 hpuxwritev(p, uap, retval)
567 struct proc *p;
568 struct hpuxrw_args *uap;
569 int *retval;
570 {
571 int error;
572
573 error = writev(p, uap, retval);
574 if (error == EWOULDBLOCK) {
575 char *fp = &p->p_fd->fd_ofileflags[uap->fd];
576
577 if (*fp & UF_NONBLOCK_ON) {
578 *retval = -1;
579 error = OEAGAIN;
580 } else if (*fp & UF_FNDELAY_ON) {
581 *retval = 0;
582 error = 0;
583 }
584 }
585 return (error);
586 }
587
588 /*
589 * 4.3bsd dup allows dup2 to come in on the same syscall entry
590 * and hence allows two arguments. HP-UX dup has only one arg.
591 */
592 struct hpuxdup_args {
593 int i;
594 };
595 hpuxdup(p, uap, retval)
596 struct proc *p;
597 register struct hpuxdup_args *uap;
598 int *retval;
599 {
600 register struct filedesc *fdp = p->p_fd;
601 struct file *fp;
602 int fd, error;
603
604 if (((unsigned)uap->i) >= fdp->fd_nfiles ||
605 (fp = fdp->fd_ofiles[uap->i]) == NULL)
606 return (EBADF);
607 if (error = fdalloc(p, 0, &fd))
608 return (error);
609 fdp->fd_ofiles[fd] = fp;
610 fdp->fd_ofileflags[fd] = fdp->fd_ofileflags[uap->i] &~ UF_EXCLOSE;
611 fp->f_count++;
612 if (fd > fdp->fd_lastfile)
613 fdp->fd_lastfile = fd;
614 *retval = fd;
615 return (0);
616 }
617
618 struct hpuxutssys_args {
619 struct hpuxutsname *uts;
620 int dev;
621 int request;
622 };
623 hpuxutssys(p, uap, retval)
624 struct proc *p;
625 register struct hpuxutssys_args *uap;
626 int *retval;
627 {
628 register int i;
629 int error;
630
631 switch (uap->request) {
632 /* uname */
633 case 0:
634 /* fill in machine type */
635 switch (machineid) {
636 case HP_320:
637 protoutsname.machine[6] = '2';
638 break;
639 /* includes 318 and 319 */
640 case HP_330:
641 protoutsname.machine[6] = '3';
642 break;
643 case HP_340:
644 protoutsname.machine[6] = '4';
645 break;
646 case HP_350:
647 protoutsname.machine[6] = '5';
648 break;
649 case HP_360:
650 protoutsname.machine[6] = '6';
651 break;
652 case HP_370:
653 protoutsname.machine[6] = '7';
654 break;
655 /* includes 345 */
656 case HP_375:
657 protoutsname.machine[6] = '7';
658 protoutsname.machine[7] = '5';
659 break;
660 /* includes 425 */
661 case HP_380:
662 protoutsname.machine[6] = '8';
663 break;
664 case HP_433:
665 protoutsname.machine[5] = '4';
666 protoutsname.machine[6] = '3';
667 protoutsname.machine[7] = '3';
668 break;
669 }
670 /* copy hostname (sans domain) to nodename */
671 for (i = 0; i < 8 && hostname[i] != '.'; i++)
672 protoutsname.nodename[i] = hostname[i];
673 protoutsname.nodename[i] = '\0';
674 error = copyout((caddr_t)&protoutsname, (caddr_t)uap->uts,
675 sizeof(struct hpuxutsname));
676 break;
677
678 /* gethostname */
679 case 5:
680 /* uap->dev is length */
681 if (uap->dev > hostnamelen + 1)
682 uap->dev = hostnamelen + 1;
683 error = copyout((caddr_t)hostname, (caddr_t)uap->uts,
684 uap->dev);
685 break;
686
687 case 1: /* ?? */
688 case 2: /* ustat */
689 case 3: /* ?? */
690 case 4: /* sethostname */
691 default:
692 error = EINVAL;
693 break;
694 }
695 return (error);
696 }
697
698 struct hpuxsysconf_args {
699 int name;
700 };
701 hpuxsysconf(p, uap, retval)
702 struct proc *p;
703 struct hpuxsysconf_args *uap;
704 int *retval;
705 {
706 switch (uap->name) {
707
708 /* clock ticks per second */
709 case HPUX_SYSCONF_CLKTICK:
710 *retval = hz;
711 break;
712
713 /* open files */
714 case HPUX_SYSCONF_OPENMAX:
715 *retval = NOFILE;
716 break;
717
718 /* architecture */
719 case HPUX_SYSCONF_CPUTYPE:
720 switch (machineid) {
721 case HP_320:
722 case HP_330:
723 case HP_350:
724 *retval = HPUX_SYSCONF_CPUM020;
725 break;
726 case HP_340:
727 case HP_360:
728 case HP_370:
729 case HP_375:
730 *retval = HPUX_SYSCONF_CPUM030;
731 break;
732 case HP_380:
733 case HP_433:
734 *retval = HPUX_SYSCONF_CPUM040;
735 break;
736 }
737 break;
738 default:
739 uprintf("HP-UX sysconf(%d) not implemented\n", uap->name);
740 return (EINVAL);
741 }
742 return (0);
743 }
744
745 struct hpuxstat_args {
746 char *fname;
747 struct hpuxstat *hsb;
748 };
749 hpuxstat(p, uap, retval)
750 struct proc *p;
751 struct hpuxstat_args *uap;
752 int *retval;
753 {
754 return (hpuxstat1(uap->fname, uap->hsb, FOLLOW, p));
755 }
756
757 struct hpuxlstat_args {
758 char *fname;
759 struct hpuxstat *hsb;
760 };
761 hpuxlstat(p, uap, retval)
762 struct proc *p;
763 struct hpuxlstat_args *uap;
764 int *retval;
765 {
766 return (hpuxstat1(uap->fname, uap->hsb, NOFOLLOW, p));
767 }
768
769 struct hpuxfstat_args {
770 int fdes;
771 struct hpuxstat *hsb;
772 };
773 hpuxfstat(p, uap, retval)
774 struct proc *p;
775 register struct hpuxfstat_args *uap;
776 int *retval;
777 {
778 register struct filedesc *fdp = p->p_fd;
779 register struct file *fp;
780 struct stat sb;
781 int error;
782
783 if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
784 (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
785 return (EBADF);
786
787 switch (fp->f_type) {
788
789 case DTYPE_VNODE:
790 error = vn_stat((struct vnode *)fp->f_data, &sb, p);
791 break;
792
793 case DTYPE_SOCKET:
794 error = soo_stat((struct socket *)fp->f_data, &sb, p);
795 break;
796
797 default:
798 panic("fstat");
799 /*NOTREACHED*/
800 }
801 /* is this right for sockets?? */
802 if (error == 0)
803 error = bsdtohpuxstat(&sb, uap->hsb);
804 return (error);
805 }
806
807 struct hpuxulimit_args {
808 int cmd;
809 long newlimit;
810 };
811 hpuxulimit(p, uap, retval)
812 struct proc *p;
813 register struct hpuxulimit_args *uap;
814 long *retval;
815 {
816 struct rlimit *limp;
817 int error = 0;
818
819 limp = &p->p_rlimit[RLIMIT_FSIZE];
820 switch (uap->cmd) {
821 case 2:
822 uap->newlimit *= 512;
823 if (uap->newlimit > limp->rlim_max &&
824 (error = suser(p->p_ucred, &p->p_acflag)))
825 break;
826 limp->rlim_cur = limp->rlim_max = uap->newlimit;
827 /* else fall into... */
828
829 case 1:
830 *retval = limp->rlim_max / 512;
831 break;
832
833 case 3:
834 limp = &p->p_rlimit[RLIMIT_DATA];
835 *retval = ctob(p->p_vmspace->vm_tsize) + limp->rlim_max;
836 break;
837
838 default:
839 error = EINVAL;
840 break;
841 }
842 return (error);
843 }
844
845 /*
846 * Map "real time" priorities 0 (high) thru 127 (low) into nice
847 * values -16 (high) thru -1 (low).
848 */
849 struct hpuxrtprio_args {
850 int pid;
851 int prio;
852 };
853 hpuxrtprio(cp, uap, retval)
854 struct proc *cp;
855 register struct hpuxrtprio_args *uap;
856 int *retval;
857 {
858 struct proc *p;
859 int nice, error;
860
861 if (uap->prio < RTPRIO_MIN && uap->prio > RTPRIO_MAX &&
862 uap->prio != RTPRIO_NOCHG && uap->prio != RTPRIO_RTOFF)
863 return (EINVAL);
864 if (uap->pid == 0)
865 p = cp;
866 else if ((p = pfind(uap->pid)) == 0)
867 return (ESRCH);
868 nice = p->p_nice;
869 if (nice < NZERO)
870 *retval = (nice + 16) << 3;
871 else
872 *retval = RTPRIO_RTOFF;
873 switch (uap->prio) {
874
875 case RTPRIO_NOCHG:
876 return (0);
877
878 case RTPRIO_RTOFF:
879 if (nice >= NZERO)
880 return (0);
881 nice = NZERO;
882 break;
883
884 default:
885 nice = (uap->prio >> 3) - 16;
886 break;
887 }
888 error = donice(cp, p, nice);
889 if (error == EACCES)
890 error = EPERM;
891 return (error);
892 }
893
894 struct hpuxadvise_args {
895 int arg;
896 };
897 hpuxadvise(p, uap, retval)
898 struct proc *p;
899 struct hpuxadvise_args *uap;
900 int *retval;
901 {
902 int error = 0;
903
904 switch (uap->arg) {
905 case 0:
906 p->p_md.md_flags |= MDP_HPUXMMAP;
907 break;
908 case 1:
909 ICIA();
910 break;
911 case 2:
912 DCIA();
913 break;
914 default:
915 error = EINVAL;
916 break;
917 }
918 return (error);
919 }
920
921 struct hpuxptrace_args {
922 int req;
923 int pid;
924 int *addr;
925 int data;
926 };
927 hpuxptrace(p, uap, retval)
928 struct proc *p;
929 struct hpuxptrace_args *uap;
930 int *retval;
931 {
932 int error, isps = 0;
933 struct proc *cp;
934
935 switch (uap->req) {
936 /* map signal */
937 case PT_STEP:
938 case PT_CONTINUE:
939 if (uap->data) {
940 uap->data = hpuxtobsdsig(uap->data);
941 if (uap->data == 0)
942 uap->data = NSIG;
943 }
944 break;
945 /* map u-area offset */
946 case PT_READ_U:
947 case PT_WRITE_U:
948 /*
949 * Big, cheezy hack: hpuxtobsduoff is really intended
950 * to be called in the child context (procxmt) but we
951 * do it here in the parent context to avoid hacks in
952 * the MI sys_process.c file. This works only because
953 * we can access the child's md_regs pointer and it
954 * has the correct value (the child has already trapped
955 * into the kernel).
956 */
957 if ((cp = pfind(uap->pid)) == 0)
958 return (ESRCH);
959 uap->addr = (int *) hpuxtobsduoff(uap->addr, &isps, cp);
960
961 /*
962 * Since HP-UX PS is only 16-bits in ar0, requests
963 * to write PS actually contain the PS in the high word
964 * and the high half of the PC (the following register)
965 * in the low word. Move the PS value to where BSD
966 * expects it.
967 */
968 if (isps && uap->req == PT_WRITE_U)
969 uap->data >>= 16;
970 break;
971 }
972 error = ptrace(p, uap, retval);
973 /*
974 * Align PS as HP-UX expects it (see WRITE_U comment above).
975 * Note that we do not return the high part of PC like HP-UX
976 * would, but the HP-UX debuggers don't require it.
977 */
978 if (isps && error == 0 && uap->req == PT_READ_U)
979 *retval <<= 16;
980 return (error);
981 }
982
983 struct hpuxgetdomainname_args {
984 char *domainname;
985 u_int len;
986 };
987 hpuxgetdomainname(p, uap, retval)
988 struct proc *p;
989 register struct hpuxgetdomainname_args *uap;
990 int *retval;
991 {
992 if (uap->len > domainnamelen + 1)
993 uap->len = domainnamelen + 1;
994 return (copyout(domainname, uap->domainname, uap->len));
995 }
996
997 struct hpuxsetdomainname_args {
998 char *domainname;
999 u_int len;
1000 };
1001 hpuxsetdomainname(p, uap, retval)
1002 struct proc *p;
1003 register struct hpuxsetdomainname_args *uap;
1004 int *retval;
1005 {
1006 int error;
1007
1008 if (error = suser(p->p_ucred, &p->p_acflag))
1009 return (error);
1010 if (uap->len > sizeof (domainname) - 1)
1011 return (EINVAL);
1012 domainnamelen = uap->len;
1013 error = copyin(uap->domainname, domainname, uap->len);
1014 domainname[domainnamelen] = 0;
1015 return (error);
1016 }
1017
1018 #ifdef SYSVSHM
1019 #include <sys/shm.h>
1020
1021 hpuxshmat(p, uap, retval)
1022 struct proc *p;
1023 int *uap, *retval;
1024 {
1025 return (shmat(p, uap, retval));
1026 }
1027
1028 hpuxshmdt(p, uap, retval)
1029 struct proc *p;
1030 int *uap, *retval;
1031 {
1032 return (shmdt(p, uap, retval));
1033 }
1034
1035 hpuxshmget(p, uap, retval)
1036 struct proc *p;
1037 int *uap, *retval;
1038 {
1039 return (shmget(p, uap, retval));
1040 }
1041
1042 hpuxshmctl(p, uap, retval)
1043 struct proc *p;
1044 int *uap, *retval;
1045 {
1046 return (hpuxshmctl1(p, uap, retval, 0));
1047 }
1048
1049 hpuxnshmctl(p, uap, retval)
1050 struct proc *p;
1051 int *uap, *retval;
1052 {
1053 return (hpuxshmctl1(p, uap, retval, 1));
1054 }
1055
1056 /*
1057 * Handle HP-UX specific commands.
1058 */
1059 struct hpuxshmctl_args {
1060 int shmid;
1061 int cmd;
1062 caddr_t buf;
1063 };
1064 hpuxshmctl1(p, uap, retval, isnew)
1065 struct proc *p;
1066 struct hpuxshmctl_args *uap;
1067 int *retval;
1068 int isnew;
1069 {
1070 register struct shmid_ds *shp;
1071 register struct ucred *cred = p->p_ucred;
1072 struct hpuxshmid_ds sbuf;
1073 int error;
1074
1075 if (error = shmvalid(uap->shmid))
1076 return (error);
1077 shp = &shmsegs[uap->shmid % SHMMMNI];
1078 switch (uap->cmd) {
1079 case SHM_LOCK:
1080 case SHM_UNLOCK:
1081 /* don't really do anything, but make them think we did */
1082 if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
1083 cred->cr_uid != shp->shm_perm.cuid)
1084 return (EPERM);
1085 return (0);
1086
1087 case IPC_STAT:
1088 if (!isnew)
1089 break;
1090 error = ipcaccess(&shp->shm_perm, IPC_R, cred);
1091 if (error == 0) {
1092 sbuf.shm_perm.uid = shp->shm_perm.uid;
1093 sbuf.shm_perm.gid = shp->shm_perm.gid;
1094 sbuf.shm_perm.cuid = shp->shm_perm.cuid;
1095 sbuf.shm_perm.cgid = shp->shm_perm.cgid;
1096 sbuf.shm_perm.mode = shp->shm_perm.mode;
1097 sbuf.shm_perm.seq = shp->shm_perm.seq;
1098 sbuf.shm_perm.key = shp->shm_perm.key;
1099 sbuf.shm_segsz = shp->shm_segsz;
1100 sbuf.shm_ptbl = shp->shm_handle; /* XXX */
1101 sbuf.shm_lpid = shp->shm_lpid;
1102 sbuf.shm_cpid = shp->shm_cpid;
1103 sbuf.shm_nattch = shp->shm_nattch;
1104 sbuf.shm_cnattch = shp->shm_nattch; /* XXX */
1105 sbuf.shm_atime = shp->shm_atime;
1106 sbuf.shm_dtime = shp->shm_dtime;
1107 sbuf.shm_ctime = shp->shm_ctime;
1108 error = copyout((caddr_t)&sbuf, uap->buf, sizeof sbuf);
1109 }
1110 return (error);
1111
1112 case IPC_SET:
1113 if (!isnew)
1114 break;
1115 if (cred->cr_uid && cred->cr_uid != shp->shm_perm.uid &&
1116 cred->cr_uid != shp->shm_perm.cuid) {
1117 return (EPERM);
1118 }
1119 error = copyin(uap->buf, (caddr_t)&sbuf, sizeof sbuf);
1120 if (error == 0) {
1121 shp->shm_perm.uid = sbuf.shm_perm.uid;
1122 shp->shm_perm.gid = sbuf.shm_perm.gid;
1123 shp->shm_perm.mode = (shp->shm_perm.mode & ~0777)
1124 | (sbuf.shm_perm.mode & 0777);
1125 shp->shm_ctime = time.tv_sec;
1126 }
1127 return (error);
1128 }
1129 return (shmctl(p, uap, retval));
1130 }
1131 #endif
1132
1133 /*
1134 * Fake semaphore routines, just don't return an error.
1135 * Should be adequate for starbase to run.
1136 */
1137 struct hpuxsemctl_args {
1138 int semid;
1139 u_int semnum;
1140 int cmd;
1141 int arg;
1142 };
1143 hpuxsemctl(p, uap, retval)
1144 struct proc *p;
1145 struct hpuxsemctl_args *uap;
1146 int *retval;
1147 {
1148 /* XXX: should do something here */
1149 return (0);
1150 }
1151
1152 struct hpuxsemget_args {
1153 key_t key;
1154 int nsems;
1155 int semflg;
1156 };
1157 hpuxsemget(p, uap, retval)
1158 struct proc *p;
1159 struct hpuxsemget_args *uap;
1160 int *retval;
1161 {
1162 /* XXX: should do something here */
1163 return (0);
1164 }
1165
1166 struct hpuxsemop_args {
1167 int semid;
1168 struct sembuf *sops;
1169 u_int nsops;
1170 };
1171 hpuxsemop(p, uap, retval)
1172 struct proc *p;
1173 struct hpuxsemop_args *uap;
1174 int *retval;
1175 {
1176 /* XXX: should do something here */
1177 return (0);
1178 }
1179
1180 /*
1181 * HP-UX mmap() emulation (mainly for shared library support).
1182 */
1183 struct hpuxmmap_args {
1184 caddr_t addr;
1185 int len;
1186 int prot;
1187 int flags;
1188 int fd;
1189 long pos;
1190 };
1191 hpuxmmap(p, uap, retval)
1192 struct proc *p;
1193 struct hpuxmmap_args *uap;
1194 int *retval;
1195 {
1196 struct mmap_args {
1197 caddr_t addr;
1198 int len;
1199 int prot;
1200 int flags;
1201 int fd;
1202 long pad;
1203 off_t pos;
1204 } nargs;
1205
1206 nargs.addr = uap->addr;
1207 nargs.len = uap->len;
1208 nargs.prot = uap->prot;
1209 nargs.flags = uap->flags &
1210 ~(HPUXMAP_FIXED|HPUXMAP_REPLACE|HPUXMAP_ANON);
1211 if (uap->flags & HPUXMAP_FIXED)
1212 nargs.flags |= MAP_FIXED;
1213 if (uap->flags & HPUXMAP_ANON)
1214 nargs.flags |= MAP_ANON;
1215 nargs.fd = (nargs.flags & MAP_ANON) ? -1 : uap->fd;
1216 nargs.pos = uap->pos;
1217 return (mmap(p, &nargs, retval));
1218 }
1219
1220 /* convert from BSD to HP-UX errno */
bsdtohpuxerrno(err)1221 bsdtohpuxerrno(err)
1222 int err;
1223 {
1224 if (err < 0 || err >= NERR)
1225 return(BERR);
1226 return((int)bsdtohpuxerrnomap[err]);
1227 }
1228
hpuxstat1(fname,hsb,follow,p)1229 hpuxstat1(fname, hsb, follow, p)
1230 char *fname;
1231 struct hpuxstat *hsb;
1232 int follow;
1233 struct proc *p;
1234 {
1235 int error;
1236 struct stat sb;
1237 struct nameidata nd;
1238
1239 NDINIT(&nd, LOOKUP, follow | LOCKLEAF, UIO_USERSPACE, fname, p);
1240 if (error = namei(&nd))
1241 return (error);
1242 error = vn_stat(nd.ni_vp, &sb, p);
1243 vput(nd.ni_vp);
1244 if (error == 0)
1245 error = bsdtohpuxstat(&sb, hsb);
1246 return (error);
1247 }
1248
1249 #include "grf.h"
1250 #if NGRF > 0
1251 #ifdef __STDC__
1252 extern int grfopen(dev_t dev, int oflags, int devtype, struct proc *p);
1253 #else
1254 extern int grfopen();
1255 #endif
1256 #endif
1257
1258 #define NHIL 1 /* XXX */
1259 #if NHIL > 0
1260 #ifdef __STDC__
1261 extern int hilopen(dev_t dev, int oflags, int devtype, struct proc *p);
1262 #else
1263 extern int hilopen();
1264 #endif
1265 #endif
1266
1267 #include <sys/conf.h>
1268
1269 bsdtohpuxstat(sb, hsb)
1270 struct stat *sb;
1271 struct hpuxstat *hsb;
1272 {
1273 struct hpuxstat ds;
1274
1275 bzero((caddr_t)&ds, sizeof(ds));
1276 ds.hst_dev = (u_short)sb->st_dev;
1277 ds.hst_ino = (u_long)sb->st_ino;
1278 ds.hst_mode = sb->st_mode;
1279 ds.hst_nlink = sb->st_nlink;
1280 ds.hst_uid = (u_short)sb->st_uid;
1281 ds.hst_gid = (u_short)sb->st_gid;
1282 ds.hst_rdev = bsdtohpuxdev(sb->st_rdev);
1283
1284 /* XXX: I don't want to talk about it... */
1285 if ((sb->st_mode & S_IFMT) == S_IFCHR) {
1286 #if NGRF > 0
1287 if (cdevsw[major(sb->st_rdev)].d_open == grfopen)
1288 ds.hst_rdev = grfdevno(sb->st_rdev);
1289 #endif
1290 #if NHIL > 0
1291 if (cdevsw[major(sb->st_rdev)].d_open == hilopen)
1292 ds.hst_rdev = hildevno(sb->st_rdev);
1293 #endif
1294 ;
1295 }
1296 if (sb->st_size < (quad_t)1 << 32)
1297 ds.hst_size = (long)sb->st_size;
1298 else
1299 ds.hst_size = -2;
1300 ds.hst_atime = sb->st_atime;
1301 ds.hst_mtime = sb->st_mtime;
1302 ds.hst_ctime = sb->st_ctime;
1303 ds.hst_blksize = sb->st_blksize;
1304 ds.hst_blocks = sb->st_blocks;
1305 return(copyout((caddr_t)&ds, (caddr_t)hsb, sizeof(ds)));
1306 }
1307
hpuxtobsdioctl(com)1308 hpuxtobsdioctl(com)
1309 int com;
1310 {
1311 switch (com) {
1312 case HPUXTIOCSLTC:
1313 com = TIOCSLTC; break;
1314 case HPUXTIOCGLTC:
1315 com = TIOCGLTC; break;
1316 case HPUXTIOCSPGRP:
1317 com = TIOCSPGRP; break;
1318 case HPUXTIOCGPGRP:
1319 com = TIOCGPGRP; break;
1320 case HPUXTIOCLBIS:
1321 com = TIOCLBIS; break;
1322 case HPUXTIOCLBIC:
1323 com = TIOCLBIC; break;
1324 case HPUXTIOCLSET:
1325 com = TIOCLSET; break;
1326 case HPUXTIOCLGET:
1327 com = TIOCLGET; break;
1328 case HPUXTIOCGWINSZ:
1329 com = TIOCGWINSZ; break;
1330 case HPUXTIOCSWINSZ:
1331 com = TIOCSWINSZ; break;
1332 }
1333 return(com);
1334 }
1335
1336 /*
1337 * HP-UX ioctl system call. The differences here are:
1338 * IOC_IN also means IOC_VOID if the size portion is zero.
1339 * no FIOCLEX/FIONCLEX/FIOASYNC/FIOGETOWN/FIOSETOWN
1340 * the sgttyb struct is 2 bytes longer
1341 */
1342 struct hpuxioctl_args {
1343 int fdes;
1344 int cmd;
1345 caddr_t cmarg;
1346 };
1347 hpuxioctl(p, uap, retval)
1348 struct proc *p;
1349 register struct hpuxioctl_args *uap;
1350 int *retval;
1351 {
1352 register struct filedesc *fdp = p->p_fd;
1353 register struct file *fp;
1354 register int com, error;
1355 register u_int size;
1356 caddr_t memp = 0;
1357 #define STK_PARAMS 128
1358 char stkbuf[STK_PARAMS];
1359 caddr_t data = stkbuf;
1360
1361 com = uap->cmd;
1362
1363 /* XXX */
1364 if (com == HPUXTIOCGETP || com == HPUXTIOCSETP)
1365 return (getsettty(p, uap->fdes, com, uap->cmarg));
1366
1367 if (((unsigned)uap->fdes) >= fdp->fd_nfiles ||
1368 (fp = fdp->fd_ofiles[uap->fdes]) == NULL)
1369 return (EBADF);
1370 if ((fp->f_flag & (FREAD|FWRITE)) == 0)
1371 return (EBADF);
1372
1373 /*
1374 * Interpret high order word to find
1375 * amount of data to be copied to/from the
1376 * user's address space.
1377 */
1378 size = IOCPARM_LEN(com);
1379 if (size > IOCPARM_MAX)
1380 return (ENOTTY);
1381 if (size > sizeof (stkbuf)) {
1382 memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
1383 data = memp;
1384 }
1385 if (com&IOC_IN) {
1386 if (size) {
1387 error = copyin(uap->cmarg, data, (u_int)size);
1388 if (error) {
1389 if (memp)
1390 free(memp, M_IOCTLOPS);
1391 return (error);
1392 }
1393 } else
1394 *(caddr_t *)data = uap->cmarg;
1395 } else if ((com&IOC_OUT) && size)
1396 /*
1397 * Zero the buffer so the user always
1398 * gets back something deterministic.
1399 */
1400 bzero(data, size);
1401 else if (com&IOC_VOID)
1402 *(caddr_t *)data = uap->cmarg;
1403
1404 switch (com) {
1405
1406 case HPUXFIOSNBIO:
1407 {
1408 char *ofp = &fdp->fd_ofileflags[uap->fdes];
1409 int tmp;
1410
1411 if (*(int *)data)
1412 *ofp |= UF_FIONBIO_ON;
1413 else
1414 *ofp &= ~UF_FIONBIO_ON;
1415 /*
1416 * Only set/clear if O_NONBLOCK/FNDELAY not in effect
1417 */
1418 if ((*ofp & (UF_NONBLOCK_ON|UF_FNDELAY_ON)) == 0) {
1419 tmp = *ofp & UF_FIONBIO_ON;
1420 error = (*fp->f_ops->fo_ioctl)(fp, FIONBIO,
1421 (caddr_t)&tmp, p);
1422 }
1423 break;
1424 }
1425
1426 case HPUXTIOCCONS:
1427 *(int *)data = 1;
1428 error = (*fp->f_ops->fo_ioctl)(fp, TIOCCONS, data, p);
1429 break;
1430
1431 /* BSD-style job control ioctls */
1432 case HPUXTIOCLBIS:
1433 case HPUXTIOCLBIC:
1434 case HPUXTIOCLSET:
1435 *(int *)data &= HPUXLTOSTOP;
1436 if (*(int *)data & HPUXLTOSTOP)
1437 *(int *)data = LTOSTOP;
1438 /* fall into */
1439
1440 /* simple mapping cases */
1441 case HPUXTIOCLGET:
1442 case HPUXTIOCSLTC:
1443 case HPUXTIOCGLTC:
1444 case HPUXTIOCSPGRP:
1445 case HPUXTIOCGPGRP:
1446 case HPUXTIOCGWINSZ:
1447 case HPUXTIOCSWINSZ:
1448 error = (*fp->f_ops->fo_ioctl)
1449 (fp, hpuxtobsdioctl(com), data, p);
1450 if (error == 0 && com == HPUXTIOCLGET) {
1451 *(int *)data &= LTOSTOP;
1452 if (*(int *)data & LTOSTOP)
1453 *(int *)data = HPUXLTOSTOP;
1454 }
1455 break;
1456
1457 /* SYS 5 termio and POSIX termios */
1458 case HPUXTCGETA:
1459 case HPUXTCSETA:
1460 case HPUXTCSETAW:
1461 case HPUXTCSETAF:
1462 case HPUXTCGETATTR:
1463 case HPUXTCSETATTR:
1464 case HPUXTCSETATTRD:
1465 case HPUXTCSETATTRF:
1466 error = hpuxtermio(uap->fdes, com, data, p);
1467 break;
1468
1469 default:
1470 error = (*fp->f_ops->fo_ioctl)(fp, com, data, p);
1471 break;
1472 }
1473 /*
1474 * Copy any data to user, size was
1475 * already set and checked above.
1476 */
1477 if (error == 0 && (com&IOC_OUT) && size)
1478 error = copyout(data, uap->cmarg, (u_int)size);
1479 if (memp)
1480 free(memp, M_IOCTLOPS);
1481 return (error);
1482 }
1483
1484 /*
1485 * Man page lies, behaviour here is based on observed behaviour.
1486 */
1487 struct hpuxgetcontext_args {
1488 char *buf;
1489 int len;
1490 };
1491 hpuxgetcontext(p, uap, retval)
1492 struct proc *p;
1493 struct hpuxgetcontext_args *uap;
1494 int *retval;
1495 {
1496 int error = 0;
1497 register int len;
1498
1499 #if defined(HP380)
1500 if (machineid == HP_380) {
1501 len = min(uap->len, sizeof(hpux040context));
1502 if (len)
1503 error = copyout(hpux040context, uap->buf, len);
1504 if (error == 0)
1505 *retval = sizeof(hpux040context);
1506 return (error);
1507 }
1508 #endif
1509 len = min(uap->len, sizeof(hpuxcontext));
1510 if (len)
1511 error = copyout(hpuxcontext, uap->buf, (u_int)len);
1512 if (error == 0)
1513 *retval = sizeof(hpuxcontext);
1514 return (error);
1515 }
1516
1517 /*
1518 * This is the equivalent of BSD getpgrp but with more restrictions.
1519 * Note we do not check the real uid or "saved" uid.
1520 */
1521 struct hpuxgetpgrp2_args {
1522 int pid;
1523 };
1524 hpuxgetpgrp2(cp, uap, retval)
1525 struct proc *cp;
1526 register struct hpuxgetpgrp2_args *uap;
1527 int *retval;
1528 {
1529 register struct proc *p;
1530
1531 if (uap->pid == 0)
1532 uap->pid = cp->p_pid;
1533 p = pfind(uap->pid);
1534 if (p == 0)
1535 return (ESRCH);
1536 if (cp->p_ucred->cr_uid && p->p_ucred->cr_uid != cp->p_ucred->cr_uid &&
1537 !inferior(p))
1538 return (EPERM);
1539 *retval = p->p_pgid;
1540 return (0);
1541 }
1542
1543 /*
1544 * This is the equivalent of BSD setpgrp but with more restrictions.
1545 * Note we do not check the real uid or "saved" uid or pgrp.
1546 */
1547 struct hpuxsetpgrp2_args {
1548 int pid;
1549 int pgrp;
1550 };
1551 hpuxsetpgrp2(p, uap, retval)
1552 struct proc *p;
1553 struct hpuxsetpgrp2_args *uap;
1554 int *retval;
1555 {
1556 /* empirically determined */
1557 if (uap->pgrp < 0 || uap->pgrp >= 30000)
1558 return (EINVAL);
1559 return (setpgid(p, uap, retval));
1560 }
1561
1562 /*
1563 * XXX Same as BSD setre[ug]id right now. Need to consider saved ids.
1564 */
1565 struct hpuxsetresuid_args {
1566 int ruid;
1567 int euid;
1568 int suid;
1569 };
1570 hpuxsetresuid(p, uap, retval)
1571 struct proc *p;
1572 struct hpuxsetresuid_args *uap;
1573 int *retval;
1574 {
1575 return (compat_43_setreuid(p, uap, retval));
1576 }
1577
1578 struct hpuxsetresgid_args {
1579 int rgid;
1580 int egid;
1581 int sgid;
1582 };
1583 hpuxsetresgid(p, uap, retval)
1584 struct proc *p;
1585 struct hpuxsetresgid_args *uap;
1586 int *retval;
1587 {
1588 return (compat_43_setregid(p, uap, retval));
1589 }
1590
1591 struct hpuxrlimit_args {
1592 u_int which;
1593 struct orlimit *rlp;
1594 };
1595 hpuxgetrlimit(p, uap, retval)
1596 struct proc *p;
1597 struct hpuxrlimit_args *uap;
1598 int *retval;
1599 {
1600 if (uap->which > HPUXRLIMIT_NOFILE)
1601 return (EINVAL);
1602 if (uap->which == HPUXRLIMIT_NOFILE)
1603 uap->which = RLIMIT_NOFILE;
1604 return (compat_43_getrlimit(p, uap, retval));
1605 }
1606
1607 hpuxsetrlimit(p, uap, retval)
1608 struct proc *p;
1609 struct hpuxrlimit_args *uap;
1610 int *retval;
1611 {
1612 if (uap->which > HPUXRLIMIT_NOFILE)
1613 return (EINVAL);
1614 if (uap->which == HPUXRLIMIT_NOFILE)
1615 uap->which = RLIMIT_NOFILE;
1616 return (compat_43_setrlimit(p, uap, retval));
1617 }
1618
1619 /*
1620 * XXX: simple recognition hack to see if we can make grmd work.
1621 */
1622 struct hpuxlockf_args {
1623 int fd;
1624 int func;
1625 long size;
1626 };
1627 hpuxlockf(p, uap, retval)
1628 struct proc *p;
1629 struct hpuxlockf_args *uap;
1630 int *retval;
1631 {
1632 return (0);
1633 }
1634
1635 struct hpuxgetaccess_args {
1636 char *path;
1637 int uid;
1638 int ngroups;
1639 int *gidset;
1640 void *label;
1641 void *privs;
1642 };
hpuxgetaccess(p,uap,retval)1643 hpuxgetaccess(p, uap, retval)
1644 register struct proc *p;
1645 register struct hpuxgetaccess_args *uap;
1646 int *retval;
1647 {
1648 int lgroups[NGROUPS];
1649 int error = 0;
1650 register struct ucred *cred;
1651 register struct vnode *vp;
1652 struct nameidata nd;
1653
1654 /*
1655 * Build an appropriate credential structure
1656 */
1657 cred = crdup(p->p_ucred);
1658 switch (uap->uid) {
1659 case 65502: /* UID_EUID */
1660 break;
1661 case 65503: /* UID_RUID */
1662 cred->cr_uid = p->p_cred->p_ruid;
1663 break;
1664 case 65504: /* UID_SUID */
1665 error = EINVAL;
1666 break;
1667 default:
1668 if (uap->uid > 65504)
1669 error = EINVAL;
1670 cred->cr_uid = uap->uid;
1671 break;
1672 }
1673 switch (uap->ngroups) {
1674 case -1: /* NGROUPS_EGID */
1675 cred->cr_ngroups = 1;
1676 break;
1677 case -5: /* NGROUPS_EGID_SUPP */
1678 break;
1679 case -2: /* NGROUPS_RGID */
1680 cred->cr_ngroups = 1;
1681 cred->cr_gid = p->p_cred->p_rgid;
1682 break;
1683 case -6: /* NGROUPS_RGID_SUPP */
1684 cred->cr_gid = p->p_cred->p_rgid;
1685 break;
1686 case -3: /* NGROUPS_SGID */
1687 case -7: /* NGROUPS_SGID_SUPP */
1688 error = EINVAL;
1689 break;
1690 case -4: /* NGROUPS_SUPP */
1691 if (cred->cr_ngroups > 1)
1692 cred->cr_gid = cred->cr_groups[1];
1693 else
1694 error = EINVAL;
1695 break;
1696 default:
1697 if (uap->ngroups > 0 && uap->ngroups <= NGROUPS)
1698 error = copyin((caddr_t)uap->gidset,
1699 (caddr_t)&lgroups[0],
1700 uap->ngroups * sizeof(lgroups[0]));
1701 else
1702 error = EINVAL;
1703 if (error == 0) {
1704 int gid;
1705
1706 for (gid = 0; gid < uap->ngroups; gid++)
1707 cred->cr_groups[gid] = lgroups[gid];
1708 cred->cr_ngroups = uap->ngroups;
1709 }
1710 break;
1711 }
1712 /*
1713 * Lookup file using caller's effective IDs.
1714 */
1715 if (error == 0) {
1716 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE,
1717 uap->path, p);
1718 error = namei(&nd);
1719 }
1720 if (error) {
1721 crfree(cred);
1722 return (error);
1723 }
1724 /*
1725 * Use the constructed credentials for access checks.
1726 */
1727 vp = nd.ni_vp;
1728 *retval = 0;
1729 if (VOP_ACCESS(vp, VREAD, cred, p) == 0)
1730 *retval |= R_OK;
1731 if (vn_writechk(vp) == 0 && VOP_ACCESS(vp, VWRITE, cred, p) == 0)
1732 *retval |= W_OK;
1733 /* XXX we return X_OK for root on VREG even if not */
1734 if (VOP_ACCESS(vp, VEXEC, cred, p) == 0)
1735 *retval |= X_OK;
1736 vput(vp);
1737 crfree(cred);
1738 return (error);
1739 }
1740
1741 extern char kstack[];
1742 #define UOFF(f) ((int)&((struct user *)0)->f)
1743 #define HPUOFF(f) ((int)&((struct hpuxuser *)0)->f)
1744
1745 /* simplified FP structure */
1746 struct bsdfp {
1747 int save[54];
1748 int reg[24];
1749 int ctrl[3];
1750 };
1751
1752 /*
1753 * Brutal hack! Map HP-UX u-area offsets into BSD k-stack offsets.
1754 */
hpuxtobsduoff(off,isps,p)1755 hpuxtobsduoff(off, isps, p)
1756 int *off, *isps;
1757 struct proc *p;
1758 {
1759 register int *ar0 = p->p_md.md_regs;
1760 struct hpuxfp *hp;
1761 struct bsdfp *bp;
1762 register u_int raddr;
1763
1764 *isps = 0;
1765
1766 /* u_ar0 field; procxmt puts in U_ar0 */
1767 if ((int)off == HPUOFF(hpuxu_ar0))
1768 return(UOFF(U_ar0));
1769
1770 #ifdef FPCOPROC
1771 /* FP registers from PCB */
1772 hp = (struct hpuxfp *)HPUOFF(hpuxu_fp);
1773 bp = (struct bsdfp *)UOFF(u_pcb.pcb_fpregs);
1774 if (off >= hp->hpfp_ctrl && off < &hp->hpfp_ctrl[3])
1775 return((int)&bp->ctrl[off - hp->hpfp_ctrl]);
1776 if (off >= hp->hpfp_reg && off < &hp->hpfp_reg[24])
1777 return((int)&bp->reg[off - hp->hpfp_reg]);
1778 #endif
1779
1780 /*
1781 * Everything else we recognize comes from the kernel stack,
1782 * so we convert off to an absolute address (if not already)
1783 * for simplicity.
1784 */
1785 if (off < (int *)ctob(UPAGES))
1786 off = (int *)((u_int)off + (u_int)kstack);
1787
1788 /*
1789 * General registers.
1790 * We know that the HP-UX registers are in the same order as ours.
1791 * The only difference is that their PS is 2 bytes instead of a
1792 * padded 4 like ours throwing the alignment off.
1793 */
1794 if (off >= ar0 && off < &ar0[18]) {
1795 /*
1796 * PS: return low word and high word of PC as HP-UX would
1797 * (e.g. &u.u_ar0[16.5]).
1798 *
1799 * XXX we don't do this since HP-UX adb doesn't rely on
1800 * it and passing such an offset to procxmt will cause
1801 * it to fail anyway. Instead, we just set the offset
1802 * to PS and let hpuxptrace() shift up the value returned.
1803 */
1804 if (off == &ar0[PS]) {
1805 #if 0
1806 raddr = (u_int) &((short *)ar0)[PS*2+1];
1807 #else
1808 raddr = (u_int) &ar0[(int)(off - ar0)];
1809 #endif
1810 *isps = 1;
1811 }
1812 /*
1813 * PC: off will be &u.u_ar0[16.5] since HP-UX saved PS
1814 * is only 16 bits.
1815 */
1816 else if (off == (int *)&(((short *)ar0)[PS*2+1]))
1817 raddr = (u_int) &ar0[PC];
1818 /*
1819 * D0-D7, A0-A7: easy
1820 */
1821 else
1822 raddr = (u_int) &ar0[(int)(off - ar0)];
1823 return((int)(raddr - (u_int)kstack));
1824 }
1825
1826 /* everything else */
1827 return(-1);
1828 }
1829
1830 /*
1831 * Kludge up a uarea dump so that HP-UX debuggers can find out
1832 * what they need. IMPORTANT NOTE: we do not EVEN attempt to
1833 * convert the entire user struct.
1834 */
1835 hpuxdumpu(vp, cred)
1836 struct vnode *vp;
1837 struct ucred *cred;
1838 {
1839 struct proc *p = curproc;
1840 int error;
1841 struct hpuxuser *faku;
1842 struct bsdfp *bp;
1843 short *foop;
1844
1845 faku = (struct hpuxuser *)malloc((u_long)ctob(1), M_TEMP, M_WAITOK);
1846 /*
1847 * Make sure there is no mistake about this
1848 * being a real user structure.
1849 */
1850 bzero((caddr_t)faku, ctob(1));
1851 /*
1852 * Fill in the process sizes.
1853 */
1854 faku->hpuxu_tsize = p->p_vmspace->vm_tsize;
1855 faku->hpuxu_dsize = p->p_vmspace->vm_dsize;
1856 faku->hpuxu_ssize = p->p_vmspace->vm_ssize;
1857 /*
1858 * Fill in the exec header for CDB.
1859 * This was saved back in exec(). As far as I can tell CDB
1860 * only uses this information to verify that a particular
1861 * core file goes with a particular binary.
1862 */
1863 bcopy((caddr_t)p->p_addr->u_md.md_exec,
1864 (caddr_t)&faku->hpuxu_exdata, sizeof (struct hpux_exec));
1865 /*
1866 * Adjust user's saved registers (on kernel stack) to reflect
1867 * HP-UX order. Note that HP-UX saves the SR as 2 bytes not 4
1868 * so we have to move it up.
1869 */
1870 faku->hpuxu_ar0 = p->p_md.md_regs;
1871 foop = (short *) p->p_md.md_regs;
1872 foop[32] = foop[33];
1873 foop[33] = foop[34];
1874 foop[34] = foop[35];
1875 #ifdef FPCOPROC
1876 /*
1877 * Copy 68881 registers from our PCB format to HP-UX format
1878 */
1879 bp = (struct bsdfp *) &p->p_addr->u_pcb.pcb_fpregs;
1880 bcopy((caddr_t)bp->save, (caddr_t)faku->hpuxu_fp.hpfp_save,
1881 sizeof(bp->save));
1882 bcopy((caddr_t)bp->ctrl, (caddr_t)faku->hpuxu_fp.hpfp_ctrl,
1883 sizeof(bp->ctrl));
1884 bcopy((caddr_t)bp->reg, (caddr_t)faku->hpuxu_fp.hpfp_reg,
1885 sizeof(bp->reg));
1886 #endif
1887 /*
1888 * Slay the dragon
1889 */
1890 faku->hpuxu_dragon = -1;
1891 /*
1892 * Dump this artfully constructed page in place of the
1893 * user struct page.
1894 */
1895 error = vn_rdwr(UIO_WRITE, vp, (caddr_t)faku, ctob(1), (off_t)0,
1896 UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred,
1897 (int *)NULL, p);
1898 /*
1899 * Dump the remaining UPAGES-1 pages normally
1900 */
1901 if (!error)
1902 error = vn_rdwr(UIO_WRITE, vp, kstack + ctob(1),
1903 ctob(UPAGES-1), (off_t)ctob(1), UIO_SYSSPACE,
1904 IO_NODELOCKED|IO_UNIT, cred, (int *)NULL, p);
1905 free((caddr_t)faku, M_TEMP);
1906 return(error);
1907 }
1908
1909 /*
1910 * The remaining routines are essentially the same as those in kern_xxx.c
1911 * and vfs_xxx.c as defined under "#ifdef COMPAT". We replicate them here
1912 * to avoid HPUXCOMPAT dependencies in those files and to make sure that
1913 * HP-UX compatibility still works even when COMPAT is not defined.
1914 *
1915 * These are still needed as of HP-UX 7.05.
1916 */
1917 #ifdef COMPAT_OHPUX
1918
1919 #define HPUX_HZ 50
1920
1921 #include "sys/times.h"
1922
1923 /* from old timeb.h */
1924 struct hpuxtimeb {
1925 time_t time;
1926 u_short millitm;
1927 short timezone;
1928 short dstflag;
1929 };
1930
1931 /* ye ole stat structure */
1932 struct ohpuxstat {
1933 u_short ohst_dev;
1934 u_short ohst_ino;
1935 u_short ohst_mode;
1936 short ohst_nlink;
1937 short ohst_uid;
1938 short ohst_gid;
1939 u_short ohst_rdev;
1940 int ohst_size;
1941 int ohst_atime;
1942 int ohst_mtime;
1943 int ohst_ctime;
1944 };
1945
1946 /*
1947 * SYS V style setpgrp()
1948 */
compat_43_hpuxsetpgrp(p,uap,retval)1949 compat_43_hpuxsetpgrp(p, uap, retval)
1950 register struct proc *p;
1951 int *uap, *retval;
1952 {
1953 if (p->p_pid != p->p_pgid)
1954 enterpgrp(p, p->p_pid, 0);
1955 *retval = p->p_pgid;
1956 return (0);
1957 }
1958
1959 struct ohpuxtime_args {
1960 long *tp;
1961 };
1962 compat_43_hpuxtime(p, uap, retval)
1963 struct proc *p;
1964 register struct ohpuxtime_args *uap;
1965 int *retval;
1966 {
1967 int error = 0;
1968
1969 if (uap->tp)
1970 error = copyout((caddr_t)&time.tv_sec, (caddr_t)uap->tp,
1971 sizeof (long));
1972 *(time_t *)retval = time.tv_sec;
1973 return (error);
1974 }
1975
1976 struct ohpuxstime_args {
1977 int time;
1978 };
1979 compat_43_hpuxstime(p, uap, retval)
1980 struct proc *p;
1981 register struct ohpuxstime_args *uap;
1982 int *retval;
1983 {
1984 struct timeval tv;
1985 int s, error;
1986
1987 tv.tv_sec = uap->time;
1988 tv.tv_usec = 0;
1989 if (error = suser(p->p_ucred, &p->p_acflag))
1990 return (error);
1991
1992 /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */
1993 boottime.tv_sec += tv.tv_sec - time.tv_sec;
1994 s = splhigh(); time = tv; splx(s);
1995 resettodr();
1996 return (0);
1997 }
1998
1999 struct ohpuxftime_args {
2000 struct hpuxtimeb *tp;
2001 };
2002 compat_43_hpuxftime(p, uap, retval)
2003 struct proc *p;
2004 register struct ohpuxftime_args *uap;
2005 int *retval;
2006 {
2007 struct hpuxtimeb tb;
2008 int s;
2009
2010 s = splhigh();
2011 tb.time = time.tv_sec;
2012 tb.millitm = time.tv_usec / 1000;
2013 splx(s);
2014 tb.timezone = tz.tz_minuteswest;
2015 tb.dstflag = tz.tz_dsttime;
2016 return (copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb)));
2017 }
2018
2019 struct ohpuxalarm_args {
2020 int deltat;
2021 };
compat_43_hpuxalarm(p,uap,retval)2022 compat_43_hpuxalarm(p, uap, retval)
2023 register struct proc *p;
2024 register struct ohpuxalarm_args *uap;
2025 int *retval;
2026 {
2027 int s = splhigh();
2028
2029 untimeout(realitexpire, (caddr_t)p);
2030 timerclear(&p->p_realtimer.it_interval);
2031 *retval = 0;
2032 if (timerisset(&p->p_realtimer.it_value) &&
2033 timercmp(&p->p_realtimer.it_value, &time, >))
2034 *retval = p->p_realtimer.it_value.tv_sec - time.tv_sec;
2035 if (uap->deltat == 0) {
2036 timerclear(&p->p_realtimer.it_value);
2037 splx(s);
2038 return (0);
2039 }
2040 p->p_realtimer.it_value = time;
2041 p->p_realtimer.it_value.tv_sec += uap->deltat;
2042 timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value));
2043 splx(s);
2044 return (0);
2045 }
2046
2047 struct ohpuxnice_args {
2048 int niceness;
2049 };
compat_43_hpuxnice(p,uap,retval)2050 compat_43_hpuxnice(p, uap, retval)
2051 register struct proc *p;
2052 register struct ohpuxnice_args *uap;
2053 int *retval;
2054 {
2055 int error;
2056
2057 error = donice(p, p, (p->p_nice-NZERO)+uap->niceness);
2058 if (error == 0)
2059 *retval = p->p_nice - NZERO;
2060 return (error);
2061 }
2062
2063 struct ohpuxtimes_args {
2064 struct tms *tmsb;
2065 };
2066 compat_43_hpuxtimes(p, uap, retval)
2067 struct proc *p;
2068 register struct ohpuxtimes_args *uap;
2069 int *retval;
2070 {
2071 struct timeval ru, rs;
2072 struct tms atms;
2073 int error;
2074
2075 calcru(p, &ru, &rs, NULL);
2076 atms.tms_utime = hpuxscale(&ru);
2077 atms.tms_stime = hpuxscale(&rs);
2078 atms.tms_cutime = hpuxscale(&p->p_stats->p_cru.ru_utime);
2079 atms.tms_cstime = hpuxscale(&p->p_stats->p_cru.ru_stime);
2080 error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms));
2081 if (error == 0)
2082 *(time_t *)retval = hpuxscale(&time) - hpuxscale(&boottime);
2083 return (error);
2084 }
2085
2086 /*
2087 * Doesn't exactly do what the documentation says.
2088 * What we really do is return 1/HPUX_HZ-th of a second since that
2089 * is what HP-UX returns.
2090 */
hpuxscale(tvp)2091 hpuxscale(tvp)
2092 register struct timeval *tvp;
2093 {
2094 return (tvp->tv_sec * HPUX_HZ + tvp->tv_usec * HPUX_HZ / 1000000);
2095 }
2096
2097 /*
2098 * Set IUPD and IACC times on file.
2099 * Can't set ICHG.
2100 */
2101 struct ohpuxutime_args {
2102 char *fname;
2103 time_t *tptr;
2104 };
2105 compat_43_hpuxutime(p, uap, retval)
2106 struct proc *p;
2107 register struct ohpuxutime_args *uap;
2108 int *retval;
2109 {
2110 register struct vnode *vp;
2111 struct vattr vattr;
2112 time_t tv[2];
2113 int error;
2114 struct nameidata nd;
2115
2116 if (uap->tptr) {
2117 error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv));
2118 if (error)
2119 return (error);
2120 } else
2121 tv[0] = tv[1] = time.tv_sec;
2122 vattr_null(&vattr);
2123 vattr.va_atime.ts_sec = tv[0];
2124 vattr.va_atime.ts_nsec = 0;
2125 vattr.va_mtime.ts_sec = tv[1];
2126 vattr.va_mtime.ts_nsec = 0;
2127 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
2128 if (error = namei(&nd))
2129 return (error);
2130 vp = nd.ni_vp;
2131 if (vp->v_mount->mnt_flag & MNT_RDONLY)
2132 error = EROFS;
2133 else
2134 error = VOP_SETATTR(vp, &vattr, nd.ni_cnd.cn_cred, p);
2135 vput(vp);
2136 return (error);
2137 }
2138
2139 compat_43_hpuxpause(p, uap, retval)
2140 struct proc *p;
2141 int *uap, *retval;
2142 {
2143 (void) tsleep(kstack, PPAUSE | PCATCH, "pause", 0);
2144 /* always return EINTR rather than ERESTART... */
2145 return (EINTR);
2146 }
2147
2148 /*
2149 * The old fstat system call.
2150 */
2151 struct ohpuxfstat_args {
2152 int fd;
2153 struct ohpuxstat *sb;
2154 };
2155 compat_43_hpuxfstat(p, uap, retval)
2156 struct proc *p;
2157 register struct ohpuxfstat_args *uap;
2158 int *retval;
2159 {
2160 register struct filedesc *fdp = p->p_fd;
2161 struct file *fp;
2162
2163 if (((unsigned)uap->fd) >= fdp->fd_nfiles ||
2164 (fp = fdp->fd_ofiles[uap->fd]) == NULL)
2165 return (EBADF);
2166 if (fp->f_type != DTYPE_VNODE)
2167 return (EINVAL);
2168 return (compat_43_hpuxstat1((struct vnode *)fp->f_data, uap->sb, p));
2169 }
2170
2171 /*
2172 * Old stat system call. This version follows links.
2173 */
2174 struct ohpuxstat_args {
2175 char *fname;
2176 struct ohpuxstat *sb;
2177 };
2178 compat_43_hpuxstat(p, uap, retval)
2179 struct proc *p;
2180 register struct ohpuxstat_args *uap;
2181 int *retval;
2182 {
2183 int error;
2184 struct nameidata nd;
2185
2186 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, uap->fname, p);
2187 if (error = namei(&nd))
2188 return (error);
2189 error = compat_43_hpuxstat1(nd.ni_vp, uap->sb, p);
2190 vput(nd.ni_vp);
2191 return (error);
2192 }
2193
2194 int
compat_43_hpuxstat1(vp,ub,p)2195 compat_43_hpuxstat1(vp, ub, p)
2196 struct vnode *vp;
2197 struct ohpuxstat *ub;
2198 struct proc *p;
2199 {
2200 struct ohpuxstat ohsb;
2201 struct stat sb;
2202 int error;
2203
2204 error = vn_stat(vp, &sb, p);
2205 if (error)
2206 return (error);
2207
2208 ohsb.ohst_dev = sb.st_dev;
2209 ohsb.ohst_ino = sb.st_ino;
2210 ohsb.ohst_mode = sb.st_mode;
2211 ohsb.ohst_nlink = sb.st_nlink;
2212 ohsb.ohst_uid = sb.st_uid;
2213 ohsb.ohst_gid = sb.st_gid;
2214 ohsb.ohst_rdev = sb.st_rdev;
2215 if (sb.st_size < (quad_t)1 << 32)
2216 ohsb.ohst_size = sb.st_size;
2217 else
2218 ohsb.ohst_size = -2;
2219 ohsb.ohst_atime = sb.st_atime;
2220 ohsb.ohst_mtime = sb.st_mtime;
2221 ohsb.ohst_ctime = sb.st_ctime;
2222 return (copyout((caddr_t)&ohsb, (caddr_t)ub, sizeof(ohsb)));
2223 }
2224 #endif
2225 #endif
2226