![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to v_proc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src|
Return to v_proc.c CVS log | Up to [MW Coherent from dump] / coherent / f / etc / conf / streams / src |
1.1 ! root 1: #define _DDI_DKI 1 ! 2: #define _DDI_DKI_IMPL 1 ! 3: #define _SYSV3 1 ! 4: ! 5: /* ! 6: * This file contains the implementations of the abstract scheduling ! 7: * interface functions defined in <sys/v_proc.h>. ! 8: * ! 9: * The functions defined here are used only by the code that needs to sleep ! 10: * processes to implement the DDI/DKI sleep lock and synchronization variable ! 11: * functionality. The code here has been broken out into a separate file and ! 12: * a formal interface specified purely to separate the abstract and ! 13: * implementation-dependent aspects of the DDI/DKI locking functions, ie to ! 14: * stop the original code being infected with #ifdefs. ! 15: * ! 16: * This module runs in the _SYSV3 compilation mode to interface with the iBCS2 ! 17: * Coherent kernel. ! 18: */ ! 19: ! 20: /* ! 21: *-IMPORTS: ! 22: * <common/ccompat.h> ! 23: * __CONST__ ! 24: * __USE_PROTO__ ! 25: * __ARGS () ! 26: * <common/xdebug.h> ! 27: * __LOCAL__ ! 28: * <common/_siginfo.h> ! 29: * __siginfo_t ! 30: * <kernel/ddi_proc.h> ! 31: * ddi_proc_data () ! 32: * <kernel/ddi_glob.h> ! 33: * ddi_global_data () ! 34: * <kernel/ddi_lock.h> ! 35: * proc_global_priority ! 36: * <kernel/sigproc.h> ! 37: * proc_send_signal () ! 38: * <sys/debug.h> ! 39: * ASSERT () ! 40: * <sys/types.h> ! 41: * plhi ! 42: * <sys/inline.h> ! 43: * splbase () ! 44: * <sys/ksynch.h> ! 45: * LOCK () ! 46: * UNLOCK () ! 47: * <sys/signal.h> ! 48: * SIGTSTP ! 49: */ ! 50: ! 51: #include <common/ccompat.h> ! 52: #include <common/xdebug.h> ! 53: #include <common/_siginfo.h> ! 54: #include <kernel/ddi_proc.h> ! 55: #include <kernel/ddi_glob.h> ! 56: #include <kernel/ddi_lock.h> ! 57: #include <kernel/sigproc.h> ! 58: #include <sys/debug.h> ! 59: #include <sys/types.h> ! 60: #include <sys/inline.h> ! 61: #include <sys/ksynch.h> ! 62: #include <sys/signal.h> ! 63: #include <stddef.h> ! 64: ! 65: #include <kernel/v_proc.h> ! 66: ! 67: /* ! 68: * Type used in comparisons of process priority. ! 69: */ ! 70: ! 71: typedef unsigned short pri_t; ! 72: ! 73: ! 74: #define PROCESS_PNODE() (& ddi_proc_data ()->dp_pnode) ! 75: ! 76: ! 77: /* ! 78: * Here we deal with the implementation-specifics. ! 79: */ ! 80: ! 81: #if __COHERENT__ ! 82: ! 83: #define __KERNEL__ 2 ! 84: #include <sys/sched.h> ! 85: #undef __KERNEL__ ! 86: ! 87: __sleep_t x_sleep __PROTO ((__VOID__ * _addr, int _pri, ! 88: int _how, char * where)); ! 89: void dwakeup __PROTO ((__VOID__ * _addr)); ! 90: ! 91: #define DPDATA_TO_PROC(dpdata) __DOWNCAST (PROC, p_ddi_space, dpdata) ! 92: #define PNODE_TO_PROC(pnode) DPDATA_TO_PROC (__DOWNCAST (dpdata_t, \ ! 93: dp_pnode, pnode)) ! 94: ! 95: /* ! 96: * Implementation-specific version of KERNEL_SLEEP (). ! 97: */ ! 98: ! 99: #if __USE_PROTO__ ! 100: __LOCAL__ int (KERNEL_SLEEP) (plist_t * plistp, int priority, int flag) ! 101: #else ! 102: __LOCAL__ int ! 103: (KERNEL_SLEEP) __ARGS ((plistp, priority, flag)) ! 104: plist_t * plistp; ! 105: int priority; ! 106: int flag; ! 107: #endif ! 108: { ! 109: pnode_t * pnode = PROCESS_PNODE (); ! 110: int state; ! 111: ! 112: ! 113: /* ! 114: * We expect to be running with interrupts disabled, so there's no ! 115: * reason not to just unlock the basic lock now and use the standard ! 116: * off-the-shelf Coherent kernel sleep function. ! 117: */ ! 118: ! 119: for (;;) { ! 120: PLIST_UNLOCK (plistp, plhi); ! 121: ! 122: (void) x_sleep (pnode, priority, ! 123: flag == SLEEP_INTERRUPTIBLE ? slpriSigCatch : ! 124: slpriNoSig, ! 125: "DDI/DKI"); ! 126: ! 127: /* ! 128: * The Coherent kernel won't dequeue us from the process list ! 129: * if it awakens us via a signal, so we use that fact to ! 130: * figure out why we are awake (sleep () does not return any ! 131: * useful value). ! 132: * ! 133: * To do anything about this in a multiprocessor-friendly ! 134: * fashion, we have to re-acquire the process list lock. ! 135: */ ! 136: ! 137: (void) PLIST_LOCK (plistp, "KERNEL_SLEEP"); ! 138: ! 139: if (ATOMIC_FETCH_PTR (pnode->pn_plistp) == 0) { ! 140: state = PROCESS_NORMAL_WAKE; ! 141: break; /* dequeued, normal wakeup */ ! 142: } ! 143: ! 144: ! 145: /* ! 146: * We were signalled; our caller may have requested non- ! 147: * interruptible sleep, so we go back to sleep on the caller's ! 148: * behalf (Coherent will always wake up a sleeper on receipt ! 149: * of a signal). ! 150: */ ! 151: ! 152: if (flag == SLEEP_INTERRUPTIBLE) { ! 153: /* ! 154: * We were woken by a signal and the caller wants to ! 155: * know about it, so dequeue us from the list and ! 156: * return the indication. ! 157: */ ! 158: ! 159: plistp->pl_head = pnode->pn_next; ! 160: pnode->pn_next->pn_prev = NULL; ! 161: ! 162: ATOMIC_CLEAR_PTR (pnode->pn_plistp); ! 163: ! 164: state = PROCESS_SIGNALLED; ! 165: break; ! 166: } ! 167: } ! 168: ! 169: /* ! 170: * Since we acquired a lock on the process list in order to safely ! 171: * test the reason why we awoke, release that lock now. Since we can, ! 172: * we'll set the interrupt priority down low. ! 173: */ ! 174: ! 175: PLIST_UNLOCK (plistp, plbase); ! 176: ! 177: return state; ! 178: } ! 179: ! 180: ! 181: /* ! 182: * Implementation-specific version of KERNEL_WAKE (). ! 183: */ ! 184: ! 185: #if __USE_PROTO__ ! 186: __LOCAL__ void (KERNEL_WAKE) (pnode_t * pnodep) ! 187: #else ! 188: __LOCAL__ void ! 189: KERNEL_WAKE __ARGS ((pnodep)) ! 190: pnode_t * pnodep; ! 191: #endif ! 192: { ! 193: dwakeup (pnodep); /* don't defer this */ ! 194: } ! 195: ! 196: ! 197: /* ! 198: * Implementation-specific code to send a signal to a process. ! 199: */ ! 200: ! 201: #if __USE_PROTO__ ! 202: __LOCAL__ int (KERNEL_SIGNAL) (dpdata_t * dpdatap, int sig) ! 203: #else ! 204: __LOCAL__ int ! 205: KERNEL_SIGNAL __ARGS ((dpdatap, sig)) ! 206: dpdata_t * dpdatap; ! 207: int sig; ! 208: #endif ! 209: { ! 210: __siginfo_t siginfo; ! 211: ! 212: /* ! 213: * This is a bit of a crock until such time as we can change the ! 214: * Coherent process-table to support reference-counting, etc. ! 215: */ ! 216: ! 217: siginfo.__si_signo = sig; ! 218: siginfo.__si_code = 0; ! 219: siginfo.__si_errno = 0; ! 220: siginfo.__si_pid = 0; ! 221: siginfo.__si_uid = 0; ! 222: ! 223: proc_send_signal (DPDATA_TO_PROC (dpdatap), & siginfo); ! 224: return 0; ! 225: } ! 226: ! 227: ! 228: #else ! 229: ! 230: ! 231: uarea_t _dos_uarea_; ! 232: proc_t _dos_proc_; ! 233: ! 234: #define PNODE_TO_PROC(pnodep) __DOWNCAST (proc_t, p_nigel, \ ! 235: __DOWNCAST (dpdata_t, dp_pnode, pnodep)) ! 236: ! 237: #include <sys/cmn_err.h> ! 238: #include <bios.h> ! 239: ! 240: ! 241: /* ! 242: * Implementation-specific version of KERNEL_SLEEP (). ! 243: */ ! 244: ! 245: #if __USE_PROTO__ ! 246: __LOCAL__ int (KERNEL_SLEEP) (plist_t * plistp, int priority, int flag) ! 247: #else ! 248: __LOCAL__ int ! 249: (KERNEL_SLEEP) __ARGS ((plistp, priority, flag)) ! 250: plist_t * plistp; ! 251: int priority; ! 252: int flag; ! 253: #endif ! 254: { ! 255: int state; ! 256: ! 257: ! 258: CURRENT_PROCESS ()->p_state = PS_SLEEP; ! 259: ! 260: PLIST_UNLOCK (plistp, plhi); ! 261: (void) splbase (); ! 262: ! 263: while ((state = CURRENT_PROCESS ()->p_state) != PS_RUN && ! 264: state != PS_SIGNALLED) ! 265: if (_bios_keybrd (_KEYBRD_READY)) ! 266: switch (_bios_keybrd (_KEYBRD_READ) & 0xFF) { ! 267: ! 268: case 0x1B: ! 269: cmn_err (CE_PANIC, "Abort!"); ! 270: break; ! 271: ! 272: default: ! 273: break; ! 274: } ! 275: ! 276: return (state == PS_RUN ? PROCESS_NORMAL_WAKE : PROCESS_SIGNALLED); ! 277: } ! 278: ! 279: ! 280: /* ! 281: * Implementation-specific version of KERNEL_WAKE () ! 282: */ ! 283: ! 284: #if __USE_PROTO__ ! 285: __LOCAL__ void (KERNEL_WAKE) (pnode_t * pnodep) ! 286: #else ! 287: __LOCAL__ void ! 288: KERNEL_WAKE __ARGS ((pnodep)) ! 289: pnode_t * pnodep; ! 290: #endif ! 291: { ! 292: ASSERT (pnodep == PROCESS_PNODE ()); ! 293: ! 294: if (CURRENT_PROCESS ()->p_state == PS_SLEEP || ! 295: CURRENT_PROCESS ()->p_state == PS_SLEEP_NO_SIG) ! 296: CURRENT_PROCESS ()->p_state = PS_RUN; ! 297: } ! 298: ! 299: ! 300: /* ! 301: * Implementation-specific code to send a signal to a process. ! 302: */ ! 303: ! 304: #if __USE_PROTO__ ! 305: __LOCAL__ int (KERNEL_SIGNAL) (dpdata_t * dpdatap, int sig) ! 306: #else ! 307: __LOCAL__ int ! 308: KERNEL_SIGNAL __ARGS ((dpdatap, sig)) ! 309: dpdata_t * dpdatap; ! 310: int sig; ! 311: #endif ! 312: { ! 313: if (CURRENT_PROCESS ()->p_state == PS_SLEEP) ! 314: CURRENT_PROCESS ()->p_state = PS_SIGNALLED; ! 315: ! 316: return 0; ! 317: } ! 318: ! 319: #endif ! 320: ! 321: ! 322: /* ! 323: * Table to define the mapping between abstract processor priority and the ! 324: * priority levels used in the comparisons between priority levels. ! 325: */ ! 326: ! 327: __LOCAL__ pri_t _pri_map [] = { ! 328: 0, 1, 2, 3, 4, 5, 6, /* prilo */ ! 329: 7, 8, 9, 10, 11, 12, 13, /* pritape */ ! 330: 14, 15, 16, 17, 18, 19, 20, /* primed */ ! 331: 21, 22, 23, 24, 25, 26, 27, /* pritty */ ! 332: 28, 29, 30, 31, 32, 33, 34, /* pridisk */ ! 333: 35, 36, 37, 38, 39, 40, 41, /* prinet */ ! 334: 42, 43, 44, 45, 46, 47, 48 /* prihi */ ! 335: }; ! 336: ! 337: ! 338: ! 339: /* ! 340: * This function is the abstract interface used by the DDI/DKI functions to ! 341: * invoke kernel sleep. ! 342: * ! 343: * This function is charged with sleeping the current process (possibly such ! 344: * that it may be interrupted by signals). It is passed a pointer to a locked ! 345: * process list structure on which the current process is to be threaded if ! 346: * it is actually going to sleep. After moving the process to a "slept" ! 347: * state and saving the process context the process list is unlocked before ! 348: * the main kernel dispatched is invoked. ! 349: */ ! 350: ! 351: #define ARRAY_MAX(array) (sizeof (array) / sizeof ((array) [0])) ! 352: ! 353: #if __USE_PROTO__ ! 354: __sleep_t (MAKE_SLEEPING) (plist_t * plistp, int priority, int flag) ! 355: #else ! 356: __sleep_t ! 357: MAKE_SLEEPING __ARGS ((plistp, priority, flag)) ! 358: plist_t * plistp; ! 359: int priority; ! 360: int flag; ! 361: #endif ! 362: { ! 363: pnode_t * pnodep = PROCESS_PNODE (); ! 364: pnode_t * pscan; ! 365: pnode_t * pprev; ! 366: unsigned my_pri = _pri_map [priority]; ! 367: ! 368: ASSERT (plistp != NULL); ! 369: PLIST_ASSERT_LOCKED (plistp); ! 370: ! 371: ASSERT (priority >= 0 && priority < ARRAY_MAX (_pri_map)); ! 372: ASSERT (flag == SLEEP_NO_SIGNALS || flag == SLEEP_INTERRUPTIBLE); ! 373: ! 374: /* ! 375: * Walk down the list of processes until one is found with a lower ! 376: * abstract priority than the process we are going to put to sleep. ! 377: */ ! 378: ! 379: for (pscan = plistp->pl_head, pprev = NULL ; pscan != NULL ; ! 380: pscan = (pprev = pscan)->pn_next) { ! 381: /* ! 382: * Don't forget to map the stored priority... ! 383: */ ! 384: ! 385: if (_pri_map [pscan->pn_priority] < my_pri) ! 386: break; ! 387: } ! 388: ! 389: ! 390: /* ! 391: * Now insert the current process between pprev and pscan. ! 392: */ ! 393: ! 394: if (pprev == NULL) ! 395: plistp->pl_head = pnodep; ! 396: else ! 397: pprev->pn_next = pnodep; ! 398: ! 399: if (pscan != NULL) ! 400: pscan->pn_prev = pnodep; ! 401: ! 402: pnodep->pn_prev = pprev; ! 403: pnodep->pn_next = pscan; ! 404: ! 405: ! 406: /* ! 407: * We store the unmapped (abstract) priority since it should make more ! 408: * sense for a "ps"-like utility, and mapping it is cheap. ! 409: */ ! 410: ! 411: pnodep->pn_priority = priority; ! 412: pnodep->pn_flag = flag; ! 413: ATOMIC_STORE_PTR (pnodep->pn_plistp, plistp); ! 414: ! 415: ! 416: /* ! 417: * Now we are going to actually perform the low-level sleep. ! 418: * ! 419: * This thing gets to perform the kernel-specific bit of sleeping the ! 420: * process, possibly with signal checks and whatnot, unlocking the ! 421: * plist, and running the next process. ! 422: */ ! 423: ! 424: return KERNEL_SLEEP (plistp, priority, flag); ! 425: } ! 426: ! 427: ! 428: /* ! 429: * This function wakes one of the processes queued on a plist; since the ! 430: * MAKE_SLEEPING () function queues them in priority order, let's wake up ! 431: * the first... ! 432: */ ! 433: ! 434: #if __USE_PROTO__ ! 435: __VOID__ * (WAKE_ONE) (plist_t * plistp) ! 436: #else ! 437: __VOID__ * ! 438: WAKE_ONE __ARGS ((plistp)) ! 439: plist_t * plistp; ! 440: #endif ! 441: { ! 442: pnode_t * pnodep; ! 443: ! 444: ASSERT (plistp != NULL); ! 445: PLIST_ASSERT_LOCKED (plistp); ! 446: ! 447: if ((pnodep = plistp->pl_head) != NULL) { ! 448: /* ! 449: * Given that we have something to awaken, dequeue it and ! 450: * make it runnable. ! 451: */ ! 452: ! 453: plistp->pl_head = pnodep->pn_next; ! 454: pnodep->pn_next->pn_prev = NULL; ! 455: ! 456: KERNEL_WAKE (pnodep); ! 457: ! 458: /* ! 459: * Return the identity of the person we gave the lock to. ! 460: */ ! 461: ! 462: return pnodep; ! 463: } ! 464: ! 465: /* ! 466: * Indicate that we found no-one to take over the mantle... ! 467: */ ! 468: ! 469: return NULL; ! 470: } ! 471: ! 472: ! 473: /* ! 474: * This function wakes all of the processes queued on a plist. ! 475: */ ! 476: ! 477: #if __USE_PROTO__ ! 478: void (WAKE_ALL) (plist_t * plistp) ! 479: #else ! 480: void ! 481: WAKE_ALL __ARGS ((plistp)) ! 482: plist_t * plistp; ! 483: #endif ! 484: { ! 485: pnode_t * pnodep; ! 486: pnode_t * pnext; ! 487: ! 488: ASSERT (plistp != NULL); ! 489: PLIST_ASSERT_LOCKED (plistp); ! 490: ! 491: for (pnodep = plistp->pl_head ; pnodep != NULL ; pnodep = pnext) { ! 492: /* ! 493: * We take the value of the "pn_next" member now, because the ! 494: * MAKE_RUNNABLE () call has the freedom to alter any of the ! 495: * members of the pnode to deal with such things as ! 496: * signalling. ! 497: */ ! 498: ! 499: pnext = pnodep->pn_next; ! 500: ! 501: KERNEL_WAKE (pnodep); ! 502: } ! 503: ! 504: plistp->pl_head = NULL; ! 505: } ! 506: ! 507: ! 508: /* ! 509: * This function returns a value suitable for use as a process identifier for ! 510: * the DDI/DKI SLEEP_LOCKOWNED () function to identify the current context. ! 511: */ ! 512: ! 513: #if __USE_PROTO__ ! 514: __VOID__ * (PROC_HANDLE) (void) ! 515: #else ! 516: __VOID__ * ! 517: PROC_HANDLE __ARGS (()) ! 518: #endif ! 519: { ! 520: return PROCESS_PNODE (); ! 521: } ! 522: ! 523: ! 524: /* ! 525: *-STATUS: ! 526: * DDI/DKI ! 527: * ! 528: *-NAME: ! 529: * proc_ref Obtain a reference to a process for signalling. ! 530: * ! 531: *-SYNOPSIS: ! 532: * #include <sys/types.h> ! 533: * ! 534: * void * proc_ref (); ! 535: * ! 536: *-DESCRIPTION: ! 537: * A non-STREAMS character driver can call proc_ref () to obtain a ! 538: * reference to the process in whose context it is running. The value ! 539: * returned can be used in subsequent calls to proc_signal () to post a ! 540: * signal to the process. The return value should not be used in any ! 541: * other way (ie, the driver should not attempt to interpret its ! 542: * meaning). ! 543: * ! 544: *-RETURN VALUE: ! 545: * An identifier that can be used in calls to proc_signal () and ! 546: * proc_unref (). ! 547: * ! 548: *-LEVEL: ! 549: * Base only. ! 550: * ! 551: *-NOTES: ! 552: * Processes can exit even though they are referenced by drivers. In this ! 553: * event, reuse of the identifier will be deferred until all driver ! 554: * references are given up. ! 555: * ! 556: * There must be a matching call to proc_unref () for every call to ! 557: * proc_ref (), when the driver no longer needs to reference the process. ! 558: * This is typically done as part of close () processing. ! 559: * ! 560: * Requires user context. ! 561: * ! 562: * Does not sleep. ! 563: * ! 564: * Driver-defined basic locks, read/write locks, and sleep locks may be ! 565: * held across calls to this function. ! 566: * ! 567: *-SEE ALSO: ! 568: * proc_signal (), proc_unref () ! 569: */ ! 570: ! 571: #if __USE_PROTO__ ! 572: __VOID__ * (proc_ref) (void) ! 573: #else ! 574: __VOID__ * ! 575: proc_ref __ARGS (()) ! 576: #endif ! 577: { ! 578: pl_t prev_pl; ! 579: dpdata_t * dpdatap; ! 580: ! 581: ASSERT_BASE_LEVEL (); ! 582: ! 583: ! 584: /* ! 585: * This implementation is a really just a stub for testing. Later ! 586: * revisions of the code (especially in proc_unref () will deal with ! 587: * the synchronization and storage management issues properly. ! 588: * ! 589: * In addition, leaving the multiprocessor rewrite of the process ! 590: * system for another time will be good for ensuring that proper ! 591: * encapsulation boundaries are created and respected, and will ensure ! 592: * that the ideas prototypes here have been properly tested before ! 593: * they are incorporated into other kernel areas. ! 594: */ ! 595: ! 596: dpdatap = ddi_proc_data (); ! 597: ! 598: prev_pl = LOCK (ddi_global_data ()->dg_proclock, ! 599: proc_global_priority); ! 600: ! 601: dpdatap->dp_refcount ++; ! 602: ! 603: UNLOCK (ddi_global_data ()->dg_proclock, prev_pl); ! 604: ! 605: return dpdatap; ! 606: } ! 607: ! 608: ! 609: /* ! 610: *-STATUS: ! 611: * DDI/DKI ! 612: * ! 613: *-NAME: ! 614: * proc_signal Send a signal to a process. ! 615: * ! 616: *-SYNOPSIS: ! 617: * #include <sys/types.h> ! 618: * #include <sys/signal.h> ! 619: * ! 620: * int proc_signal (void * pref, int sig); ! 621: * ! 622: *-ARGUMENTS: ! 623: * pref Identifier obtained by a previous call to proc_ref (). ! 624: * ! 625: * sig Signal number to be sent. Valid signal numbers to be ! 626: * sent are: ! 627: * SIGHUP The device has been disconnected. ! 628: * SIGINT The interrupt character has been ! 629: * received. ! 630: * SIGQUIT The quit character has been received. ! 631: * SIGWINCH The window size has changed. ! 632: * SIGURG Urgent data are available. ! 633: * SIGPOLL A pollable event has occurred. ! 634: * ! 635: *-DESCRIPTION: ! 636: * The proc_signal () function can be used to post a signal to the ! 637: * process represented by "pref". This will interrupt any process blocked ! 638: * in SV_WAIT_SIG () or SLEEP_LOCK_SIG () at the time the signal is ! 639: * posted, causing those functions to return prematurely in most cases. ! 640: * If the process has exited then this function has no effect. ! 641: * ! 642: *-RETURN VALUE: ! 643: * If the process still exists, 0 is returned. Otherwise, -1 is returned ! 644: * to indicate that the process no longer exists. ! 645: * ! 646: *-LEVEL: ! 647: * Base or interrupt. ! 648: * ! 649: *-NOTES: ! 650: * STREAMS drivers and modules should not use this mechanism for ! 651: * signalling processes. Instead, they can send M_SIG or M_PCSIG STREAMS ! 652: * messages to the stream head. ! 653: * ! 654: * proc_signal () must not be used to send SIGTSTP to a process. ! 655: * ! 656: * Does not sleep. ! 657: * ! 658: * Driver-defined basic locks, read/write locks, and sleep locks may be ! 659: * held across calls to this function. ! 660: * ! 661: *-SEE ALSO: ! 662: * proc_ref (), proc_unref () ! 663: */ ! 664: ! 665: #if __USE_PROTO__ ! 666: int (proc_signal) (__VOID__ * pref, int sig) ! 667: #else ! 668: int ! 669: proc_signal __ARGS ((pref, sig)) ! 670: __VOID__ * pref; ! 671: int sig; ! 672: #endif ! 673: { ! 674: dpdata_t * dpdatap = (dpdata_t *) pref; ! 675: ! 676: ASSERT (pref != NULL); ! 677: ASSERT (sig != SIGTSTP); ! 678: ! 679: return KERNEL_SIGNAL (dpdatap, sig); ! 680: } ! 681: ! 682: ! 683: /* ! 684: *-STATUS: ! 685: * DDI/DKI ! 686: * ! 687: *-SYNOPSIS: ! 688: * #include <sys/types.h> ! 689: * ! 690: * void proc_unref (void * pref); ! 691: * ! 692: *-ARGUMENTS: ! 693: * pref Identifier obtained by a previous call to proc_ref (). ! 694: * ! 695: *-DESCRIPTION: ! 696: * The proc_unref () function can be used to release a reference to a ! 697: * process identified by the parameter "pref". There must be a matching ! 698: * call to proc_unref () for every previous call to proc_ref (). ! 699: * ! 700: *-RETURN VALUE: ! 701: * None. ! 702: * ! 703: *-LEVEL: ! 704: * Base or interrupt. ! 705: * ! 706: *-NOTE: ! 707: * Processes can exit even though they are referenced by drivers. In this ! 708: * event, reuse of "pref" will be deferred until all driver references ! 709: * are given up. ! 710: * ! 711: * Does not sleep. ! 712: * ! 713: * Driver-defined basic locks, read/write locks, and sleep locks may be ! 714: * held across calls to this function. ! 715: * ! 716: *-SEE ALSO: ! 717: * proc_ref (), proc_signal () ! 718: */ ! 719: ! 720: #if __USE_PROTO__ ! 721: void (proc_unref) (__VOID__ * pref) ! 722: #else ! 723: void ! 724: proc_unref __ARGS ((pref)) ! 725: __VOID__ * pref; ! 726: #endif ! 727: { ! 728: pl_t prev_pl; ! 729: dpdata_t * dpdatap = (dpdata_t *) pref; ! 730: ! 731: ASSERT (pref != NULL); ! 732: ! 733: /* ! 734: * This implementation is a really just a stub for testing. Later ! 735: * revisions of the code will deal with the synchronization and ! 736: * storage management issues properly. ! 737: */ ! 738: ! 739: prev_pl = LOCK (ddi_global_data ()->dg_proclock, ! 740: proc_global_priority); ! 741: ! 742: dpdatap->dp_refcount --; ! 743: ! 744: UNLOCK (ddi_global_data ()->dg_proclock, prev_pl); ! 745: } ! 746: ! 747: ! 748: /* ! 749: *-STATUS: ! 750: * Internal ! 751: * ! 752: *-SYNOPSIS: ! 753: * #include <sys/types.h> ! 754: * ! 755: * void proc_kill_group (pid_t group, int sig); ! 756: * ! 757: *-ARGUMENTS: ! 758: * group Process group ID to which the signal will be sent. All ! 759: * members of the indicated process group will be sent ! 760: * the signal. ! 761: * ! 762: * sig Signal number to be sent. Valid signal numbers are: ! 763: * SIGHUP The device has been disconnected. ! 764: * SIGINT The interrupt character has been ! 765: * received. ! 766: * SIGQUIT The quit character has been received. ! 767: * SIGWINCH The window size has changed. ! 768: * SIGURG Urgent data are available. ! 769: * SIGPOLL A pollable event has occurred. ! 770: * ! 771: *-DESCRIPTION: ! 772: * The proc_kill_group () function can be used to post a signal to a ! 773: * group of processes. This will interrupt any process blocked in ! 774: * SV_WAIT_SIG () or SLEEP_LOCK_SIG () at the time the signal is posted, ! 775: * causing those functions to return prematurely in most cases. ! 776: * ! 777: *-RETURN VALUE: ! 778: * None. ! 779: * ! 780: *-LEVEL: ! 781: * Base or interrupt. ! 782: * ! 783: *-NOTES: ! 784: * STREAMS drivers and modules should not use this mechanism for ! 785: * signalling processes. Instead, they can send M_SIG or M_PCSIG STREAMS ! 786: * messages to the stream head. ! 787: * ! 788: * proc_kill_group () must not be used to send SIGTSTP to a process. ! 789: * ! 790: * Does not sleep. ! 791: * ! 792: * Driver-defined basic locks, read/write locks, and sleep locks may be ! 793: * held across calls to this function. ! 794: * ! 795: *-SEE ALSO: ! 796: * proc_ref (), proc_signal (), proc_unref () ! 797: */ ! 798: ! 799: #if __USE_PROTO__ ! 800: void (proc_kill_group) (pid_t group, int sig) ! 801: #else ! 802: void ! 803: proc_kill_group __ARGS ((group, sig)) ! 804: pid_t group; ! 805: int sig; ! 806: #endif ! 807: { ! 808: ASSERT ("proc_kill_group () : not implemented" == 0); ! 809: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.