Changeset 23580

Timestamp:

2008-03-28 12:47:54 (6 months ago)

Author:

zarzycki@…

Message:

Have launchd use the kill-via-shmem trick.

Location:

trunk/launchd/src

Files:

• launchd.c (modified) (2 diffs)
• launchd_core_logic.c (modified) (18 diffs)
• launchd_runtime.c (modified) (8 diffs)
• launchd_runtime.h (modified) (1 diff)
• libvproc.c (modified) (10 diffs)
• libvproc_internal.h (modified) (1 diff)
• libvproc_private.h (modified) (1 diff)

trunk/launchd/src/launchd.c

@@ -71 +71 @@
 #include "libbootstrap_public.h"
 #include "libvproc_public.h"
+#include "libvproc_private.h"
 #include "libvproc_internal.h"
 #include "liblaunch_public.h"
@@ -159 +160 @@
         if (pid1_magic) {
                 handle_pid1_crashes_separately();
+        } else {
+                /* prime shared memory before the 'bootstrap_port' global is set to zero */
+                _vproc_transaction_begin();
+                _vproc_transaction_end();
         }
 

trunk/launchd/src/launchd_core_logic.c

@@ -564 +564 @@
 job_stop(job_t j)
 {
+        char extralog[100];
         int32_t newval = 1;
 
@@ -596 +597 @@
                 }
 
-                job_log(j, LOG_DEBUG, "Sent SIGTERM signal");
+                if (j->kill_via_shmem) {
+                        snprintf(extralog, sizeof(extralog), ": %d remaining transactions", j->shmem->vp_shmem_transaction_cnt + 1);
+                } else {
+                        extralog[0] = '\0';
+                }
+
+                job_log(j, LOG_DEBUG, "Sent SIGTERM signal%s", extralog);
         }
 }
@@ -804 +811 @@
 
         if (jm->parentmgr) {
-                runtime_del_ref();
+                runtime_del_weak_ref();
                 SLIST_REMOVE(&jm->parentmgr->submgrs, jm, jobmgr_s, sle);
         } else if (pid1_magic) {
@@ -960 +967 @@
         }
         if (j->start_interval) {
-                runtime_del_ref();
+                runtime_del_weak_ref();
                 job_assumes(j, kevent_mod((uintptr_t)&j->start_interval, EVFILT_TIMER, EV_DELETE, 0, 0, NULL) != -1);
         }
@@ -1665 +1672 @@
                                 job_log(j, LOG_WARNING, "%s is too large. Ignoring.", LAUNCH_JOBKEY_STARTINTERVAL);
                         } else {
-                                runtime_add_ref();
+                                runtime_add_weak_ref();
                                 j->start_interval = value;
 
@@ -2231 +2238 @@
 
         if (j->shmem) {
-                job_assumes(j, munmap(j->shmem, getpagesize()) == 0);
+                job_assumes(j, vm_deallocate(mach_task_self(), (vm_address_t)j->shmem, getpagesize()) == 0);
                 j->shmem = NULL;
         }
@@ -3792 +3799 @@
         calendarinterval_setalarm(j, ci);
 
-        runtime_add_ref();
+        runtime_add_weak_ref();
 
         return true;
@@ -3805 +3812 @@
         free(ci);
 
-        runtime_del_ref();
+        runtime_del_weak_ref();
 }
 
@@ -3863 +3870 @@
         SLIST_INSERT_HEAD(&j->sockets, sg, sle);
 
-        runtime_add_ref();
+        runtime_add_weak_ref();
 
         return true;
@@ -3894 +3901 @@
         free(sg);
 
-        runtime_del_ref();
+        runtime_del_weak_ref();
 }
 
@@ -4730 +4737 @@
 
         if (jmr->parentmgr) {
-                runtime_add_ref();
+                runtime_add_weak_ref();
         }
 
@@ -5170 +5177 @@
 
         if (add) {
-                runtime_add_ref();
+                runtime_add_weak_ref();
         } else {
-                runtime_del_ref();
+                runtime_del_weak_ref();
         }
 }
@@ -5438 +5445 @@
 {
         memory_object_size_t size_of_page, size_of_page_orig;
+        vm_address_t vm_addr;
         kern_return_t kr;
 
@@ -5445 +5453 @@
 
         if (unlikely(j->anonymous)) {
+                job_log(j, LOG_ERR, "Anonymous job tried to setup shared memory");
                 return BOOTSTRAP_NOT_PRIVILEGED;
         }
@@ -5455 +5464 @@
         size_of_page_orig = size_of_page = getpagesize();
 
-        if (!job_assumes(j, j->shmem = mmap(NULL, size_of_page, PROT_READ|PROT_WRITE, MAP_ANON, -1, 0))) {
-                return BOOTSTRAP_NO_MEMORY;
-        }
+        kr = vm_allocate(mach_task_self(), &vm_addr, size_of_page, true);
+
+        if (!job_assumes(j, kr == 0)) {
+                return kr;
+        }
+
+        j->shmem = (typeof(j->shmem))vm_addr;
+        j->shmem->vp_shmem_standby_timeout = j->timeout;
 
         kr = mach_make_memory_entry_64(mach_task_self(), &size_of_page,
-                        (memory_object_offset_t)((long)j->shmem), VM_PROT_DEFAULT, shmem_port, 0);
+                        (memory_object_offset_t)vm_addr, VM_PROT_READ|VM_PROT_WRITE, shmem_port, 0);
 
         if (job_assumes(j, kr == 0)) {
                 job_assumes(j, size_of_page == size_of_page_orig);
         }
+
+        /* no need to inherit this in child processes */
+        job_assumes(j, vm_inherit(mach_task_self(), (vm_address_t)j->shmem, size_of_page_orig, VM_INHERIT_NONE) == 0);
 
         return kr;
@@ -5777 +5794 @@
                 } else if (inval) {
                         if (j->start_interval == 0) {
-                                runtime_add_ref();
+                                runtime_add_weak_ref();
                         } else {
                                 /* Workaround 5225889 */
@@ -5787 +5804 @@
                         job_assumes(j, kevent_mod((uintptr_t)&j->start_interval, EVFILT_TIMER, EV_DELETE, 0, 0, NULL) != -1);
                         if (j->start_interval != 0) {
-                                runtime_del_ref();
+                                runtime_del_weak_ref();
                         }
                         j->start_interval = 0;
@@ -6015 +6032 @@
                 ji->mach_uid = which_user;
                 ji->per_user = true;
+                ji->kill_via_shmem = true;
 
                 if ((ms = machservice_new(ji, lbuf, up_cont, false)) == NULL) {

trunk/launchd/src/launchd_runtime.c

@@ -70 +70 @@
 #include "launchd.h"
 #include "launchd_core_logic.h"
+#include "libvproc_public.h"
+#include "libvproc_private.h"
 #include "libvproc_internal.h"
 #include "job_reply.h"
@@ -100 +102 @@
 static struct ldcred ldc;
 static size_t runtime_busy_cnt;
+static size_t runtime_standby_cnt;
 
 
@@ -990 +993 @@
         mach_msg_timeout_t to;
         mach_msg_return_t mr;
+        size_t busy_cnt;
 
         options = MACH_RCV_MSG|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT) |
@@ -997 +1001 @@
 
         for (;;) {
+                busy_cnt = runtime_busy_cnt + runtime_standby_cnt;
                 to = MACH_MSG_TIMEOUT_NONE;
 
@@ -1008 +1013 @@
                 }
 
-                if ((tmp_options & MACH_RCV_MSG) && (runtime_idle_callback || (runtime_busy_cnt == 0))) {
+                if ((tmp_options & MACH_RCV_MSG) && (runtime_idle_callback || (busy_cnt == 0))) {
                         tmp_options |= MACH_RCV_TIMEOUT;
 
                         if (!(tmp_options & MACH_SEND_TIMEOUT)) {
-                                to = runtime_busy_cnt ? runtime_idle_timeout : (RUNTIME_ADVISABLE_IDLE_TIMEOUT * 1000);
+                                to = busy_cnt ? runtime_idle_timeout : (_vproc_standby_timeout() * 1000);
                         }
                 }
@@ -1034 +1039 @@
                 case MACH_RCV_TIMED_OUT:
                         if (to != MACH_MSG_TIMEOUT_NONE) {
-                                if (runtime_busy_cnt == 0) {
+                                if (busy_cnt == 0) {
                                         launchd_shutdown();
                                 } else if (runtime_idle_callback) {
@@ -1478 +1483 @@
 runtime_add_ref(void)
 {
+        if (!pid1_magic) {
+                _vproc_transaction_begin();
+        }
         runtime_busy_cnt++;
 }
@@ -1484 +1492 @@
 runtime_del_ref(void)
 {
+        if (!pid1_magic) {
+                _vproc_transaction_end();
+        }
         runtime_busy_cnt--;
+}
+
+INTERNAL_ABI void
+runtime_add_weak_ref(void)
+{
+        if (!pid1_magic) {
+                _vproc_standby_begin();
+        }
+        runtime_standby_cnt++;
+}
+
+INTERNAL_ABI void
+runtime_del_weak_ref(void)
+{
+        if (!pid1_magic) {
+                _vproc_standby_end();
+        }
+        runtime_standby_cnt--;
 }
 

trunk/launchd/src/launchd_runtime.h

@@ -112 +112 @@
 INTERNAL_ABI void runtime_add_ref(void);
 INTERNAL_ABI void runtime_del_ref(void);
+INTERNAL_ABI void runtime_add_weak_ref(void);
+INTERNAL_ABI void runtime_del_weak_ref(void);
 
 INTERNAL_ABI void launchd_runtime_init(void);

trunk/launchd/src/libvproc.c

@@ -34 +34 @@
 #include <pthread.h>
 #include <signal.h>
+#include <assert.h>
 #if HAVE_QUARANTINE
 #include <quarantine.h>
@@ -66 +67 @@
         kr = vproc_mig_setup_shmem(bootstrap_port, &shmem_port);
 
-        if (unlikely(kr)) {
-                abort();
-        }
-
-        kr = vm_map_64(mach_task_self(), &vm_addr, getpagesize(), 0, true, shmem_port, 0, false,
+        assert(kr == 0);
+
+        kr = vm_map(mach_task_self(), &vm_addr, getpagesize(), 0, true, shmem_port, 0, false,
                         VM_PROT_READ|VM_PROT_WRITE, VM_PROT_READ|VM_PROT_WRITE, VM_INHERIT_NONE);
 
-        if (unlikely(kr)) {
-                abort();
-        }
+        assert(kr == 0);
 
         vproc_shmem = (struct vproc_shmem_s *)vm_addr;
@@ -85 +82 @@
         vproc_transaction_t vpt = (vproc_transaction_t)vproc_shmem_init; /* we need a "random" variable that is testable */
 
-        _basic_vproc_transaction_begin();
+        _vproc_transaction_begin();
 
         return vpt;
@@ -91 +88 @@
 
 void
-_basic_vproc_transaction_begin(void)
+_vproc_transaction_begin(void)
 {
         typeof(vproc_shmem->vp_shmem_transaction_cnt) newval;
@@ -116 +113 @@
 
 size_t
-_basic_vproc_transaction_count(void)
+_vproc_transaction_count(void)
 {
         return likely(vproc_shmem) ? vproc_shmem->vp_shmem_transaction_cnt : INT32_MAX;
 }
 
-void
-_basic_vproc_transaction_try_exit(int status)
+size_t
+_vproc_standby_count(void)
+{
+        return likely(vproc_shmem) ? vproc_shmem->vp_shmem_standby_cnt : INT32_MAX;
+}
+
+size_t
+_vproc_standby_timeout(void)
+{
+        return likely(vproc_shmem) ? vproc_shmem->vp_shmem_standby_timeout : 0;
+}
+
+void
+_vproc_transaction_try_exit(int status)
 {
         typeof(vproc_shmem->vp_shmem_transaction_cnt) newval;
@@ -147 +156 @@
         }
 
-        _basic_vproc_transaction_end();
-}
-
-void
-_basic_vproc_transaction_end(void)
+        _vproc_transaction_end();
+}
+
+void
+_vproc_transaction_end(void)
 {
         typeof(vproc_shmem->vp_shmem_transaction_cnt) newval;
@@ -172 +181 @@
 {
         vproc_standby_t vpsb = (vproc_standby_t)vproc_shmem_init; /* we need a "random" variable that is testable */
+
+        _vproc_standby_begin();
+
+        return vpsb;
+}
+
+void
+_vproc_standby_begin(void)
+{
         typeof(vproc_shmem->vp_shmem_standby_cnt) newval;
 
@@ -177 +195 @@
                 int po_r = pthread_once(&shmem_inited, vproc_shmem_init);
                 if (po_r != 0 || vproc_shmem == NULL) {
-                        return NULL;
+                        return;
                 }
         }
@@ -187 +205 @@
                 abort();
         }
-
-        return vpsb;
 }
 
@@ -194 +210 @@
 vproc_standby_end(vproc_t vp __attribute__((unused)), vproc_standby_t vpt)
 {
-        typeof(vproc_shmem->vp_shmem_standby_cnt) newval;
-
         if (unlikely(vpt != (vproc_standby_t)vproc_shmem_init)) {
                 __crashreporter_info__ = "Bogus standby handle passed to vproc_standby_end() ";
                 abort();
         }
+
+        _vproc_standby_end();
+}
+
+void
+_vproc_standby_end(void)
+{
+        typeof(vproc_shmem->vp_shmem_standby_cnt) newval;
 
         newval = __sync_sub_and_fetch(&vproc_shmem->vp_shmem_standby_cnt, 1);

trunk/launchd/src/libvproc_internal.h

@@ -39 +39 @@
         int32_t vp_shmem_transaction_cnt;
         int32_t vp_shmem_standby_cnt;
+        uint32_t vp_shmem_standby_timeout;
         int32_t vp_shmem_flags;
 };

trunk/launchd/src/libvproc_private.h

@@ -77 +77 @@
 vproc_err_t _vprocmgr_move_subset_to_user(uid_t target_user, const char *session_type);
 
-void _basic_vproc_transaction_begin(void);
-void _basic_vproc_transaction_end(void);
-size_t _basic_vproc_transaction_count(void);
-void _basic_vproc_transaction_try_exit(int status);
+void _vproc_standby_begin(void);
+void _vproc_standby_end(void);
+size_t _vproc_standby_count(void);
+size_t _vproc_standby_timeout(void);
+
+void _vproc_transaction_try_exit(int status);
+void _vproc_transaction_begin(void);
+void _vproc_transaction_end(void);
+size_t _vproc_transaction_count(void);