src/child.cpp

   1 /*
   2  * Copyright (c) 2004 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24
  25 //
  26 // child - track a single child process and its belongings
  27 //
  28 #include "child.h"
  29 #include <security_utilities/debugging.h>
  30
  31
  32 //
  33 // We use a static Mutex to coordinate checkin
  34 //
  35 Mutex ServerChild::mCheckinLock;
  36
  37
  38 //
  39 // Make and break ServerChildren
  40 //
  41 ServerChild::ServerChild()
  42         : mCheckinCond(mCheckinLock)
  43 {
  44 }
  45
  46
  47 //
  48 // If the ServerChild is destroyed, kill its process, nice or hard.
  49 //
  50 // In case  you wonder about the tango below, it's making sure we
  51 // get to "It's dead, Jim" with the minimum number of checkChildren()
  52 // calls while still working correctly if this is the only thread alive.
  53 //
  54 //@@@ We *could* define a "soft shutdown" MIG message to send to all
  55 //@@@ ServerChildren in this situation.
  56 //
  57 ServerChild::~ServerChild()
  58 {
  59         if (state() == alive) {
  60                 this->kill(SIGTERM);            // shoot it once
  61                 checkChildren();                        // check for quick death
  62                 if (state() == alive) {
  63                         usleep(300000);                 // give it some grace
  64                         if (state() == alive) { // could have been reaped by another thread
  65                                 checkChildren();        // check again
  66                                 if (state() == alive) { // it... just... won't... die...
  67                                         this->kill(SIGKILL); // take THAT!
  68                                         checkChildren();
  69                                         if (state() == alive) // stuck zombie
  70                                                 abandon();      // leave the body behind
  71                                 }
  72                         }
  73                 }
  74         }
  75 }
  76
  77
  78 //
  79 // Parent action during fork: wait until ready or dead, then return
  80 //
  81 void ServerChild::parentAction()
  82 {
  83         // wait for either checkin or (premature) death
  84         secdebug("serverchild", "%p (pid %d) waiting for checkin", this, pid());
  85         StLock<Mutex> _(mCheckinLock);
  86         while (!ready() && state() == alive)
  87                 mCheckinCond.wait();
  88
  89         // so what happened?
  90         if (state() == dead) {
  91                 // our child died
  92                 secdebug("serverchild", "%p (pid %d) died before checking in", this, pid());
  93         } else if (ready()) {
  94                 // child has checked in and is ready for service
  95                 secdebug("serverchild", "%p (pid %d) ready for service on port %d",
  96                         this, pid(), mServicePort.port());
  97         } else
  98                 assert(false);          // how did we ever get here?!
  99 }
 100
 101
 102 //
 103 // Death action during fork: release the waiting creator thread, if any
 104 //
 105 void ServerChild::dying()
 106 {
 107         secdebug("serverchild", "%p is dead; resuming parent thread (if any)", this);
 108         mCheckinCond.signal();
 109 }
 110
 111
 112 void ServerChild::checkIn(Port servicePort, pid_t pid)
 113 {
 114         if (ServerChild *child = Child::find<ServerChild>(pid)) {
 115                 // Child was alive when last seen. Store service port and signal parent thread
 116                 {
 117                         StLock<Mutex> _(mCheckinLock);
 118                         child->mServicePort = servicePort;
 119                         servicePort.modRefs(MACH_PORT_RIGHT_SEND, +1);  // retain send right
 120                         secdebug("serverchild", "%p (pid %d) checking in; resuming parent thread",
 121                                 child, pid);
 122                 }
 123                 child->mCheckinCond.signal();
 124         } else {
 125                 // Child has died; is wrong kind; or spurious checkin.
 126                 // If it was a proper child, death notifications will wake up the parent thread
 127                 secdebug("serverchild", "pid %d not in child set; checkin ignored", pid);
 128         }
 129 }