![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386|
Return to sys2.c CVS log | Up to [MW Coherent from dump] / coherent / b / STREAMS / coh.386 |
1.1 ! root 1: /* ! 2: * coh.386/sys2.c ! 3: * ! 4: * Filesystem related system calls. ! 5: * ! 6: * Revised: Mon Jul 12 08:56:23 1993 CDT ! 7: */ ! 8: ! 9: #include <kernel/_sleep.h> ! 10: #include <sys/coherent.h> ! 11: #include <sys/errno.h> ! 12: #include <fcntl.h> ! 13: #include <sys/fd.h> ! 14: #include <sys/ino.h> ! 15: #include <sys/inode.h> ! 16: #include <sys/mount.h> ! 17: #include <sys/sched.h> ! 18: #include <sys/stat.h> ! 19: #include <sys/file.h> ! 20: ! 21: /* ! 22: * Determine accessibility of the given file. ! 23: */ ! 24: ! 25: uaccess(np, mode) ! 26: char *np; ! 27: register int mode; ! 28: { ! 29: register INODE *ip; ! 30: register int r; ! 31: IO io; ! 32: struct direct dir; ! 33: ! 34: schizo (); ! 35: ! 36: io.io_seg = IOUSR; ! 37: r = ftoi (np, 'r', & io, & dir); ! 38: ! 39: schizo (); ! 40: ! 41: if (r) ! 42: return; ! 43: ip = u.u_cdiri; ! 44: if (! iaccess (ip, mode)) ! 45: u.u_error = EACCES; ! 46: idetach (ip); ! 47: return 0; ! 48: } ! 49: ! 50: /* ! 51: * Schizo - swap real and effective id's. ! 52: */ ! 53: schizo() ! 54: { ! 55: register int t; ! 56: ! 57: t = u.u_uid; ! 58: u.u_uid = u.u_ruid; ! 59: u.u_ruid = t; ! 60: t = u.u_gid; ! 61: u.u_gid = u.u_rgid; ! 62: u.u_rgid = t; ! 63: } ! 64: ! 65: /* ! 66: * Turn accounting on or off. ! 67: */ ! 68: uacct(np) ! 69: register char *np; ! 70: { ! 71: if (super () == 0) ! 72: return; ! 73: ! 74: if (np == NULL) { ! 75: if (acctip == NULL) { ! 76: u.u_error = EINVAL; ! 77: return; ! 78: } ! 79: ! 80: ldetach (acctip); ! 81: acctip = NULL; ! 82: } else { ! 83: INODE * ip; ! 84: IO io; ! 85: struct direct dir; ! 86: ! 87: if (acctip != NULL) { ! 88: u.u_error = EINVAL; ! 89: return; ! 90: } ! 91: ! 92: io.io_seg = IOUSR; ! 93: if (ftoi (np, 'r', & io, & dir)) ! 94: return; ! 95: ! 96: ip = u.u_cdiri; ! 97: if ((ip->i_mode & IFMT) != IFREG) { ! 98: u.u_error = EINVAL; ! 99: idetach (ip); ! 100: return; ! 101: } ! 102: iunlock (ip); ! 103: acctip = ip; ! 104: } ! 105: return 0; ! 106: } ! 107: ! 108: /* ! 109: * Set current directory. ! 110: */ ! 111: uchdir(np) ! 112: char *np; ! 113: { ! 114: setcdir (np, & u.u_cdir); ! 115: return 0; ! 116: } ! 117: ! 118: /* ! 119: * Given a directory name and a pointer to a working directory pointer, ! 120: * Save the inode associated with the directory name in the working ! 121: * directory pointer and release the old one. This is used to change ! 122: * working and root directories. ! 123: */ ! 124: setcdir(np, ipp) ! 125: char *np; ! 126: register INODE **ipp; ! 127: { ! 128: register INODE *ip; ! 129: IO io; ! 130: struct direct dir; ! 131: ! 132: io.io_seg = IOUSR; ! 133: if (ftoi (np, 'r', & io, & dir)) ! 134: return; ! 135: ! 136: ip = u.u_cdiri; ! 137: if ((ip->i_mode & IFMT) != IFDIR) { ! 138: u.u_error = ENOTDIR; ! 139: idetach (ip); ! 140: return; ! 141: } ! 142: if (iaccess (ip, IPE) == 0) { ! 143: u.u_error = EACCES; ! 144: idetach (ip); ! 145: return; ! 146: } ! 147: iunlock (ip); ! 148: ldetach (* ipp); ! 149: * ipp = ip; ! 150: } ! 151: ! 152: /* ! 153: * Change the mode of a file. ! 154: */ ! 155: uchmod(np, mode) ! 156: char *np; ! 157: { ! 158: register INODE *ip; ! 159: IO io; ! 160: struct direct dir; ! 161: ! 162: io.io_seg = IOUSR; ! 163: if (ftoi (np, 'r', & io, & dir)) ! 164: return; ! 165: ! 166: ip = u.u_cdiri; ! 167: if (owner (ip->i_uid)) { ! 168: if (u.u_uid) ! 169: mode &= ~ ISVTXT; ! 170: ip->i_mode &= IFMT; ! 171: ip->i_mode |= mode & ~ IFMT; ! 172: icrt (ip); /* chmod - ctime */ ! 173: } ! 174: idetach (ip); ! 175: return 0; ! 176: } ! 177: ! 178: /* ! 179: * Change owner and group of a file. ! 180: */ ! 181: uchown(np, uid, gid) ! 182: char *np; ! 183: { ! 184: register INODE *ip; ! 185: IO io; ! 186: struct direct dir; ! 187: ! 188: io.io_seg = IOUSR; ! 189: if (ftoi (np, 'r', & io, & dir)) ! 190: return; ! 191: ! 192: ip = u.u_cdiri; ! 193: if (super ()) { ! 194: ip->i_mode &= ~ (ISUID | ISGID); /* clear any setuid/setgid */ ! 195: ip->i_uid = uid; ! 196: ip->i_gid = gid; ! 197: icrt (ip); /* chown - ctime */ ! 198: } ! 199: idetach (ip); ! 200: return 0; ! 201: } ! 202: ! 203: /* ! 204: * Set root directory. ! 205: */ ! 206: uchroot(np) ! 207: register char *np; ! 208: { ! 209: if (super ()) ! 210: setcdir (np, & u.u_rdir); ! 211: return 0; ! 212: } ! 213: ! 214: /* ! 215: * Close the given file descriptor. ! 216: */ ! 217: uclose(fd) ! 218: { ! 219: fdclose (fd); ! 220: return 0; ! 221: } ! 222: ! 223: /* ! 224: * Create a file with the given mode. ! 225: */ ! 226: ucreat(np, mode) ! 227: char *np; ! 228: register int mode; ! 229: { ! 230: return uopen (np, O_WRONLY | O_CREAT | O_TRUNC, mode); ! 231: } ! 232: ! 233: /* ! 234: * Duplicate a file descriptor. ! 235: */ ! 236: udup(ofd) ! 237: { ! 238: return fddup (ofd, 0); ! 239: } ! 240: ! 241: /* ! 242: * Given a file descriptor, return a status structure. ! 243: */ ! 244: ufstat(fd, stp) ! 245: struct stat *stp; ! 246: { ! 247: register INODE *ip; ! 248: register FD *fdp; ! 249: struct stat stat; ! 250: ! 251: if ((fdp = fdget (fd)) == NULL) ! 252: return; ! 253: ! 254: ip = fdp->f_ip; ! 255: istat (ip, & stat); ! 256: ! 257: if (kucopy (& stat, stp, sizeof (stat)) != sizeof (stat)) { ! 258: u.u_error = EFAULT; ! 259: return -1; ! 260: } ! 261: return 0; ! 262: } ! 263: ! 264: /* ! 265: * File control. ! 266: */ ! 267: ! 268: ufcntl (fd, cmd, arg) ! 269: unsigned fd; ! 270: unsigned cmd; ! 271: unsigned arg; ! 272: { ! 273: register FD * fdp; ! 274: struct flock sfl; ! 275: ! 276: T_VLAD(2, printf("fcntl(%d,%x,%x) ", fd, cmd, arg)); ! 277: ! 278: /* ! 279: * Validate file descriptor. ! 280: */ ! 281: ! 282: if ((fdp = fdget (fd)) == NULL) { ! 283: u.u_error = EBADF; ! 284: return; ! 285: } ! 286: ! 287: switch (cmd) { ! 288: ! 289: case F_DUPFD: ! 290: /* ! 291: * Validate base file descriptor. ! 292: */ ! 293: if (arg >= NOFILE) { ! 294: u.u_error = EINVAL; ! 295: return; ! 296: } ! 297: ! 298: /* ! 299: * Search for next available file descriptor. ! 300: */ ! 301: ! 302: return fddup (fd, arg); ! 303: ! 304: case F_SETFL: ! 305: fdp->f_flag &= ~ (IPNDLY | IPAPPEND | IPNONBLOCK); ! 306: if (arg & O_NDELAY) ! 307: fdp->f_flag |= IPNDLY; ! 308: if (arg & O_APPEND) ! 309: fdp->f_flag |= IPAPPEND; ! 310: if (arg & O_NONBLOCK) ! 311: fdp->f_flag |= IPNONBLOCK; ! 312: ! 313: /* ! 314: * Originally, this call returned the previous flag values, ! 315: * as permitted by the various standards. However, many ! 316: * programs incorrectly check for "== 0" as the return ! 317: * condition from this function rather than "!= -1" as they ! 318: * should. ! 319: */ ! 320: return 0; ! 321: ! 322: case F_GETFL: ! 323: switch (fdp->f_flag & (IPR | IPW)) { ! 324: case IPR: arg = O_RDONLY; break; ! 325: case IPW: arg = O_WRONLY; break; ! 326: default: arg = O_RDWR; break; ! 327: } ! 328: ! 329: if ((fdp->f_flag & IPNDLY) != 0) ! 330: arg |= O_NDELAY; ! 331: ! 332: if ((fdp->f_flag & IPAPPEND) != 0) ! 333: arg |= O_APPEND; ! 334: ! 335: if ((fdp->f_flag & IPNONBLOCK) != 0) ! 336: arg |= O_NONBLOCK; ! 337: ! 338: return arg; ! 339: ! 340: case F_GETLK: ! 341: case F_SETLK: ! 342: case F_SETLKW: ! 343: if (ukcopy ((struct flock *) arg, & sfl, ! 344: sizeof (struct flock)) != sizeof (struct flock)) { ! 345: u.u_error = EFAULT; ! 346: return -1; ! 347: } ! 348: if (rlock (fdp, cmd, & sfl)) ! 349: return -1; ! 350: if (cmd == F_GETLK && ! 351: kucopy (& sfl, (struct flock *) arg, ! 352: sizeof (struct flock)) != sizeof (struct flock)) { ! 353: u.u_error = EFAULT; ! 354: return -1; ! 355: } ! 356: return 0; ! 357: ! 358: case F_GETFD: ! 359: return fdgetflags (fd); ! 360: ! 361: case F_SETFD: ! 362: return fdsetflags (fd, arg); ! 363: ! 364: default: ! 365: T_VLAD (0x02, printf ("'fcntl - unknown cmd=%d arg=0x0%x' ", ! 366: cmd, arg)); ! 367: u.u_error = EINVAL; ! 368: } ! 369: } ! 370: ! 371: /* ! 372: * Device control information. ! 373: */ ! 374: ! 375: int ! 376: uioctl (fd, cmd, argp, regsetp) ! 377: unsigned fd; ! 378: unsigned cmd; ! 379: __VOID__ * argp; ! 380: gregset_t * regsetp; ! 381: { ! 382: register FD *fdp; ! 383: register INODE *ip; ! 384: register int mode; ! 385: ! 386: ! 387: T_PIGGY (0x8, printf ("uioctl(%d, 0x%x, 0x%x)", fd, cmd, argp)); ! 388: ! 389: if ((fdp = fdget (fd)) == NULL) ! 390: return; ! 391: ip = fdp->f_ip; ! 392: mode = ip->i_mode & IFMT; ! 393: if (mode != IFCHR && mode != IFBLK) { ! 394: u.u_error = ENOTTY; ! 395: return; ! 396: } ! 397: dioctl (ip->i_a.i_rdev, cmd, argp, fdp->f_flag, regsetp); ! 398: return 0; ! 399: } ! 400: ! 401: /* ! 402: * Create a link, `np2' to the already existing file `np1'. ! 403: */ ! 404: ! 405: ulink (np1, np2) ! 406: char *np1; ! 407: char *np2; ! 408: { ! 409: return do_link (np1, np2, IOUSR); ! 410: } ! 411: ! 412: ! 413: /* ! 414: * Internal version of link (), used by ulink () and umkdir (). ! 415: */ ! 416: ! 417: int ! 418: do_link (path1, path2, space) ! 419: char * path1; ! 420: char * path2; ! 421: int space; ! 422: { ! 423: register INODE *ip1; ! 424: IO io; ! 425: struct direct dir; ! 426: ! 427: io.io_seg = space; ! 428: if (ftoi (path1, 'r', & io, & dir)) ! 429: return; ! 430: ! 431: ip1 = u.u_cdiri; ! 432: if ((ip1->i_mode & IFMT) == IFDIR && super () == 0) { ! 433: idetach (ip1); ! 434: return; ! 435: } ! 436: ! 437: iunlock (ip1); ! 438: ! 439: io.io_seg = space; ! 440: if (ftoi (path2, 'c', & io, & dir)) { ! 441: ldetach (ip1); ! 442: return; ! 443: } ! 444: ! 445: if (u.u_cdiri != NULL) { ! 446: u.u_error = EEXIST; ! 447: idetach (u.u_cdiri); ! 448: ldetach (ip1); ! 449: return; ! 450: } ! 451: ! 452: if (ip1->i_dev != u.u_pdiri->i_dev) { ! 453: u.u_error = EXDEV; ! 454: idetach (u.u_pdiri); ! 455: ldetach (ip1); ! 456: return; ! 457: } ! 458: ! 459: if (iaccess (u.u_pdiri, IPW) == 0) { ! 460: idetach (u.u_pdiri); ! 461: ldetach (ip1); ! 462: return; ! 463: } ! 464: ! 465: idirent (ip1->i_ino, & io, & dir); ! 466: idetach (u.u_pdiri); ! 467: ilock (ip1); ! 468: ! 469: /* ! 470: * idirent() can fail during iwrite. In this case we should not ! 471: * increase link count. ! 472: * As result of this old bug, 286 mkdir utility destroys file ! 473: * system when runs out of free blocks. ! 474: */ ! 475: ! 476: if (! u.u_error) ! 477: ip1->i_nlink ++; ! 478: ! 479: icrt (ip1); /* link - ctime */ ! 480: idetach (ip1); ! 481: return 0; ! 482: } ! 483: ! 484: ! 485: /* ! 486: * Seek on the given file descriptor. ! 487: */ ! 488: ! 489: off_t ! 490: ulseek(fd, off, w) ! 491: register off_t off; ! 492: { ! 493: register FD *fdp; ! 494: register INODE *ip; ! 495: ! 496: if ((fdp = fdget (fd)) == NULL) ! 497: return; ! 498: ip = fdp->f_ip; ! 499: if ((ip->i_mode & IFMT) == IFPIPE) { ! 500: u.u_error = ESPIPE; ! 501: return; ! 502: } ! 503: switch (w) { ! 504: case 0: ! 505: break; ! 506: ! 507: case 1: ! 508: off += fdp->f_seek; ! 509: break; ! 510: ! 511: case 2: ! 512: off += ip->i_size; ! 513: break; ! 514: ! 515: default: ! 516: u.u_error = EINVAL; ! 517: return; ! 518: } ! 519: ! 520: if (off < 0) { ! 521: u.u_error = EINVAL; ! 522: return; ! 523: } ! 524: ! 525: fdp->f_seek = off; ! 526: return off; ! 527: } ! 528: ! 529: /* ! 530: * Create a special file. ! 531: */ ! 532: umknod(np, mode, rdev) ! 533: char *np; ! 534: dev_t rdev; ! 535: { ! 536: register INODE *ip; ! 537: register int type; ! 538: IO io; ! 539: struct direct dir; ! 540: ! 541: type = mode & IFMT; ! 542: if (type != IFPIPE && super () == 0) ! 543: return; ! 544: if (type != IFBLK && type != IFCHR) ! 545: rdev = 0; ! 546: ! 547: io.io_seg = IOUSR; ! 548: if (ftoi (np, 'c', & io, & dir)) ! 549: return; ! 550: ! 551: if ((ip = u.u_cdiri) != NULL) { ! 552: u.u_error = EEXIST; ! 553: idetach (ip); ! 554: return; ! 555: } ! 556: ! 557: if ((ip = imake (mode, rdev, & io, & dir)) != NULL) ! 558: idetach (ip); ! 559: ! 560: return 0; ! 561: } ! 562: ! 563: /* ! 564: * Mount the device `sp' on the pathname `np'. The flag, `f', ! 565: * indicates that the device is to be mounted read only. ! 566: */ ! 567: umount(sp, np, f) ! 568: char *sp; ! 569: char *np; ! 570: { ! 571: register INODE *ip; ! 572: register MOUNT *mp; ! 573: register dev_t rdev; ! 574: register int mode; ! 575: IO io; ! 576: struct direct dir; ! 577: ! 578: io.io_seg = IOUSR; ! 579: if (ftoi (sp, 'r', & io, & dir)) ! 580: return; ! 581: ! 582: ip = u.u_cdiri; ! 583: if (iaccess (ip, IPR | IPW) == 0) ! 584: goto err; ! 585: ! 586: mode = ip->i_mode; ! 587: rdev = ip->i_a.i_rdev; ! 588: if ((mode & IFMT) != IFBLK) { ! 589: u.u_error = ENOTBLK; ! 590: goto err; ! 591: } ! 592: ! 593: idetach(ip); ! 594: ! 595: io.io_seg = IOUSR; ! 596: if (ftoi (np, 'r', & io, & dir)) ! 597: return; ! 598: ! 599: ip = u.u_cdiri; ! 600: ! 601: if (iaccess (ip, IPR) == 0) ! 602: goto err; ! 603: ! 604: if ((ip->i_mode & IFMT) != IFDIR) { ! 605: u.u_error = ENOTDIR; ! 606: goto err; ! 607: } ! 608: ! 609: /* Check for current directory, open, or mount directory */ ! 610: ! 611: if (ip->i_refc > 1 || ip->i_ino == ROOTIN) { ! 612: u.u_error = EBUSY; ! 613: goto err; ! 614: } ! 615: for (mp = mountp ; mp != NULL ; mp = mp->m_next) { ! 616: if (mp->m_dev == rdev) { ! 617: u.u_error = EBUSY; ! 618: goto err; ! 619: } ! 620: } ! 621: ! 622: if ((mp = fsmount (rdev, f)) == NULL) ! 623: goto err; ! 624: mp->m_ip = ip; ! 625: ip->i_flag |= IFMNT; ! 626: ip->i_refc ++; ! 627: err: ! 628: idetach (ip); ! 629: return 0; ! 630: } ! 631: ! 632: /* ! 633: * Poll devices for input/output events. ! 634: */ ! 635: int ! 636: upoll(pollfds, npoll, msec) ! 637: struct pollfd * pollfds; ! 638: unsigned long npoll; ! 639: int msec; ! 640: { ! 641: register struct pollfd * pollp; /* current poll pointer */ ! 642: register FD * fdp; /* current file descriptor ptr */ ! 643: auto int fd; /* current file descriptor */ ! 644: auto int rev; /* last event report received */ ! 645: auto int nev; /* number non-zero event reports */ ! 646: auto int i; ! 647: char * cp; ! 648: int ret = -1; ! 649: ! 650: /* ! 651: * Validate number of polls. ! 652: */ ! 653: if ((npoll < 0) || (npoll > NOFILE)) { ! 654: u.u_error = EINVAL; ! 655: goto poll_done; ! 656: } ! 657: ! 658: /* ! 659: * If there are any fd's to poll ! 660: * validate address of polling information. ! 661: * npoll of 0 is legal, allows user a short delay. ! 662: */ ! 663: if (npoll) ! 664: if ((pollfds == NULL) ! 665: || !useracc(pollfds, npoll*sizeof(struct pollfd), 1)) { ! 666: u.u_error = EFAULT; ! 667: goto poll_done; ! 668: } ! 669: ! 670: for (;;) { ! 671: /* ! 672: * Service each poll in turn. ! 673: */ ! 674: for (nev=0, i=npoll, pollp = pollfds; i > 0; --i, pollp++) { ! 675: ! 676: /* ! 677: * Fetch file descriptor. ! 678: */ ! 679: fd = getuwd(&pollp->fd); ! 680: ! 681: /* ! 682: * Ignore negative file descriptors. ! 683: */ ! 684: if (fd < 0) { ! 685: rev = 0; ! 686: goto remember; ! 687: } ! 688: ! 689: #if 1 ! 690: /* ! 691: * Ignore file descriptors that are too large. ! 692: */ ! 693: if (fd >= NOFILE) { ! 694: rev = 0; ! 695: goto remember; ! 696: } ! 697: #else ! 698: /* For now, msg polling is deleted. */ ! 699: /* ! 700: * Poll message queue. ! 701: */ ! 702: if (fd >= NOFILE) { ! 703: rev = msgpoll(fd, getusd(&pollp->events), msec); ! 704: goto remember; ! 705: } ! 706: #endif ! 707: ! 708: /* ! 709: * Validate file descriptor. ! 710: */ ! 711: if ((fdp = fdget (fd)) == NULL) { ! 712: rev = POLLNVAL; ! 713: goto remember; ! 714: } ! 715: ! 716: switch ( fdp->f_ip->i_mode & IFMT ) { ! 717: case IFCHR: ! 718: rev = dpoll(fdp->f_ip->i_a.i_rdev, ! 719: getusd(&pollp->events)&0xffff, msec); ! 720: break; ! 721: case IFPIPE: ! 722: rev = ppoll(fdp->f_ip, ! 723: getusd(&pollp->events)&0xffff, msec); ! 724: break; ! 725: default: ! 726: printf("polling illegal dev: fd=%d mode=%x\n", ! 727: fd, fdp->f_ip->i_mode); ! 728: rev = POLLNVAL; ! 729: break; ! 730: } ! 731: ! 732: /* ! 733: * Remember reponses. ! 734: */ ! 735: remember: ! 736: cp = (char *)(&pollp->revents); ! 737: putusd(cp, rev); ! 738: ! 739: /* ! 740: * Record number of non-zero responses. ! 741: */ ! 742: if (rev) ! 743: nev++; ! 744: } ! 745: ! 746: /* ! 747: * Non-blocking poll or poll response received. ! 748: */ ! 749: if ( (nev != 0) || (msec == 0) ) { ! 750: pollexit(); ! 751: ret = nev; ! 752: goto poll_done; ! 753: } ! 754: ! 755: /* ! 756: * Schedule wakeup timer if positive delay interval given ! 757: * and the timer is not currently set. ! 758: */ ! 759: if ( (msec > 0) && (cprocp->p_polltim.t_func == NULL) ) { ! 760: /* ! 761: * Convert milliseconds to clock ticks. ! 762: */ ! 763: msec += (1000 / HZ) - 1; ! 764: msec /= (1000 / HZ); ! 765: timeout(&cprocp->p_polltim, msec, ! 766: wakeup, &cprocp->p_polls); ! 767: } ! 768: ! 769: /* ! 770: * Wake for polled event, poll timeout, or signal. ! 771: */ ! 772: ! 773: { ! 774: __sleep_t sleep; ! 775: ! 776: sleep = x_sleep (& cprocp->p_polls, pritty, ! 777: slpriSigCatch, "poll"); ! 778: ! 779: /* ! 780: * Terminate event monitoring. ! 781: */ ! 782: ! 783: pollexit(); ! 784: ! 785: /* ! 786: * Signal woke us up. ! 787: */ ! 788: ! 789: if (sleep == PROCESS_SIGNALLED) { ! 790: u.u_error = EINTR; ! 791: goto poll_done; ! 792: } ! 793: } ! 794: ! 795: /* ! 796: * We were woken up by timeout wakeup. ! 797: */ ! 798: if ( (msec > 0) && (cprocp->p_polltim.t_lbolt <= lbolt) ) { ! 799: ret = 0; ! 800: goto poll_done; ! 801: } ! 802: } ! 803: ! 804: poll_done: ! 805: /* ! 806: * Cancel timeout ! 807: */ ! 808: if ( (msec > 0) && (cprocp->p_polltim.t_func != NULL) ) ! 809: timeout(&cprocp->p_polltim, 0, NULL, NULL); ! 810: ! 811: return ret; ! 812: } ! 813: ! 814: /* ! 815: * Suspend execution for a short interval. ! 816: * ! 817: * Return the number of milliseconds actually slept. ! 818: * Shares use of cprocp->p_polltim with upoll(). ! 819: */ ! 820: int ! 821: unap(msec) ! 822: int msec; ! 823: { ! 824: int ret, lbolt0; ! 825: int ticksToWait, ticksWaited; ! 826: ! 827: if (msec <= 0) ! 828: return 0; ! 829: ! 830: /* ! 831: * Convert milliseconds to clock ticks. ! 832: * ! 833: * Wait for at least the specified number of milliseconds. ! 834: * For 100 Hz clock, if nap is for 11 msec, timeout is for 2 ticks. ! 835: */ ! 836: ticksToWait = ((msec * HZ) + 999) / 1000; ! 837: timeout (& cprocp->p_polltim, ticksToWait, wakeup, & cprocp->p_polls); ! 838: ! 839: /* ! 840: * Wake for timeout or signal. ! 841: */ ! 842: lbolt0 = lbolt; ! 843: if (x_sleep (& cprocp->p_polls, pritty, slpriSigCatch, ! 844: "nap") == PROCESS_SIGNALLED) { ! 845: /* ! 846: * Signal woke us up. ! 847: */ ! 848: u.u_error = EINTR; ! 849: goto napDone; ! 850: } else { ! 851: /* ! 852: * We were awakened by a timeout. ! 853: * Return number of milliseconds actually waited. ! 854: */ ! 855: ticksWaited = lbolt - lbolt0; ! 856: if (ticksWaited >= 0) ! 857: ret = (ticksWaited * 1000) / HZ; ! 858: else ! 859: ret = 0; ! 860: goto napDone; ! 861: } ! 862: ! 863: napDone: ! 864: /* ! 865: * Cancel timeout ! 866: */ ! 867: timeout (& cprocp->p_polltim, 0, NULL, NULL); ! 868: ! 869: return ret; ! 870: } ! 871:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.