![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hpux_compat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpux|
Return to hpux_compat.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpux |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 University of Utah. ! 3: * Copyright (c) 1990 The Regents of the University of California. ! 4: * 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: * Redistribution is only permitted until one year after the first shipment ! 11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 12: * binary forms are permitted provided that: (1) source distributions retain ! 13: * this entire copyright notice and comment, and (2) distributions including ! 14: * binaries display the following acknowledgement: This product includes ! 15: * software developed by the University of California, Berkeley and its ! 16: * contributors'' in the documentation or other materials provided with the ! 17: * distribution and in all advertising materials mentioning features or use ! 18: * of this software. Neither the name of the University nor the names of ! 19: * its contributors may be used to endorse or promote products derived from ! 20: * this software without specific prior written permission. ! 21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 24: * ! 25: * from: Utah $Hdr: hpux_compat.c 1.33 89/08/23$ ! 26: * ! 27: * @(#)hpux_compat.c 7.9 (Berkeley) 6/28/90 ! 28: */ ! 29: ! 30: /* ! 31: * Various HPUX compatibility routines ! 32: */ ! 33: ! 34: #ifdef HPUXCOMPAT ! 35: ! 36: #include "param.h" ! 37: #include "systm.h" ! 38: #include "user.h" ! 39: #include "kernel.h" ! 40: #include "proc.h" ! 41: #include "buf.h" ! 42: #include "wait.h" ! 43: #include "file.h" ! 44: #include "vnode.h" ! 45: #include "ioctl.h" ! 46: #include "uio.h" ! 47: #include "ptrace.h" ! 48: #include "stat.h" ! 49: #include "syslog.h" ! 50: #include "malloc.h" ! 51: #include "mount.h" ! 52: #include "ipc.h" ! 53: ! 54: #include "machine/cpu.h" ! 55: #include "machine/reg.h" ! 56: #include "machine/psl.h" ! 57: #include "machine/vmparam.h" ! 58: #include "hpux.h" ! 59: #include "hpux_termio.h" ! 60: ! 61: #ifdef DEBUG ! 62: int unimpresponse = 0; ! 63: #endif ! 64: ! 65: /* "tick" value for HZ==50 */ ! 66: int hpuxtick = 1000000 / 50; ! 67: ! 68: /* SYS5 style UTSNAME info */ ! 69: struct hpuxutsname protoutsname = { ! 70: "4.4bsd", "", "2.0", "B", "9000/3?0", "" ! 71: }; ! 72: ! 73: /* 6.0 and later style context */ ! 74: #ifdef FPCOPROC ! 75: char hpuxcontext[] = ! 76: "standalone HP-MC68881 HP-MC68020 HP-MC68010 localroot default"; ! 77: #else ! 78: char hpuxcontext[] = ! 79: "standalone HP-MC68020 HP-MC68010 localroot default"; ! 80: #endif ! 81: ! 82: /* YP domainname */ ! 83: char domainname[MAXHOSTNAMELEN] = "unknown"; ! 84: int domainnamelen = 7; ! 85: ! 86: #define NERR 79 ! 87: #define BERR 1000 ! 88: ! 89: /* indexed by BSD errno */ ! 90: short bsdtohpuxerrnomap[NERR] = { ! 91: /*00*/ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ! 92: /*10*/ 10, 45, 12, 13, 14, 15, 16, 17, 18, 19, ! 93: /*20*/ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, ! 94: /*30*/ 30, 31, 32, 33, 34, 246, 245, 244, 216, 217, ! 95: /*40*/ 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, ! 96: /*50*/ 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, ! 97: /*60*/ 238, 239, 249, 248, 241, 242, 247,BERR,BERR,BERR, ! 98: /*70*/ 70, 71,BERR,BERR,BERR,BERR,BERR, 46,BERR ! 99: }; ! 100: ! 101: notimp(p, uap, retval, code, nargs) ! 102: struct proc *p; ! 103: int *uap, *retval; ! 104: int code, nargs; ! 105: { ! 106: int error = 0; ! 107: #ifdef DEBUG ! 108: register int *argp = uap; ! 109: extern char *hpuxsyscallnames[]; ! 110: ! 111: printf("HPUX %s(", hpuxsyscallnames[code]); ! 112: if (nargs) ! 113: while (nargs--) ! 114: printf("%x%c", *argp++, nargs? ',' : ')'); ! 115: else ! 116: printf(")"); ! 117: printf("\n"); ! 118: switch (unimpresponse) { ! 119: case 0: ! 120: error = nosys(p, uap, retval); ! 121: break; ! 122: case 1: ! 123: error = EINVAL; ! 124: break; ! 125: } ! 126: #else ! 127: error = nosys(p, uap, retval); ! 128: #endif ! 129: uprintf("HP-UX system call %d not implemented\n", code); ! 130: return (error); ! 131: } ! 132: ! 133: /* ! 134: * HPUX versions of wait and wait3 actually pass the parameters ! 135: * (status pointer, options, rusage) into the kernel rather than ! 136: * handling it in the C library stub. We also need to map any ! 137: * termination signal from BSD to HPUX. ! 138: */ ! 139: hpuxwait3(p, uap, retval) ! 140: struct proc *p; ! 141: struct args { ! 142: int *status; ! 143: int options; ! 144: int rusage; ! 145: } *uap; ! 146: int *retval; ! 147: { ! 148: /* rusage pointer must be zero */ ! 149: if (uap->rusage) ! 150: return (EINVAL); ! 151: u.u_ar0[PS] = PSL_ALLCC; ! 152: u.u_ar0[R0] = uap->options; ! 153: u.u_ar0[R1] = uap->rusage; ! 154: return (hpuxwait(p, uap, retval)); ! 155: } ! 156: ! 157: hpuxwait(p, uap, retval) ! 158: struct proc *p; ! 159: struct args { ! 160: int *status; ! 161: } *uap; ! 162: int *retval; ! 163: { ! 164: int sig, *statp, error; ! 165: ! 166: statp = uap->status; /* owait clobbers first arg */ ! 167: error = owait(p, uap, retval); ! 168: /* ! 169: * HP-UX wait always returns EINTR when interrupted by a signal ! 170: * (well, unless its emulating a BSD process, but we don't bother...) ! 171: */ ! 172: if (error == ERESTART) ! 173: error = EINTR; ! 174: if (error) ! 175: return (error); ! 176: sig = retval[1] & 0xFF; ! 177: if (sig == WSTOPPED) { ! 178: sig = (retval[1] >> 8) & 0xFF; ! 179: retval[1] = (bsdtohpuxsig(sig) << 8) | WSTOPPED; ! 180: } else if (sig) ! 181: retval[1] = (retval[1] & 0xFF00) | ! 182: bsdtohpuxsig(sig & 0x7F) | (sig & 0x80); ! 183: if (statp) ! 184: if (suword((caddr_t)statp, retval[1])) ! 185: error = EFAULT; ! 186: return (error); ! 187: } ! 188: ! 189: hpuxwaitpid(p, uap, retval) ! 190: struct proc *p; ! 191: struct args { ! 192: int pid; ! 193: int *status; ! 194: int options; ! 195: struct rusage *rusage; /* wait4 arg */ ! 196: } *uap; ! 197: int *retval; ! 198: { ! 199: int sig, *statp, error; ! 200: ! 201: uap->rusage = 0; ! 202: error = wait4(p, uap, retval); ! 203: /* ! 204: * HP-UX wait always returns EINTR when interrupted by a signal ! 205: * (well, unless its emulating a BSD process, but we don't bother...) ! 206: */ ! 207: if (error == ERESTART) ! 208: error = EINTR; ! 209: if (error) ! 210: return (error); ! 211: sig = retval[1] & 0xFF; ! 212: if (sig == WSTOPPED) { ! 213: sig = (retval[1] >> 8) & 0xFF; ! 214: retval[1] = (bsdtohpuxsig(sig) << 8) | WSTOPPED; ! 215: } else if (sig) ! 216: retval[1] = (retval[1] & 0xFF00) | ! 217: bsdtohpuxsig(sig & 0x7F) | (sig & 0x80); ! 218: if (statp) ! 219: if (suword((caddr_t)statp, retval[1])) ! 220: error = EFAULT; ! 221: return (error); ! 222: } ! 223: ! 224: /* ! 225: * Must remap some bits in the mode mask. ! 226: * O_CREAT, O_TRUNC, and O_EXCL must be remapped, ! 227: * O_SYNCIO (0100000) is removed entirely. ! 228: */ ! 229: hpuxopen(p, uap, retval) ! 230: struct proc *p; ! 231: register struct args { ! 232: char *fname; ! 233: int mode; ! 234: int crtmode; ! 235: } *uap; ! 236: int *retval; ! 237: { ! 238: int mode; ! 239: ! 240: mode = uap->mode; ! 241: uap->mode &= ~(HPUXFSYNCIO|HPUXFEXCL|HPUXFTRUNC|HPUXFCREAT); ! 242: if (mode & HPUXFCREAT) { ! 243: /* ! 244: * simulate the pre-NFS behavior that opening a ! 245: * file for READ+CREATE ignores the CREATE (unless ! 246: * EXCL is set in which case we will return the ! 247: * proper error). ! 248: */ ! 249: if ((mode & HPUXFEXCL) || ((mode-FOPEN) & FWRITE)) ! 250: uap->mode |= FCREAT; ! 251: } ! 252: if (mode & HPUXFTRUNC) ! 253: uap->mode |= FTRUNC; ! 254: if (mode & HPUXFEXCL) ! 255: uap->mode |= FEXCL; ! 256: return (open(p, uap, retval)); ! 257: } ! 258: ! 259: hpuxfcntl(p, uap, retval) ! 260: struct proc *p; ! 261: register struct args { ! 262: int fdes; ! 263: int cmd; ! 264: int arg; ! 265: } *uap; ! 266: int *retval; ! 267: { ! 268: int mode, error; ! 269: ! 270: switch (uap->cmd) { ! 271: case F_SETFL: ! 272: uap->arg &= ~(HPUXFSYNCIO|HPUXFREMOTE|FUSECACHE); ! 273: break; ! 274: case F_GETFL: ! 275: case F_DUPFD: ! 276: case F_GETFD: ! 277: case F_SETFD: ! 278: break; ! 279: default: ! 280: return (EINVAL); ! 281: } ! 282: error = fcntl(p, uap, retval); ! 283: if (error == 0 && uap->arg == F_GETFL) { ! 284: mode = *retval; ! 285: *retval &= ~(FCREAT|FTRUNC|FEXCL|FUSECACHE); ! 286: if (mode & FCREAT) ! 287: *retval |= HPUXFCREAT; ! 288: if (mode & FTRUNC) ! 289: *retval |= HPUXFTRUNC; ! 290: if (mode & FEXCL) ! 291: *retval |= HPUXFEXCL; ! 292: } ! 293: return (error); ! 294: } ! 295: ! 296: /* ! 297: * Read and write should return a 0 count when an operation ! 298: * on a VNODE would block, not an error. Sockets appear to ! 299: * return EWOULDBLOCK (at least in 6.2). This is probably ! 300: * not entirely correct, since the behavior is only defined ! 301: * for pipes and tty type devices. ! 302: */ ! 303: hpuxread(p, uap, retval) ! 304: struct proc *p; ! 305: struct args { ! 306: int fd; ! 307: } *uap; ! 308: int *retval; ! 309: { ! 310: int error; ! 311: ! 312: error = read(p, uap, retval); ! 313: if (error == EWOULDBLOCK && ! 314: u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) { ! 315: error = 0; ! 316: *retval = 0; ! 317: } ! 318: return (error); ! 319: } ! 320: ! 321: hpuxwrite(p, uap, retval) ! 322: struct proc *p; ! 323: struct args { ! 324: int fd; ! 325: } *uap; ! 326: int *retval; ! 327: { ! 328: int error; ! 329: ! 330: error = write(p, uap, retval); ! 331: if (error == EWOULDBLOCK && ! 332: u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) { ! 333: error = 0; ! 334: *retval = 0; ! 335: } ! 336: return (error); ! 337: } ! 338: ! 339: hpuxreadv(p, uap, retval) ! 340: struct proc *p; ! 341: struct args { ! 342: int fd; ! 343: } *uap; ! 344: int *retval; ! 345: { ! 346: int error; ! 347: ! 348: error = readv(p, uap, retval); ! 349: if (error == EWOULDBLOCK && ! 350: u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) { ! 351: error = 0; ! 352: *retval = 0; ! 353: } ! 354: return (error); ! 355: } ! 356: ! 357: hpuxwritev(p, uap, retval) ! 358: struct proc *p; ! 359: struct args { ! 360: int fd; ! 361: } *uap; ! 362: int *retval; ! 363: { ! 364: int error; ! 365: ! 366: error = writev(p, uap, retval); ! 367: if (error == EWOULDBLOCK && ! 368: u.u_ofile[uap->fd]->f_type == DTYPE_VNODE) { ! 369: error = 0; ! 370: *retval = 0; ! 371: } ! 372: return (error); ! 373: } ! 374: ! 375: /* ! 376: * 4.3bsd dup allows dup2 to come in on the same syscall entry ! 377: * and hence allows two arguments. HPUX dup has only one arg. ! 378: */ ! 379: hpuxdup(p, uap, retval) ! 380: struct proc *p; ! 381: register struct args { ! 382: int i; ! 383: } *uap; ! 384: int *retval; ! 385: { ! 386: struct file *fp; ! 387: int fd, error; ! 388: ! 389: if ((unsigned)uap->i >= NOFILE || (fp = u.u_ofile[uap->i]) == NULL) ! 390: return (EBADF); ! 391: if (error = ufalloc(0, &fd)) ! 392: return (error); ! 393: *retval = fd; ! 394: u.u_ofile[fd] = fp; ! 395: u.u_pofile[fd] = u.u_pofile[uap->i] &~ UF_EXCLOSE; ! 396: fp->f_count++; ! 397: if (fd > u.u_lastfile) ! 398: u.u_lastfile = fd; ! 399: return (0); ! 400: } ! 401: ! 402: hpuxuname(p, uap, retval) ! 403: struct proc *p; ! 404: register struct args { ! 405: struct hpuxutsname *uts; ! 406: int dev; ! 407: int request; ! 408: } *uap; ! 409: int *retval; ! 410: { ! 411: register int i; ! 412: int error; ! 413: ! 414: switch (uap->request) { ! 415: /* uname */ ! 416: case 0: ! 417: /* fill in machine type */ ! 418: switch (machineid) { ! 419: case HP_320: ! 420: protoutsname.machine[6] = '2'; ! 421: break; ! 422: /* includes 318 and 319 */ ! 423: case HP_330: ! 424: protoutsname.machine[6] = '3'; ! 425: break; ! 426: case HP_340: ! 427: protoutsname.machine[6] = '4'; ! 428: break; ! 429: case HP_350: ! 430: protoutsname.machine[6] = '5'; ! 431: break; ! 432: case HP_360: ! 433: protoutsname.machine[6] = '6'; ! 434: break; ! 435: case HP_370: ! 436: protoutsname.machine[6] = '7'; ! 437: break; ! 438: /* includes 345 */ ! 439: case HP_375: ! 440: protoutsname.machine[6] = '7'; ! 441: protoutsname.machine[7] = '5'; ! 442: break; ! 443: } ! 444: /* copy hostname (sans domain) to nodename */ ! 445: for (i = 0; i < 9 && hostname[i] != '.'; i++) ! 446: protoutsname.nodename[i] = hostname[i]; ! 447: error = copyout((caddr_t)&protoutsname, (caddr_t)uap->uts, ! 448: sizeof(struct hpuxutsname)); ! 449: break; ! 450: /* ustat - who cares? */ ! 451: case 2: ! 452: default: ! 453: error = EINVAL; ! 454: break; ! 455: } ! 456: return (error); ! 457: } ! 458: ! 459: hpuxstat(p, uap, retval) ! 460: struct proc *p; ! 461: struct args { ! 462: char *fname; ! 463: struct hpuxstat *hsb; ! 464: } *uap; ! 465: int *retval; ! 466: { ! 467: return (hpuxstat1(uap->fname, uap->hsb, FOLLOW)); ! 468: } ! 469: ! 470: hpuxlstat(p, uap, retval) ! 471: struct proc *p; ! 472: struct args { ! 473: char *fname; ! 474: struct hpuxstat *hsb; ! 475: } *uap; ! 476: int *retval; ! 477: { ! 478: return (hpuxstat1(uap->fname, uap->hsb, NOFOLLOW)); ! 479: } ! 480: ! 481: hpuxfstat(p, uap, retval) ! 482: struct proc *p; ! 483: register struct args { ! 484: int fdes; ! 485: struct hpuxstat *hsb; ! 486: } *uap; ! 487: int *retval; ! 488: { ! 489: register struct file *fp; ! 490: struct stat sb; ! 491: int error; ! 492: ! 493: if ((unsigned)uap->fdes >= NOFILE || ! 494: (fp = u.u_ofile[uap->fdes]) == NULL) ! 495: return (EBADF); ! 496: ! 497: switch (fp->f_type) { ! 498: ! 499: case DTYPE_VNODE: ! 500: error = vn_stat((struct vnode *)fp->f_data, &sb); ! 501: break; ! 502: ! 503: case DTYPE_SOCKET: ! 504: error = soo_stat((struct socket *)fp->f_data, &sb); ! 505: break; ! 506: ! 507: default: ! 508: panic("fstat"); ! 509: /*NOTREACHED*/ ! 510: } ! 511: /* is this right for sockets?? */ ! 512: if (error == 0) ! 513: error = bsdtohpuxstat(&sb, uap->hsb); ! 514: return (error); ! 515: } ! 516: ! 517: hpuxulimit(p, uap, retval) ! 518: struct proc *p; ! 519: register struct args { ! 520: int cmd; ! 521: long newlimit; ! 522: } *uap; ! 523: off_t *retval; ! 524: { ! 525: struct rlimit *limp; ! 526: int error = 0; ! 527: ! 528: limp = &u.u_rlimit[RLIMIT_FSIZE]; ! 529: switch (uap->cmd) { ! 530: case 2: ! 531: uap->newlimit *= 512; ! 532: if (uap->newlimit > limp->rlim_max && ! 533: (error = suser(u.u_cred, &u.u_acflag))) ! 534: break; ! 535: limp->rlim_cur = limp->rlim_max = uap->newlimit; ! 536: /* else fall into... */ ! 537: ! 538: case 1: ! 539: *retval = limp->rlim_max / 512; /* XXX */ ! 540: break; ! 541: ! 542: case 3: ! 543: limp = &u.u_rlimit[RLIMIT_DATA]; ! 544: *retval = ctob(u.u_tsize) + limp->rlim_max; /* XXX */ ! 545: break; ! 546: ! 547: default: ! 548: error = EINVAL; ! 549: break; ! 550: } ! 551: return (error); ! 552: } ! 553: ! 554: /* ! 555: * Map "real time" priorities 0 (high) thru 127 (low) into nice ! 556: * values -16 (high) thru -1 (low). ! 557: */ ! 558: hpuxrtprio(cp, uap, retval) ! 559: struct proc *cp; ! 560: register struct args { ! 561: int pid; ! 562: int prio; ! 563: } *uap; ! 564: int *retval; ! 565: { ! 566: struct proc *p; ! 567: int nice, error; ! 568: ! 569: if (uap->prio < RTPRIO_MIN && uap->prio > RTPRIO_MAX && ! 570: uap->prio != RTPRIO_NOCHG && uap->prio != RTPRIO_RTOFF) ! 571: return (EINVAL); ! 572: if (uap->pid == 0) ! 573: p = cp; ! 574: else if ((p = pfind(uap->pid)) == 0) ! 575: return (ESRCH); ! 576: nice = p->p_nice; ! 577: if (nice < NZERO) ! 578: *retval = (nice + 16) << 3; ! 579: else ! 580: *retval = RTPRIO_RTOFF; ! 581: switch (uap->prio) { ! 582: ! 583: case RTPRIO_NOCHG: ! 584: return (0); ! 585: ! 586: case RTPRIO_RTOFF: ! 587: if (nice >= NZERO) ! 588: return (0); ! 589: nice = NZERO; ! 590: break; ! 591: ! 592: default: ! 593: nice = (uap->prio >> 3) - 16; ! 594: break; ! 595: } ! 596: error = donice(cp, p, nice); ! 597: if (error == EACCES) ! 598: error = EPERM; ! 599: return (error); ! 600: } ! 601: ! 602: hpuxadvise(p, uap, retval) ! 603: struct proc *p; ! 604: struct args { ! 605: int arg; ! 606: } *uap; ! 607: int *retval; ! 608: { ! 609: int error = 0; ! 610: ! 611: switch (uap->arg) { ! 612: case 0: ! 613: u.u_pcb.pcb_flags |= PCB_HPUXMMAP; ! 614: break; ! 615: case 1: ! 616: ICIA(); ! 617: break; ! 618: case 2: ! 619: DCIA(); ! 620: break; ! 621: default: ! 622: error = EINVAL; ! 623: break; ! 624: } ! 625: return (error); ! 626: } ! 627: ! 628: hpuxptrace(p, uap, retval) ! 629: struct proc *p; ! 630: struct args { ! 631: int req; ! 632: int pid; ! 633: int *addr; ! 634: int data; ! 635: } *uap; ! 636: int *retval; ! 637: { ! 638: int error; ! 639: ! 640: if (uap->req == PT_STEP || uap->req == PT_CONTINUE) { ! 641: if (uap->data) { ! 642: uap->data = hpuxtobsdsig(uap->data); ! 643: if (uap->data == 0) ! 644: uap->data = NSIG; ! 645: } ! 646: } ! 647: error = ptrace(p, uap, retval); ! 648: return (error); ! 649: } ! 650: ! 651: hpuxgetdomainname(p, uap, retval) ! 652: struct proc *p; ! 653: register struct args { ! 654: char *domainname; ! 655: u_int len; ! 656: } *uap; ! 657: int *retval; ! 658: { ! 659: if (uap->len > domainnamelen + 1) ! 660: uap->len = domainnamelen + 1; ! 661: return (copyout(domainname, uap->domainname, uap->len)); ! 662: } ! 663: ! 664: hpuxsetdomainname(p, uap, retval) ! 665: struct proc *p; ! 666: register struct args { ! 667: char *domainname; ! 668: u_int len; ! 669: } *uap; ! 670: int *retval; ! 671: { ! 672: int error; ! 673: ! 674: if (error = suser(u.u_cred, &u.u_acflag)) ! 675: return (error); ! 676: if (uap->len > sizeof (domainname) - 1) ! 677: return (EINVAL); ! 678: domainnamelen = uap->len; ! 679: error = copyin(uap->domainname, domainname, uap->len); ! 680: domainname[domainnamelen] = 0; ! 681: return (error); ! 682: } ! 683: ! 684: #ifdef SYSVSHM ! 685: hpuxshmat(p, uap, retval) ! 686: struct proc *p; ! 687: int *uap, *retval; ! 688: { ! 689: return (shmat(p, uap, retval)); ! 690: } ! 691: ! 692: hpuxshmctl(p, uap, retval) ! 693: struct proc *p; ! 694: int *uap, *retval; ! 695: { ! 696: return (shmctl(p, uap, retval)); ! 697: } ! 698: ! 699: hpuxshmdt(p, uap, retval) ! 700: struct proc *p; ! 701: int *uap, *retval; ! 702: { ! 703: return (shmdt(p, uap, retval)); ! 704: } ! 705: ! 706: hpuxshmget(p, uap, retval) ! 707: struct proc *p; ! 708: int *uap, *retval; ! 709: { ! 710: return (shmget(p, uap, retval)); ! 711: } ! 712: #endif ! 713: ! 714: /* ! 715: * Fake semaphore routines, just don't return an error. ! 716: * Should be adequate for starbase to run. ! 717: */ ! 718: hpuxsemctl(p, uap, retval) ! 719: struct proc *p; ! 720: struct args { ! 721: int semid; ! 722: u_int semnum; ! 723: int cmd; ! 724: int arg; ! 725: } *uap; ! 726: int *retval; ! 727: { ! 728: /* XXX: should do something here */ ! 729: return (0); ! 730: } ! 731: ! 732: hpuxsemget(p, uap, retval) ! 733: struct proc *p; ! 734: struct args { ! 735: key_t key; ! 736: int nsems; ! 737: int semflg; ! 738: } *uap; ! 739: int *retval; ! 740: { ! 741: /* XXX: should do something here */ ! 742: return (0); ! 743: } ! 744: ! 745: hpuxsemop(p, uap, retval) ! 746: struct proc *p; ! 747: struct args { ! 748: int semid; ! 749: struct sembuf *sops; ! 750: u_int nsops; ! 751: } *uap; ! 752: int *retval; ! 753: { ! 754: /* XXX: should do something here */ ! 755: return (0); ! 756: } ! 757: ! 758: /* convert from BSD to HPUX errno */ ! 759: bsdtohpuxerrno(err) ! 760: int err; ! 761: { ! 762: if (err < 0 || err >= NERR) ! 763: return(BERR); ! 764: return((int)bsdtohpuxerrnomap[err]); ! 765: } ! 766: ! 767: hpuxstat1(fname, hsb, follow) ! 768: char *fname; ! 769: struct hpuxstat *hsb; ! 770: int follow; ! 771: { ! 772: register struct nameidata *ndp = &u.u_nd; ! 773: struct stat sb; ! 774: int error; ! 775: ! 776: ndp->ni_nameiop = LOOKUP | LOCKLEAF | follow; ! 777: ndp->ni_segflg = UIO_USERSPACE; ! 778: ndp->ni_dirp = fname; ! 779: if (error = namei(ndp)) ! 780: return (error); ! 781: error = vn_stat(ndp->ni_vp, &sb); ! 782: vput(ndp->ni_vp); ! 783: if (error == 0) ! 784: error = bsdtohpuxstat(&sb, hsb); ! 785: return (error); ! 786: } ! 787: ! 788: #include "grf.h" ! 789: ! 790: bsdtohpuxstat(sb, hsb) ! 791: struct stat *sb; ! 792: struct hpuxstat *hsb; ! 793: { ! 794: struct hpuxstat ds; ! 795: ! 796: bzero((caddr_t)&ds, sizeof(ds)); ! 797: ds.hst_dev = sb->st_dev; ! 798: ds.hst_ino = (u_long)sb->st_ino; ! 799: ds.hst_mode = sb->st_mode; ! 800: ds.hst_nlink = sb->st_nlink; ! 801: ds.hst_uid = (u_short)sb->st_uid; ! 802: ds.hst_gid = (u_short)sb->st_gid; ! 803: #if NGRF > 0 ! 804: /* XXX: I don't want to talk about it... */ ! 805: if ((sb->st_mode & S_IFMT) == S_IFCHR && major(sb->st_rdev) == 10) ! 806: ds.hst_rdev = grfdevno(sb->st_rdev); ! 807: else ! 808: #endif ! 809: ds.hst_rdev = bsdtohpuxdev(sb->st_rdev); ! 810: ds.hst_size = sb->st_size; ! 811: ds.hst_atime = sb->st_atime; ! 812: ds.hst_mtime = sb->st_mtime; ! 813: ds.hst_ctime = sb->st_ctime; ! 814: ds.hst_blksize = sb->st_blksize; ! 815: ds.hst_blocks = sb->st_blocks; ! 816: return(copyout((caddr_t)&ds, (caddr_t)hsb, sizeof(ds))); ! 817: } ! 818: ! 819: hpuxtobsdioctl(com) ! 820: int com; ! 821: { ! 822: switch (com) { ! 823: case HPUXTIOCSLTC: ! 824: com = TIOCSLTC; break; ! 825: case HPUXTIOCGLTC: ! 826: com = TIOCGLTC; break; ! 827: case HPUXTIOCSPGRP: ! 828: com = TIOCSPGRP; break; ! 829: case HPUXTIOCGPGRP: ! 830: com = TIOCGPGRP; break; ! 831: case HPUXTIOCLBIS: ! 832: com = TIOCLBIS; break; ! 833: case HPUXTIOCLBIC: ! 834: com = TIOCLBIC; break; ! 835: case HPUXTIOCLSET: ! 836: com = TIOCLSET; break; ! 837: case HPUXTIOCLGET: ! 838: com = TIOCLGET; break; ! 839: } ! 840: return(com); ! 841: } ! 842: ! 843: /* ! 844: * HPUX ioctl system call. The differences here are: ! 845: * IOC_IN also means IOC_VOID if the size portion is zero. ! 846: * no FIOCLEX/FIONCLEX/FIONBIO/FIOASYNC/FIOGETOWN/FIOSETOWN ! 847: * the sgttyb struct is 2 bytes longer ! 848: */ ! 849: hpuxioctl(p, uap, retval) ! 850: struct proc *p; ! 851: register struct args { ! 852: int fdes; ! 853: int cmd; ! 854: caddr_t cmarg; ! 855: } *uap; ! 856: int *retval; ! 857: { ! 858: register struct file *fp; ! 859: register int com, error; ! 860: register u_int size; ! 861: caddr_t memp = 0; ! 862: #define STK_PARAMS 128 ! 863: char stkbuf[STK_PARAMS]; ! 864: caddr_t data = stkbuf; ! 865: ! 866: com = uap->cmd; ! 867: ! 868: /* XXX */ ! 869: if (com == HPUXTIOCGETP || com == HPUXTIOCSETP) ! 870: return (getsettty(uap->fdes, com, uap->cmarg)); ! 871: ! 872: if ((unsigned)uap->fdes >= NOFILE || ! 873: (fp = u.u_ofile[uap->fdes]) == NULL) ! 874: return (EBADF); ! 875: if ((fp->f_flag & (FREAD|FWRITE)) == 0) ! 876: return (EBADF); ! 877: ! 878: /* ! 879: * Interpret high order word to find ! 880: * amount of data to be copied to/from the ! 881: * user's address space. ! 882: */ ! 883: size = IOCPARM_LEN(com); ! 884: if (size > IOCPARM_MAX) ! 885: return (ENOTTY); ! 886: if (size > sizeof (stkbuf)) { ! 887: memp = (caddr_t)malloc((u_long)size, M_IOCTLOPS, M_WAITOK); ! 888: data = memp; ! 889: } ! 890: if (com&IOC_IN) { ! 891: if (size) { ! 892: error = copyin(uap->cmarg, data, (u_int)size); ! 893: if (error) { ! 894: if (memp) ! 895: free(memp, M_IOCTLOPS); ! 896: return (error); ! 897: } ! 898: } else ! 899: *(caddr_t *)data = uap->cmarg; ! 900: } else if ((com&IOC_OUT) && size) ! 901: /* ! 902: * Zero the buffer so the user always ! 903: * gets back something deterministic. ! 904: */ ! 905: bzero(data, size); ! 906: else if (com&IOC_VOID) ! 907: *(caddr_t *)data = uap->cmarg; ! 908: ! 909: switch (com) { ! 910: ! 911: case HPUXTIOCCONS: ! 912: *(int *)data = 1; ! 913: error = (*fp->f_ops->fo_ioctl)(fp, TIOCCONS, data); ! 914: break; ! 915: ! 916: /* BSD-style job control ioctls */ ! 917: case HPUXTIOCLBIS: ! 918: case HPUXTIOCLBIC: ! 919: case HPUXTIOCLSET: ! 920: *(int *)data &= HPUXLTOSTOP; ! 921: if (*(int *)data & HPUXLTOSTOP) ! 922: *(int *)data = LTOSTOP; ! 923: /* fall into */ ! 924: case HPUXTIOCLGET: ! 925: case HPUXTIOCSLTC: ! 926: case HPUXTIOCGLTC: ! 927: case HPUXTIOCSPGRP: ! 928: case HPUXTIOCGPGRP: ! 929: error = (*fp->f_ops->fo_ioctl)(fp, hpuxtobsdioctl(com), data); ! 930: if (error == 0 && com == HPUXTIOCLGET) { ! 931: *(int *)data &= LTOSTOP; ! 932: if (*(int *)data & LTOSTOP) ! 933: *(int *)data = HPUXLTOSTOP; ! 934: } ! 935: break; ! 936: ! 937: /* SYS 5 termio */ ! 938: case HPUXTCGETA: ! 939: case HPUXTCSETA: ! 940: case HPUXTCSETAW: ! 941: case HPUXTCSETAF: ! 942: error = hpuxtermio(fp, com, data); ! 943: break; ! 944: ! 945: default: ! 946: error = (*fp->f_ops->fo_ioctl)(fp, com, data); ! 947: break; ! 948: } ! 949: /* ! 950: * Copy any data to user, size was ! 951: * already set and checked above. ! 952: */ ! 953: if (error == 0 && (com&IOC_OUT) && size) ! 954: error = copyout(data, uap->cmarg, (u_int)size); ! 955: if (memp) ! 956: free(memp, M_IOCTLOPS); ! 957: return (error); ! 958: } ! 959: ! 960: /* ! 961: * Man page lies, behaviour here is based on observed behaviour. ! 962: */ ! 963: hpuxgetcontext(p, uap, retval) ! 964: struct proc *p; ! 965: struct args { ! 966: char *buf; ! 967: int len; ! 968: } *uap; ! 969: int *retval; ! 970: { ! 971: int error = 0; ! 972: register int len; ! 973: ! 974: len = MIN(uap->len, sizeof(hpuxcontext)); ! 975: if (len) ! 976: error = copyout(hpuxcontext, uap->buf, (u_int)len); ! 977: if (error == 0) ! 978: *retval = sizeof(hpuxcontext); ! 979: return (error); ! 980: } ! 981: ! 982: /* ! 983: * XXX: simple recognition hack to see if we can make grmd work. ! 984: */ ! 985: hpuxlockf(p, uap, retval) ! 986: struct proc *p; ! 987: struct args { ! 988: int fd; ! 989: int func; ! 990: long size; ! 991: } *uap; ! 992: int *retval; ! 993: { ! 994: #ifdef DEBUG ! 995: log(LOG_DEBUG, "%d: lockf(%d, %d, %d)\n", ! 996: p->p_pid, uap->fd, uap->func, uap->size); ! 997: #endif ! 998: return (0); ! 999: } ! 1000: ! 1001: /* ! 1002: * This is the equivalent of BSD getpgrp but with more restrictions. ! 1003: * Note we do not check the real uid or "saved" uid. ! 1004: */ ! 1005: hpuxgetpgrp2(cp, uap, retval) ! 1006: struct proc *cp; ! 1007: register struct args { ! 1008: int pid; ! 1009: } *uap; ! 1010: int *retval; ! 1011: { ! 1012: register struct proc *p; ! 1013: ! 1014: if (uap->pid == 0) ! 1015: uap->pid = cp->p_pid; ! 1016: p = pfind(uap->pid); ! 1017: if (p == 0) ! 1018: return (ESRCH); ! 1019: if (u.u_uid && p->p_uid != u.u_uid && !inferior(p)) ! 1020: return (EPERM); ! 1021: *retval = p->p_pgid; ! 1022: return (0); ! 1023: } ! 1024: ! 1025: /* ! 1026: * This is the equivalent of BSD setpgrp but with more restrictions. ! 1027: * Note we do not check the real uid or "saved" uid or pgrp. ! 1028: */ ! 1029: hpuxsetpgrp2(p, uap, retval) ! 1030: struct proc *p; ! 1031: struct args { ! 1032: int pid; ! 1033: int pgrp; ! 1034: } *uap; ! 1035: int *retval; ! 1036: { ! 1037: /* empirically determined */ ! 1038: if (uap->pgrp < 0 || uap->pgrp >= 30000) ! 1039: return (EINVAL); ! 1040: return (setpgrp(p, uap, retval)); ! 1041: } ! 1042: ! 1043: /* ! 1044: * Brutal hack! Map HPUX u-area offsets into BSD u offsets. ! 1045: * No apologies offered, if you don't like it, rewrite it! ! 1046: */ ! 1047: ! 1048: #define UOFF(f) ((int)&((struct user *)0)->f) ! 1049: #define HPUOFF(f) ((int)&((struct hpuxuser *)0)->f) ! 1050: ! 1051: /* simplified FP structure */ ! 1052: struct bsdfp { ! 1053: int save[54]; ! 1054: int reg[24]; ! 1055: int ctrl[3]; ! 1056: }; ! 1057: ! 1058: hpuxtobsduoff(off) ! 1059: int *off; ! 1060: { ! 1061: struct hpuxfp *hp; ! 1062: struct bsdfp *bp; ! 1063: register u_int raddr; ! 1064: ! 1065: /* u_ar0 field */ ! 1066: if ((int)off == HPUOFF(hpuxu_ar0)) ! 1067: return(UOFF(u_ar0)); ! 1068: ! 1069: #ifdef FPCOPROC ! 1070: /* 68881 registers from PCB */ ! 1071: hp = (struct hpuxfp *)HPUOFF(hpuxu_fp); ! 1072: bp = (struct bsdfp *)UOFF(u_pcb.pcb_fpregs); ! 1073: if (off >= hp->hpfp_ctrl && off < &hp->hpfp_ctrl[3]) ! 1074: return((int)&bp->ctrl[off - hp->hpfp_ctrl]); ! 1075: if (off >= hp->hpfp_reg && off < &hp->hpfp_reg[24]) ! 1076: return((int)&bp->reg[off - hp->hpfp_reg]); ! 1077: #endif ! 1078: ! 1079: /* ! 1080: * Everything else we recognize comes from the kernel stack, ! 1081: * so we convert off to an absolute address (if not already) ! 1082: * for simplicity. ! 1083: */ ! 1084: if (off < (int *)ctob(UPAGES)) ! 1085: off = (int *)((u_int)off + (u_int)&u); ! 1086: ! 1087: /* ! 1088: * 68020 registers. ! 1089: * We know that the HPUX registers are in the same order as ours. ! 1090: * The only difference is that their PS is 2 bytes instead of a ! 1091: * padded 4 like ours throwing the alignment off. ! 1092: */ ! 1093: if (off >= u.u_ar0 && off < &u.u_ar0[18]) { ! 1094: /* ! 1095: * PS: return low word and high word of PC as HP-UX would ! 1096: * (e.g. &u.u_ar0[16.5]). ! 1097: */ ! 1098: if (off == &u.u_ar0[PS]) ! 1099: raddr = (u_int) &((short *)u.u_ar0)[PS*2+1]; ! 1100: /* ! 1101: * PC: off will be &u.u_ar0[16.5] ! 1102: */ ! 1103: else if (off == (int *)&(((short *)u.u_ar0)[PS*2+1])) ! 1104: raddr = (u_int) &u.u_ar0[PC]; ! 1105: /* ! 1106: * D0-D7, A0-A7: easy ! 1107: */ ! 1108: else ! 1109: raddr = (u_int) &u.u_ar0[(int)(off - u.u_ar0)]; ! 1110: return((int)(raddr - (u_int)&u)); ! 1111: } ! 1112: ! 1113: /* everything else */ ! 1114: return(-1); ! 1115: } ! 1116: ! 1117: /* ! 1118: * Kludge up a uarea dump so that HPUX debuggers can find out ! 1119: * what they need. IMPORTANT NOTE: we do not EVEN attempt to ! 1120: * convert the entire user struct. ! 1121: */ ! 1122: hpuxdumpu(vp, cred) ! 1123: struct vnode *vp; ! 1124: struct ucred *cred; ! 1125: { ! 1126: int error; ! 1127: struct hpuxuser *faku; ! 1128: struct bsdfp *bp; ! 1129: short *foop; ! 1130: ! 1131: faku = (struct hpuxuser *)malloc((u_long)ctob(1), M_TEMP, M_WAITOK); ! 1132: /* ! 1133: * Make sure there is no mistake about this ! 1134: * being a real user structure. ! 1135: */ ! 1136: bzero((caddr_t)faku, ctob(1)); ! 1137: /* ! 1138: * Fill in the process sizes. ! 1139: */ ! 1140: faku->hpuxu_tsize = u.u_tsize; ! 1141: faku->hpuxu_dsize = u.u_dsize; ! 1142: faku->hpuxu_ssize = u.u_ssize; ! 1143: /* ! 1144: * Fill in the exec header for CDB. ! 1145: * This was saved back in exec(). As far as I can tell CDB ! 1146: * only uses this information to verify that a particular ! 1147: * core file goes with a particular binary. ! 1148: */ ! 1149: bcopy((caddr_t)u.u_pcb.pcb_exec, ! 1150: (caddr_t)&faku->hpuxu_exdata, sizeof (struct hpux_exec)); ! 1151: /* ! 1152: * Adjust user's saved registers (on kernel stack) to reflect ! 1153: * HPUX order. Note that HPUX saves the SR as 2 bytes not 4 ! 1154: * so we have to move it up. ! 1155: */ ! 1156: faku->hpuxu_ar0 = u.u_ar0; ! 1157: foop = (short *) u.u_ar0; ! 1158: foop[32] = foop[33]; ! 1159: foop[33] = foop[34]; ! 1160: foop[34] = foop[35]; ! 1161: #ifdef FPCOPROC ! 1162: /* ! 1163: * Copy 68881 registers from our PCB format to HPUX format ! 1164: */ ! 1165: bp = (struct bsdfp *) &u.u_pcb.pcb_fpregs; ! 1166: bcopy((caddr_t)bp->save, (caddr_t)faku->hpuxu_fp.hpfp_save, ! 1167: sizeof(bp->save)); ! 1168: bcopy((caddr_t)bp->ctrl, (caddr_t)faku->hpuxu_fp.hpfp_ctrl, ! 1169: sizeof(bp->ctrl)); ! 1170: bcopy((caddr_t)bp->reg, (caddr_t)faku->hpuxu_fp.hpfp_reg, ! 1171: sizeof(bp->reg)); ! 1172: #endif ! 1173: /* ! 1174: * Slay the dragon ! 1175: */ ! 1176: faku->hpuxu_dragon = -1; ! 1177: /* ! 1178: * Dump this artfully constructed page in place of the ! 1179: * user struct page. ! 1180: */ ! 1181: error = vn_rdwr(UIO_WRITE, vp, ! 1182: (caddr_t)faku, ctob(1), (off_t)0, ! 1183: UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *)0); ! 1184: /* ! 1185: * Dump the remaining UPAGES-1 pages normally ! 1186: */ ! 1187: if (!error) ! 1188: error = vn_rdwr(UIO_WRITE, vp, ((caddr_t)&u)+ctob(1), ! 1189: ctob(UPAGES-1), (off_t)ctob(1), UIO_SYSSPACE, ! 1190: IO_NODELOCKED|IO_UNIT, cred, (int *)0); ! 1191: free((caddr_t)faku, M_TEMP); ! 1192: return(error); ! 1193: } ! 1194: ! 1195: /* ! 1196: * The remaining routines are essentially the same as those in kern_xxx.c ! 1197: * and vfs_xxx.c as defined under "#ifdef COMPAT". We replicate them here ! 1198: * to avoid HPUXCOMPAT dependencies in those files and to make sure that ! 1199: * HP-UX compatibility still works even when COMPAT is not defined. ! 1200: */ ! 1201: /* #ifdef COMPAT */ ! 1202: ! 1203: #include "../sys/times.h" ! 1204: ! 1205: /* from old timeb.h */ ! 1206: struct hpuxtimeb { ! 1207: time_t time; ! 1208: u_short millitm; ! 1209: short timezone; ! 1210: short dstflag; ! 1211: }; ! 1212: ! 1213: /* ye ole stat structure */ ! 1214: struct ohpuxstat { ! 1215: dev_t ohst_dev; ! 1216: u_short ohst_ino; ! 1217: u_short ohst_mode; ! 1218: short ohst_nlink; ! 1219: short ohst_uid; ! 1220: short ohst_gid; ! 1221: dev_t ohst_rdev; ! 1222: int ohst_size; ! 1223: int ohst_atime; ! 1224: int ohst_mtime; ! 1225: int ohst_ctime; ! 1226: }; ! 1227: ! 1228: /* ! 1229: * SYS V style setpgrp() ! 1230: */ ! 1231: ohpuxsetpgrp(p, uap, retval) ! 1232: register struct proc *p; ! 1233: int *uap, *retval; ! 1234: { ! 1235: if (p->p_pid != p->p_pgid) ! 1236: pgmv(p, p->p_pid, 0); ! 1237: *retval = p->p_pgid; ! 1238: } ! 1239: ! 1240: ohpuxtime(p, uap, retval) ! 1241: struct proc *p; ! 1242: register struct args { ! 1243: long *tp; ! 1244: } *uap; ! 1245: time_t *retval; ! 1246: { ! 1247: int error; ! 1248: ! 1249: if (uap->tp) ! 1250: error = copyout((caddr_t)&time.tv_sec, (caddr_t)uap->tp, ! 1251: sizeof (long)); ! 1252: *retval = time.tv_sec; /* XXX */ ! 1253: return (error); ! 1254: } ! 1255: ! 1256: ohpuxstime(p, uap, retval) ! 1257: struct proc *p; ! 1258: register struct args { ! 1259: int time; ! 1260: } *uap; ! 1261: int *retval; ! 1262: { ! 1263: struct timeval tv; ! 1264: int s, error; ! 1265: ! 1266: tv.tv_sec = uap->time; ! 1267: tv.tv_usec = 0; ! 1268: if (error = suser(u.u_cred, &u.u_acflag)) ! 1269: return (error); ! 1270: ! 1271: /* WHAT DO WE DO ABOUT PENDING REAL-TIME TIMEOUTS??? */ ! 1272: boottime.tv_sec += tv.tv_sec - time.tv_sec; ! 1273: s = splhigh(); time = tv; splx(s); ! 1274: resettodr(); ! 1275: return (0); ! 1276: } ! 1277: ! 1278: ohpuxftime(p, uap, retval) ! 1279: struct proc *p; ! 1280: register struct args { ! 1281: struct hpuxtimeb *tp; ! 1282: } *uap; ! 1283: int *retval; ! 1284: { ! 1285: struct hpuxtimeb tb; ! 1286: int s; ! 1287: ! 1288: s = splhigh(); ! 1289: tb.time = time.tv_sec; ! 1290: tb.millitm = time.tv_usec / 1000; ! 1291: splx(s); ! 1292: tb.timezone = tz.tz_minuteswest; ! 1293: tb.dstflag = tz.tz_dsttime; ! 1294: return (copyout((caddr_t)&tb, (caddr_t)uap->tp, sizeof (tb))); ! 1295: } ! 1296: ! 1297: ohpuxalarm(p, uap, retval) ! 1298: register struct proc *p; ! 1299: register struct args { ! 1300: int deltat; ! 1301: } *uap; ! 1302: int *retval; ! 1303: { ! 1304: int s = splhigh(); ! 1305: ! 1306: untimeout(realitexpire, (caddr_t)p); ! 1307: timerclear(&p->p_realtimer.it_interval); ! 1308: *retval = 0; ! 1309: if (timerisset(&p->p_realtimer.it_value) && ! 1310: timercmp(&p->p_realtimer.it_value, &time, >)) ! 1311: *retval = p->p_realtimer.it_value.tv_sec - time.tv_sec; ! 1312: if (uap->deltat == 0) { ! 1313: timerclear(&p->p_realtimer.it_value); ! 1314: splx(s); ! 1315: return (0); ! 1316: } ! 1317: p->p_realtimer.it_value = time; ! 1318: p->p_realtimer.it_value.tv_sec += uap->deltat; ! 1319: timeout(realitexpire, (caddr_t)p, hzto(&p->p_realtimer.it_value)); ! 1320: splx(s); ! 1321: return (0); ! 1322: } ! 1323: ! 1324: ohpuxnice(p, uap, retval) ! 1325: register struct proc *p; ! 1326: register struct args { ! 1327: int niceness; ! 1328: } *uap; ! 1329: int *retval; ! 1330: { ! 1331: int error; ! 1332: ! 1333: error = donice(p, p, (p->p_nice-NZERO)+uap->niceness); ! 1334: if (error == 0) ! 1335: *retval = p->p_nice - NZERO; ! 1336: return (error); ! 1337: } ! 1338: ! 1339: ohpuxtimes(p, uap, retval) ! 1340: struct proc *p; ! 1341: register struct args { ! 1342: struct tms *tmsb; ! 1343: } *uap; ! 1344: time_t *retval; ! 1345: { ! 1346: struct tms atms; ! 1347: int error; ! 1348: ! 1349: atms.tms_utime = scale50(&u.u_ru.ru_utime); ! 1350: atms.tms_stime = scale50(&u.u_ru.ru_stime); ! 1351: atms.tms_cutime = scale50(&u.u_cru.ru_utime); ! 1352: atms.tms_cstime = scale50(&u.u_cru.ru_stime); ! 1353: error = copyout((caddr_t)&atms, (caddr_t)uap->tmsb, sizeof (atms)); ! 1354: if (error == 0) ! 1355: *retval = scale50(&time) - scale50(&boottime); /* XXX */ ! 1356: return (error); ! 1357: } ! 1358: ! 1359: scale50(tvp) ! 1360: register struct timeval *tvp; ! 1361: { ! 1362: extern int hpuxtick; ! 1363: ! 1364: /* ! 1365: * Doesn't exactly do what the documentation says. ! 1366: * What we really do is return 50th of a second since that ! 1367: * is what HZ is on all bobcats I know of. ! 1368: */ ! 1369: return ((tvp->tv_sec * 50 + tvp->tv_usec / hpuxtick)); ! 1370: } ! 1371: ! 1372: /* ! 1373: * Set IUPD and IACC times on file. ! 1374: * Can't set ICHG. ! 1375: */ ! 1376: ohpuxutime(p, uap, retval) ! 1377: struct proc *p; ! 1378: register struct a { ! 1379: char *fname; ! 1380: time_t *tptr; ! 1381: } *uap; ! 1382: int *retval; ! 1383: { ! 1384: struct vattr vattr; ! 1385: time_t tv[2]; ! 1386: register struct vnode *vp; ! 1387: register struct nameidata *ndp = &u.u_nd; ! 1388: int error; ! 1389: ! 1390: if (uap->tptr) { ! 1391: error = copyin((caddr_t)uap->tptr, (caddr_t)tv, sizeof (tv)); ! 1392: if (error) ! 1393: return (error); ! 1394: } else ! 1395: tv[0] = tv[1] = time.tv_sec; ! 1396: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF; ! 1397: ndp->ni_segflg = UIO_USERSPACE; ! 1398: ndp->ni_dirp = uap->fname; ! 1399: vattr_null(&vattr); ! 1400: vattr.va_atime.tv_sec = tv[0]; ! 1401: vattr.va_atime.tv_usec = 0; ! 1402: vattr.va_mtime.tv_sec = tv[1]; ! 1403: vattr.va_mtime.tv_usec = 0; ! 1404: if (error = namei(ndp)) ! 1405: return (error); ! 1406: vp = ndp->ni_vp; ! 1407: if (vp->v_mount->mnt_flag & MNT_RDONLY) ! 1408: error = EROFS; ! 1409: else ! 1410: error = VOP_SETATTR(vp, &vattr, ndp->ni_cred); ! 1411: vput(vp); ! 1412: return (error); ! 1413: } ! 1414: ! 1415: ohpuxpause(p, uap, retval) ! 1416: struct proc *p; ! 1417: int *uap, *retval; ! 1418: { ! 1419: (void) tsleep((caddr_t)&u, PPAUSE | PCATCH, "pause", 0); ! 1420: /* always return EINTR rather than ERESTART... */ ! 1421: return (EINTR); ! 1422: } ! 1423: ! 1424: /* ! 1425: * The old fstat system call. ! 1426: */ ! 1427: ohpuxfstat(p, uap, retval) ! 1428: struct proc *p; ! 1429: register struct args { ! 1430: int fd; ! 1431: struct ohpuxstat *sb; ! 1432: } *uap; ! 1433: int *retval; ! 1434: { ! 1435: struct file *fp; ! 1436: ! 1437: if ((unsigned)uap->fd >= NOFILE || (fp = u.u_ofile[uap->fd]) == NULL) ! 1438: return (EBADF); ! 1439: if (fp->f_type != DTYPE_VNODE) ! 1440: return (EINVAL); ! 1441: return (ohpuxstat1((struct vnode *)fp->f_data, uap->sb)); ! 1442: } ! 1443: ! 1444: /* ! 1445: * Old stat system call. This version follows links. ! 1446: */ ! 1447: ohpuxstat(p, uap, retval) ! 1448: struct proc *p; ! 1449: register struct args { ! 1450: char *fname; ! 1451: struct ohpuxstat *sb; ! 1452: } *uap; ! 1453: int *retval; ! 1454: { ! 1455: register struct nameidata *ndp = &u.u_nd; ! 1456: int error; ! 1457: ! 1458: ndp->ni_nameiop = LOOKUP | LOCKLEAF | FOLLOW; ! 1459: ndp->ni_segflg = UIO_USERSPACE; ! 1460: ndp->ni_dirp = uap->fname; ! 1461: if (error = namei(ndp)) ! 1462: return (error); ! 1463: error = ohpuxstat1(ndp->ni_vp, uap->sb); ! 1464: vput(ndp->ni_vp); ! 1465: return (error); ! 1466: } ! 1467: ! 1468: int ! 1469: ohpuxstat1(vp, ub) ! 1470: register struct vnode *vp; ! 1471: struct ohpuxstat *ub; ! 1472: { ! 1473: struct ohpuxstat ds; ! 1474: struct vattr vattr; ! 1475: register int error; ! 1476: ! 1477: error = VOP_GETATTR(vp, &vattr, u.u_cred); ! 1478: if (error) ! 1479: return(error); ! 1480: /* ! 1481: * Copy from inode table ! 1482: */ ! 1483: ds.ohst_dev = vattr.va_fsid; ! 1484: ds.ohst_ino = (short)vattr.va_fileid; ! 1485: ds.ohst_mode = (u_short)vattr.va_mode; ! 1486: ds.ohst_nlink = vattr.va_nlink; ! 1487: ds.ohst_uid = (short)vattr.va_uid; ! 1488: ds.ohst_gid = (short)vattr.va_gid; ! 1489: ds.ohst_rdev = (dev_t)vattr.va_rdev; ! 1490: ds.ohst_size = (int)vattr.va_size; ! 1491: ds.ohst_atime = (int)vattr.va_atime.tv_sec; ! 1492: ds.ohst_mtime = (int)vattr.va_mtime.tv_sec; ! 1493: ds.ohst_ctime = (int)vattr.va_ctime.tv_sec; ! 1494: return (copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds))); ! 1495: } ! 1496: /* #endif */ ! 1497: ! 1498: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.