Merge lp:~jamesodhunt/upstart/upstart-shutdown into lp:upstart

[James Hunt]

This branch provides the Session Init shutdown facility.

= Session Init Shutdown as Result of Impending System Shutdown =

Sending SIGTERM to a Session Init is indicative of a system shutdown. In this scenario the Session Init will emit the 'session-end' event and immediately request all jobs stop.

The Session Init will (attempt) to wait for up to the maximum kill_timeout value specified in any running jobs .conf file (5 seconds by default) before they are forcibly killed (although note that system policy may not allow the Session Init to wait as long as it wishes).

= Session Init Shutdown as Result of Logout Request =

The branch also introduces an 'EndSession' D-Bus method which is designed to be called when the user wishes their session to be ended due to a 'logout' request.

In this scenario, the Session Init will emit the 'session-end' event and wait for up to 5 seconds for *new* jobs to react to this event. If no new jobs start or after 5 seconds, the final shutdown phase is entered where all running jobs are requested to stop and after the maximum kill_timeout value specified in any running jobs .conf file is reached (5 seconds by default), the Session Init will exit.

[Stéphane Graber (stgraber)]

I'm using this code in my PPA and I can confirm that session logout works with it. In my case I'm not using the POSIX signals to trigger a shutdown but calling EndSession directly over DBus.

I haven't spent any particular time testing the timeouts and the shutdown signal as in my case everything is part of gnome-session and so is stopping when it does. However I had a quick look and I clearly see the signal being emitted, so that part looks good too.

review: Approve

=== modified file 'ChangeLog'
--- ChangeLog	2013-02-08 16:55:25 +0000
+++ ChangeLog	2013-02-15 11:31:39 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 2013-02-08  James Hunt  <[e-mail]>
 
 	* init/job_process.c: job_process_run(): Copy parent environment if
@@ -5,6 +6,82 @@
 	* init/main.c: Added 'inherit-env' command-line option.
 	* init/man/init.8: Documented --inherit-env.
 
+=======
[phone]  James Hunt  <[e-mail]>
+
+	* util/tests/test_initctl.c:
+	  - timed_waitpid(): Back off if no status change.
+	  - test_quiesce():
+	    - Set XDG_RUNTIME_DIR to a temporary value.
+	    - Remove stale session files.
+	  - test_job_env(): Remove stale session files.
+
[phone]  James Hunt  <[e-mail]>
+
+	* util/tests/test_initctl.c:
+	  - wait_for_upstart(): Functional replacement of WAIT_FOR_UPSTART()
+	    macro. Now accepts @user.
+	  - set_upstart_session(): Poll to ensure we give Upstart time to
+	    initialise and write the session file.
+	  - _start_upstart(): Extra @user parameter.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/Makefile.am: Added quiesce.o, now required by control.o.
+	* init/main.c: main():
+	  - SIGHUP+SIGUSR1 handling now applies however you run init (since
+	    it should react to these signals when run as a Session Init).
+	  - Qualified sessions message to avoid confusion.
+	* util/initctl.c: upstart_open(): Better handling for user_mode.
+	* util/tests/test_initctl.c:
+	  - WAIT_FOR_UPSTART(): Made session-aware.
+	  - KILL_UPSTART(): Reset user mode flag (taken from STOP_UPSTART()).
+	  - set_upstart_session(): New function.
+	  - self_pipe_write(): New Function.
+	  - self_pipe_setup(): New Function.
+	  - timed_waitpid(): New function.
+	  - _start_upstart():
+	     - Signal handling and extra checks.
+	     - Discard init output (unless UPSTART_TEST_VERBOSE set)
+	       for saner logs.
+	  - test_list_sessions():
+	    - Removed need for a dbus-daemon.
+	    - Added required initctl reset.
+	  - test_quiesce(): Tests for Session Init shutdown (both
+	    system-initiated and end-session request).
+	  - test_usage(): Added extra checks and tidyup.
+	  - main(): Added call to test_quiesce().
+
[phone]  James Hunt  <[e-mail]>
+
+	* dbus/com.ubuntu.Upstart.xml: Added 'EndSession' method.
+	* init/Makefile.am: Updated for quiesce.[ch].
+	* init/conf.c: conf_destroy(): Cleanup function.
+	* init/conf.h: Prototype.
+	* init/control.c: control_end_session(): 'EndSession' implemenation.
+	* init/control.h: Include.
+	* init/events.h: Added SESSION_END_EVENT.
+	* init/job_class.c: job_class_max_kill_timeout(): New function.
+	* init/job_class.h: Prototype.
+	* init/job_process.c:
+	  - Added disable_respawn to disallow respawns.
+	  - job_process_jobs_running(): New function.
+	  - job_process_stop_all(): New function.
+	  - job_process_terminated(): Honours disable_respawn.
+	* init/job_process.h: Prototypes.
+	* init/main.c:
+	  - Typos.
+	  - term_handler(): Quiesce rather than re-exec on receipt of SIGTERM
+	    when running as a Session Init.
+	  - main(): Make quiesce() handle cleanup.
+	* init/man/init.8: Update for Session Init SIGTERM handling.
+	* init/man/startup.7: Update for Session Init.
+	* init/session.c: session_destroy(): New function.
+	* init/session.h: Prototype.
+	* init/man/session-end.7: New man page.
+	* init/quiesce.[ch]: New files.
+
+>>>>>>> MERGE-SOURCE
 2013-02-02  James Hunt  <[e-mail]>
 
 	* util/initctl.c: Remove ability to specify explicitly job and/or job

=== modified file 'dbus/com.ubuntu.Upstart.xml'
--- dbus/com.ubuntu.Upstart.xml	2013-01-25 20:08:49 +0000
+++ dbus/com.ubuntu.Upstart.xml	2013-02-15 11:31:39 +0000
@@ -103,6 +103,8 @@
     <method name="NotifyDiskWriteable">
     </method>
 
+    <method name="EndSession"/>
+
     <!-- Basic information about Upstart -->
     <property name="version" type="s" access="read" />
     <property name="log_priority" type="s" access="readwrite" />

=== modified file 'init/Makefile.am'
--- init/Makefile.am	2013-01-21 16:39:28 +0000
+++ init/Makefile.am	2013-02-15 11:31:39 +0000
@@ -31,7 +31,8 @@
 	man/keyboard-request.7 \
 	man/power-status-changed.7 \
 	man/upstart.7 \
-	man/inittab.5
+	man/inittab.5 \
+	man/session-end.7
 
 
 sbin_PROGRAMS = init
@@ -57,6 +58,7 @@
 	conf.c conf.h \
 	control.c control.h \
 	xdg.c xdg.h \
+	quiesce.c quiesce.h \
 	errors.h
 nodist_init_SOURCES = \
 	$(com_ubuntu_Upstart_OUTPUTS) \
@@ -176,7 +178,7 @@
 test_process_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -190,7 +192,7 @@
 test_job_class_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -204,7 +206,7 @@
 test_job_process_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -218,7 +220,7 @@
 test_job_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -232,7 +234,7 @@
 test_log_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -246,7 +248,7 @@
 test_state_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -260,7 +262,7 @@
 test_event_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -274,7 +276,7 @@
 test_event_operator_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -288,7 +290,7 @@
 test_blocked_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -302,7 +304,7 @@
 test_parse_job_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -316,7 +318,7 @@
 test_parse_conf_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -330,7 +332,7 @@
 test_conf_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -344,7 +346,7 @@
 test_conf_static_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o control.o \
+	parse_job.o parse_conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
@@ -365,7 +367,7 @@
 test_control_LDADD = \
 	system.o environ.o process.o \
 	job_class.o job_process.o job.o event.o event_operator.o blocked.o \
-	parse_job.o parse_conf.o conf.o control.o \
+	parse_job.o parse_conf.o conf.o control.o quiesce.o \
 	session.o log.o state.o xdg.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \

=== modified file 'init/conf.c'
--- init/conf.c	2013-01-08 16:15:46 +0000
+++ init/conf.c	2013-02-15 11:31:39 +0000
@@ -321,6 +321,17 @@
 		conf_sources = NIH_MUST (nih_list_new (NULL));
 }
 
+/**
+ * conf_destroy:
+ *
+ * Clear: the conf_sources list.
+ **/
+void
+conf_destroy (void)
+{
+	if (conf_sources)
+		nih_free (conf_sources);
+}
 
 /**
  * conf_source_new:

=== modified file 'init/conf.h'
--- init/conf.h	2012-12-19 12:46:46 +0000
+++ init/conf.h	2013-02-15 11:31:39 +0000
@@ -112,6 +112,7 @@
 
 
 void        conf_init          (void);
+void        conf_destroy       (void);
 
 ConfSource *conf_source_new    (const void *parent, const char *path,
 				ConfSourceType type)

=== modified file 'init/control.c'
--- init/control.c	2013-01-31 17:23:55 +0000
+++ init/control.c	2013-02-15 11:31:39 +0000
@@ -57,6 +57,7 @@
 #include "errors.h"
 #include "state.h"
 #include "event.h"
+#include "events.h"
 #include "paths.h"
 #include "xdg.h"
 
@@ -115,9 +116,9 @@
 NihList *control_conns = NULL;
 
 /* External definitions */
-extern int user_mode;
-
-extern char *session_file;
+extern int      user_mode;
+extern int      disable_respawn;
+extern char    *session_file;
 
 /**
  * control_init:
@@ -1744,3 +1745,50 @@
 	if (session_file)
 		(void)unlink (session_file);
 }
+
+/**
+ * control_session_end:
+ *
+ * @data: not used,
+ * @message: D-Bus connection and message received.
+ *
+ * Implements the EndSession method of the com.ubuntu.Upstart
+ * interface.
+ *
+ * Called to request that Upstart stop all jobs and exit. Only
+ * appropriate when running as a Session Init and user wishes to
+ * 'logout'.
+ *
+ * Returns: zero on success, negative value on raised error.
+ **/
+int
+control_end_session (void             *data,
+		     NihDBusMessage   *message)
+{
+	Session  *session;
+
+	nih_assert (message);
+
+	/* Not supported at the system level */
+	if (getpid () == 1)
+		return 0;
+
+	if (! control_check_permission (message)) {
+		nih_dbus_error_raise_printf (
+			DBUS_INTERFACE_UPSTART ".Error.PermissionDenied",
+			_("You do not have permission to end session"));
+		return -1;
+	}
+
+	/* Get the relevant session */
+	session = session_from_dbus (NULL, message);
+
+	if (session && session->chroot) {
+		nih_warn (_("Ignoring session end request from chroot session"));
+		return 0;
+	}
+
+	quiesce (QUIESCE_REQUESTER_SESSION);
+
+	return 0;
+}

=== modified file 'init/control.h'
--- init/control.h	2013-01-31 17:23:55 +0000
+++ init/control.h	2013-02-15 11:31:39 +0000
@@ -31,6 +31,7 @@
 #include <json.h>
 
 #include "event.h"
+#include "quiesce.h"
 
 /**
  * USE_SESSION_BUS_ENV:

=== modified file 'init/events.h'
--- init/events.h	2009-06-23 09:29:35 +0000
+++ init/events.h	2013-02-15 11:31:39 +0000
@@ -31,6 +31,13 @@
 #define STARTUP_EVENT "debug"
 #endif
 
+/**
+ * SESSION_END_EVENT:
+ *
+ * Name of the event Upstart emits to denote a Session Init
+ * is shutting down.
+ **/
+#define SESSION_END_EVENT "session-end"
 
 /**
  * CTRLALTDEL_EVENT:

=== modified file 'init/job_class.c'
--- init/job_class.c	2013-01-31 17:23:55 +0000
+++ init/job_class.c	2013-02-15 11:31:39 +0000
@@ -2344,3 +2344,33 @@
 
 	return class;
 }
+
+/**
+ * job_class_max_kill_timeout:
+ *
+ * Determine maximum kill timeout for all running jobs.
+ *
+ * Returns: Maximum kill timeout (seconds).
+ **/
+time_t
+job_class_max_kill_timeout (void)
+{
+	time_t kill_timeout = JOB_DEFAULT_KILL_TIMEOUT;
+
+	job_class_init ();
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		JobClass *class = (JobClass *)iter;
+
+		NIH_HASH_FOREACH (class->instances, job_iter) {
+			Job *job = (Job *)job_iter;
+
+			if (job->class->kill_timeout > kill_timeout) {
+				kill_timeout = job->class->kill_timeout;
+				break;
+			}
+		}
+	}
+
+	return kill_timeout;
+}

=== modified file 'init/job_class.h'
--- init/job_class.h	2013-01-25 20:08:49 +0000
+++ init/job_class.h	2013-02-15 11:31:39 +0000
@@ -359,6 +359,9 @@
 JobClass * job_class_find (const Session *session, const char *name)
 	__attribute__ ((warn_unused_result));
 
+time_t     job_class_max_kill_timeout (void)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_CLASS_H */

=== modified file 'init/job_process.c'
--- init/job_process.c	2013-02-14 02:54:10 +0000
+++ init/job_process.c	2013-02-15 11:31:39 +0000
@@ -99,6 +99,13 @@
  **/
 char *log_dir = NULL;
 
+/**
+ * disable_respawn:
+ *
+ * If TRUE, disallow respawning.
+ **/
+int disable_respawn = FALSE;
+
 /* Prototypes for static functions */
 static void job_process_error_abort     (int fd, JobProcessErrorType type,
 					 int arg)
@@ -136,8 +143,14 @@
 static void job_process_trace_fork      (Job *job, ProcessType process);
 static void job_process_trace_exec      (Job *job, ProcessType process);
 
+<<<<<<< TREE
 extern int           user_mode;
+=======
+>>>>>>> MERGE-SOURCE
 extern char         *control_server_address;
+extern int           user_mode;
+extern int           session_end;
+extern time_t        quiesce_phase_time;
 
 /**
  * job_process_run:
@@ -1231,6 +1244,52 @@
 }
 
 /**
+ * job_process_jobs_running:
+ *
+ * Determine if any jobs are running.
+ *
+ * Returns: TRUE if jobs are still running, else FALSE.
+ **/
+int
+job_process_jobs_running (void)
+{
+	job_class_init ();
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		JobClass *class = (JobClass *)iter;
+
+		NIH_HASH_FOREACH (class->instances, job_iter)
+			return TRUE;
+	}
+
+	return FALSE;
+}
+
+
+/**
+ * job_process_stop_all:
+ *
+ * Stop all running jobs.
+ **/
+void
+job_process_stop_all (void)
+{
+	job_class_init ();
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		JobClass *class = (JobClass *)iter;
+
+		/* Note that instances get killed in a random order */
+		NIH_HASH_FOREACH (class->instances, job_iter) {
+			Job *job = (Job *)job_iter;
+
+			/* Request job instance stops */
+			job_change_goal (job, JOB_STOP);
+		}
+	}
+}
+
+/**
  * job_process_set_kill_timer:
  * @job: job to set kill timer for,
  * @process: process to be killed,
@@ -1559,7 +1618,7 @@
 			 * that's a simple matter of doing nothing.  Check
 			 * the job isn't running away first though.
 			 */
-			if (failed && job->class->respawn) {
+			if (failed && job->class->respawn && ! disable_respawn) {
 				if (job_process_catch_runaway (job)) {
 					nih_warn (_("%s respawning too fast, stopped"),
 						  job_name (job));

=== modified file 'init/job_process.h'
--- init/job_process.h	2012-11-26 19:30:41 +0000
+++ init/job_process.h	2013-02-15 11:31:39 +0000
@@ -63,7 +63,6 @@
 #define JOB_PROCESS_LOG_FILE_EXT ".log"
 #endif
 
-
 /**
  * JobProcessErrorType:
  *
@@ -151,6 +150,10 @@
 
 void   job_process_adj_kill_timer  (Job *job, time_t due);
 
+int    job_process_jobs_running (void);
+
+void   job_process_stop_all (void);
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_PROCESS_H */

=== modified file 'init/main.c'
--- init/main.c	2013-02-14 13:36:06 +0000
+++ init/main.c	2013-02-15 11:31:39 +0000
@@ -425,19 +425,20 @@
 		nih_signal_set_handler (SIGPWR, nih_signal_handler);
 		NIH_MUST (nih_signal_add_handler (NULL, SIGPWR, pwr_handler, NULL));
 
-		/* SIGHUP instructs us to re-load our configuration */
-		nih_signal_set_handler (SIGHUP, nih_signal_handler);
-		NIH_MUST (nih_signal_add_handler (NULL, SIGHUP, hup_handler, NULL));
-
-		/* SIGUSR1 instructs us to reconnect to D-Bus */
-		nih_signal_set_handler (SIGUSR1, nih_signal_handler);
-		NIH_MUST (nih_signal_add_handler (NULL, SIGUSR1, usr1_handler, NULL));
-
 	}
 
-	/* SIGTERM instructs us to re-exec ourselves; this should be the
-	 * last in the list to ensure that all other signals are handled
-	 * before a SIGTERM.
+	/* SIGHUP instructs us to re-load our configuration */
+	nih_signal_set_handler (SIGHUP, nih_signal_handler);
+	NIH_MUST (nih_signal_add_handler (NULL, SIGHUP, hup_handler, NULL));
+
+	/* SIGUSR1 instructs us to reconnect to D-Bus */
+	nih_signal_set_handler (SIGUSR1, nih_signal_handler);
+	NIH_MUST (nih_signal_add_handler (NULL, SIGUSR1, usr1_handler, NULL));
+
+	/* SIGTERM instructs us to re-exec ourselves when running as PID
+	 * 1, or to exit when running as a Session Init; this signal should
+	 * be the last in the list to ensure that all other signals are
+	 * handled before a SIGTERM.
 	 */
 	nih_signal_set_handler (SIGTERM, nih_signal_handler);
 	NIH_MUST (nih_signal_add_handler (NULL, SIGTERM, term_handler, NULL));
@@ -634,7 +635,7 @@
 	}
 
 	if (disable_sessions)
-		nih_debug ("Sessions disabled");
+		nih_debug ("Chroot Sessions disabled");
 
 	/* Set us as the child subreaper.
 	 * This ensures that even when init doesn't run as PID 1, it'll always be
@@ -656,8 +657,6 @@
 	nih_main_loop_interrupt ();
 	ret = nih_main_loop ();
 
-	control_cleanup ();
-
 	return ret;
 }
 
@@ -805,7 +804,8 @@
  * @signal: signal caught.
  *
  * This is called when we receive the TERM signal, which instructs us
- * to reexec ourselves.
+ * to reexec ourselves when running as PID 1, or to perform a controlled
+ * exit when running as a Session Init.
  **/
 static void
 term_handler (void      *data,
@@ -814,8 +814,12 @@
 	nih_assert (args_copy[0] != NULL);
 	nih_assert (signal != NULL);
 
+	if (user_mode) {
+		quiesce (QUIESCE_REQUESTER_SYSTEM);
+		return;
+	}
+
 	nih_warn (_("Re-executing %s"), args_copy[0]);
-
 	stateful_reexec ();
 }
 
@@ -826,7 +830,7 @@
  * @data: unused,
  * @signal: signal that called this handler.
  *
- * Handle having recieved the SIGINT signal, sent to us when somebody
+ * Handle having received the SIGINT signal, sent to us when somebody
  * presses Ctrl-Alt-Delete on the console.  We just generate a
  * ctrlaltdel event.
  **/
@@ -842,7 +846,7 @@
  * @data: unused,
  * @signal: signal that called this handler.
  *
- * Handle having recieved the SIGWINCH signal, sent to us when somebody
+ * Handle having received the SIGWINCH signal, sent to us when somebody
  * presses Alt-UpArrow on the console.  We just generate a
  * kbdrequest event.
  **/
@@ -858,7 +862,7 @@
  * @data: unused,
  * @signal: signal that called this handler.
  *
- * Handle having recieved the SIGPWR signal, sent to us when powstatd
+ * Handle having received the SIGPWR signal, sent to us when powstatd
  * changes the /etc/powerstatus file.  We just generate a
  * power-status-changed event and jobs read the file.
  **/
@@ -874,7 +878,7 @@
  * @data: unused,
  * @signal: signal that called this handler.
  *
- * Handle having recieved the SIGHUP signal, which we use to instruct us to
+ * Handle having received the SIGHUP signal, which we use to instruct us to
  * reload our configuration.
  **/
 static void
@@ -890,7 +894,7 @@
  * @data: unused,
  * @signal: signal that called this handler.
  *
- * Handle having recieved the SIGUSR signal, which we use to instruct us to
+ * Handle having received the SIGUSR signal, which we use to instruct us to
  * reconnect to D-Bus.
  **/
 static void

=== modified file 'init/man/init.8'
--- init/man/init.8	2013-02-08 16:55:25 +0000
+++ init/man/init.8	2013-02-15 11:31:39 +0000
@@ -149,8 +149,25 @@
 and pass all arguments to that.  See that manual page for further
 details. However, if the
 .B \-\-user
-option is specified, it will read alternative configuration files and
-manage the individual user session in a similar fashion.
+option is specified, it will run as a
+.B Session Init
+and read alternative configuration files and manage the individual user
+session in a similar fashion.
+
+Sending a Session Init a
+.I SIGTERM
+signal is taken as a request to shutdown due to an impending system
+shutdown. In this scenario, the
+Session Init will emit the 
+.B session\-end
+event and  request all running jobs stop. It will attempt to honour jobs
+.B kill timeout
+values (see
+.BR init (5)
+for further details). Note however that system policy will prevail: if
+jobs request timeout values longer than the system policy allows for
+complete system shutdown, it will not be possible to honour them before
+the Session Init is killed by the system.
 .\"
 .SH ENVIRONMENT VARIABLES
 

=== added file 'init/man/session-end.7'
--- init/man/session-end.7	1970-01-01 00:00:00 +0000
+++ init/man/session-end.7	2013-02-15 11:31:39 +0000
@@ -0,0 +1,34 @@
+.TH session\-end 7 2013-02-08 "Upstart"
+.\"
+.SH NAME
+session\-end \- event signalling session shutdown
+.\"
+.SH SYNOPSIS
+.B session\-end
+.BI TYPE\fR= TYPE
+.\"
+.SH DESCRIPTION
+The
+.B session\-end
+event is generated by the Upstart
+.BR init (8)
+daemon when running as a Session Init (where its pid is not 1) when
+requested to stop.
+
+The
+.B TYPE
+environment variable will be set to either
+.I shutdown
+when the Session Init has received the
+.I SIGTERM
+signal, or
+.I logout
+when the Session Init has processed the
+.B com.ubuntu.Upstart0_6.EndSession()
+D\-Bus method call.
+
+.\"
+.SH SEE ALSO
+.BR startup (7)
+.BR init (5)
+.BR init (8)

=== modified file 'init/man/startup.7'
--- init/man/startup.7	2009-07-09 12:26:11 +0000
+++ init/man/startup.7	2013-02-15 11:31:39 +0000
@@ -27,12 +27,17 @@
 .BR runlevel (7)
 event.  See that page for a more detailed explanation of this process.
 
+This event is emitted when running both as pid 1 and as a Session Init.
+
 Paradoxically there is currently no corresponding Upstart-native event
 signifying that the system is to be shutdown, only the System V compatible
 .B runlevel 0
 and
 .B runlevel 6
-events provide this functionality.
+events provide this functionality. However, when running as a Session
+Init, the
+.BR session\-end
+event performs this function.
 .\"
 .SH EXAMPLE
 A service with no other dependencies run on startup might use:
@@ -45,4 +50,6 @@
 .\"
 .SH SEE ALSO
 .BR runlevel (7)
+.BR session\-end (7)
+.BR init (5)
 .BR init (8)

=== added file 'init/quiesce.c'
--- init/quiesce.c	1970-01-01 00:00:00 +0000
+++ init/quiesce.c	2013-02-15 11:31:39 +0000
@@ -0,0 +1,248 @@
+/* upstart
+ *
+ * quiesce.c - shutdown handling.
+ *
+ * Copyright © 2013 Canonical Ltd.
+ * Author: James Hunt <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include "quiesce.h"
+#include "events.h"
+#include "environ.h"
+#include "conf.h"
+#include "job_process.h"
+#include "control.h"
+
+#include <nih/main.h>
+
+/**
+ * quiesce_requester:
+ *
+ * Where the quiesce request originated. This determines
+ * the shutdown behaviour.
+ **/
+static QuiesceRequester quiesce_requester = QUIESCE_REQUESTER_INVALID;
+
+/**
+ * quiesce_phase:
+ *
+ * Current phase of shutdown.
+ **/
+static QuiescePhase quiesce_phase = QUIESCE_PHASE_NOT_QUIESCED;
+
+/**
+ * max_kill_timeout:
+ *
+ * Maxiumum kill_timout value calculated from all running jobs used to
+ * determine how long to wait before exiting.
+ **/
+static time_t max_kill_timeout = 0;
+
+/**
+ * quiesce_phase_time:
+ *
+ * Time that a particular phase started.
+ **/
+static time_t quiesce_phase_time = 0;
+
+/* External definitions */
+extern int disable_respawn;
+
+/**
+ * quiesce:
+ *
+ * @requester: where the quiesce request originated.
+ *
+ * Commence Session Init shutdown.
+ **/
+void
+quiesce (QuiesceRequester requester)
+{
+	nih_local char  **env = NULL;
+	const char       *reason;
+
+	job_class_init ();
+
+	/* Quiesce already in progress */
+	if (quiesce_phase != QUIESCE_PHASE_NOT_QUIESCED)
+		return;
+
+	quiesce_requester = requester;
+
+	/* System shutdown skips the wait phase to ensure all running
+	 * jobs get signalled.
+	 *
+	 * Note that jobs which choose to start on SESSION_END_EVENT may
+	 * not complete (or even start), but no guarantee is possible in
+	 * the system shutdown scenario since Session Inits must not
+	 * hold up the system.
+	 */
+	quiesce_phase = (requester == QUIESCE_REQUESTER_SYSTEM)
+		? QUIESCE_PHASE_KILL
+		: QUIESCE_PHASE_WAIT;
+
+	reason = (requester == QUIESCE_REQUESTER_SESSION)
+		? _("logout") : _("shutdown");
+
+	nih_info (_("Quiescing due to %s request"), reason);
+
+	quiesce_phase_time = time (NULL);
+
+	/* Stop existing jobs from respawning */
+	disable_respawn = TRUE;
+
+	/* Signal that the session is ending. This may start new jobs.
+	 *
+	 * Note that the event doesn't actually get emitted until the
+	 * next time the main loop gets a chance to run.
+	 */
+	env = NIH_MUST (nih_str_array_new (NULL));
+
+	NIH_MUST (environ_set (&env, NULL, NULL, TRUE,
+				"TYPE=%s", reason));
+
+	NIH_MUST (event_new (NULL, SESSION_END_EVENT, env));
+
+	if (requester == QUIESCE_REQUESTER_SYSTEM) {
+		/* We'll attempt to wait for this long, but system
+		 * policy may prevent it such that we just get killed
+		 * and job processes reparented to PID 1.
+		 */
+		max_kill_timeout = job_class_max_kill_timeout ();
+
+		job_process_stop_all ();
+	}
+
+	/* Check every second to see if all jobs have finished. If so,
+	 * we can exit early.
+	 */
+	NIH_MUST (nih_timer_add_periodic (NULL, 1,
+				(NihTimerCb)quiesce_wait_callback, NULL));
+}
+
+/**
+ * quiesce_wait_callback:
+ *
+ * @data: not used,
+ * @timer: timer that caused us to be called.
+ *
+ * Callback used to check if all jobs have finished and if so
+ * finalise Session Init shutdown.
+ **/
+void
+quiesce_wait_callback (void *data, NihTimer *timer)
+{
+	time_t now;
+
+	nih_assert (timer);
+	nih_assert (quiesce_phase_time);
+
+	now = time (NULL);
+
+	nih_assert (quiesce_requester != QUIESCE_REQUESTER_INVALID);
+
+	if (quiesce_requester == QUIESCE_REQUESTER_SYSTEM) {
+		nih_assert (quiesce_phase == QUIESCE_PHASE_KILL);
+
+		if ((now - quiesce_phase_time) > max_kill_timeout)
+			goto out;
+
+	} else if (quiesce_phase == QUIESCE_PHASE_WAIT) {
+
+		if ((now - quiesce_phase_time) > QUIESCE_DEFAULT_JOB_RUNTIME) {
+			quiesce_phase = QUIESCE_PHASE_KILL;
+
+			/* reset for new phase */
+			quiesce_phase_time = time (NULL);
+
+			max_kill_timeout = job_class_max_kill_timeout ();
+			job_process_stop_all ();
+		}
+	} else if (quiesce_phase == QUIESCE_PHASE_KILL) {
+
+		if ((now - quiesce_phase_time) > max_kill_timeout)
+			goto out;
+	} else {
+		nih_assert_not_reached ();
+	}
+
+	if (! job_process_jobs_running ())
+		goto out;
+
+	return;
+
+out:
+	quiesce_show_slow_jobs ();
+
+	/* Note that we might skip the kill phase for the session
+	 * requestor if no jobs are actually running at this point.
+	 */
+	quiesce_phase = QUIESCE_PHASE_CLEANUP;
+	quiesce_finalise ();
+
+	/* Deregister */
+	nih_free (timer);
+}
+
+/**
+ * quiesce_show_slow_jobs:
+ *
+ * List jobs that are still running after their expected end time.
+ **/
+void
+quiesce_show_slow_jobs (void)
+{
+	job_class_init ();
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		JobClass *class = (JobClass *)iter;
+
+		/* Note that instances get killed in a random order */
+		NIH_HASH_FOREACH (class->instances, job_iter) {
+			nih_local const char  *name = NULL;
+			Job                   *job;
+		       
+			job = (Job *)job_iter;
+
+			name = job_name (job);
+
+			nih_message ("job %s failed to stop", name);
+		}
+	}
+}
+
+
+/**
+ * quiesce_finalise:
+ *
+ * Perform final shutdown operations.
+ **/
+void
+quiesce_finalise (void)
+{
+	nih_assert (quiesce_phase == QUIESCE_PHASE_CLEANUP);
+
+	/* Cleanup */
+	conf_destroy ();
+	session_destroy ();
+	control_cleanup ();
+
+	nih_main_loop_exit (0);
+}

=== added file 'init/quiesce.h'
--- init/quiesce.h	1970-01-01 00:00:00 +0000
+++ init/quiesce.h	2013-02-15 11:31:39 +0000
@@ -0,0 +1,76 @@
+/* upstart
+ *
+ * Copyright © 2013 Canonical Ltd.
+ * Author: James Hunt <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef INIT_QUIESCE_H
+#define INIT_QUIESCE_H
+
+#include <nih/timer.h>
+
+/**
+ * QUIESCE_DEFAULT_JOB_RUNTIME:
+ *
+ * The default maximum length of time to wait after emitting the
+ * SESSION_END_EVENT event before stopping all jobs.
+ **/
+#define QUIESCE_DEFAULT_JOB_RUNTIME 5
+
+/**
+ * QuiesceRequester:
+ *
+ * Reason for Session Init wishing to shutdown; either the Session Init
+ * has been notified the system is being shutdown, or the session has
+ * requested it be ended (for example due to a user logout request).
+ **/
+typedef enum quiesce_requester {
+	QUIESCE_REQUESTER_INVALID = -1,
+	QUIESCE_REQUESTER_SYSTEM = 0,
+	QUIESCE_REQUESTER_SESSION,
+} QuiesceRequester;
+
+/**
+ * QuiescePhase:
+ *
+ * Phase 0: No quiesce operation in progress.
+ *
+ * Phase 1: Wait: Period between SESSION_END_EVENT being emitted and
+ *          QUIESCE_DEFAULT_JOB_RUNTIME being reached.
+ *
+ * Phase 2: Kill: Period between QUIESCE_DEFAULT_JOB_RUNTIME being
+ *          reached and kill signal being sent to all jobs.
+ *
+ * Phase 3: Cleanup: Period between all jobs having ended
+ *          (either naturally or by induction) and final exit.
+ **/
+typedef enum quiesce_phase {
+	QUIESCE_PHASE_NOT_QUIESCED,
+	QUIESCE_PHASE_WAIT,
+	QUIESCE_PHASE_KILL,
+	QUIESCE_PHASE_CLEANUP,
+} QuiescePhase;
+
+NIH_BEGIN_EXTERN
+
+void    quiesce                (QuiesceRequester requester);
+void    quiesce_wait_callback  (void *data, NihTimer *timer);
+void    quiesce_show_slow_jobs (void);
+void    quiesce_finalise       (void);
+
+NIH_END_EXTERN
+
+#endif /* INIT_QUIESCE_H */

=== modified file 'init/session.c'
--- init/session.c	2013-01-25 09:01:00 +0000
+++ init/session.c	2013-02-15 11:31:39 +0000
@@ -89,6 +89,18 @@
 		sessions = NIH_MUST (nih_list_new (NULL));
 }
 
+/**
+ * session_destroy:
+ *
+ * Clean up the sessions list.
+ **/
+void
+session_destroy (void)
+{
+	if (sessions)
+		nih_free (sessions);
+}
+
 
 /**
  * session_new:

=== modified file 'init/session.h'
--- init/session.h	2013-01-25 09:01:00 +0000
+++ init/session.h	2013-02-15 11:31:39 +0000
@@ -78,6 +78,7 @@
 extern NihList *sessions;
 
 void           session_init        (void);
+void           session_destroy     (void);
 
 Session      * session_new         (const void *parent, const char *chroot)
 	__attribute__ ((malloc, warn_unused_result));

=== modified file 'util/initctl.c'
--- util/initctl.c	2013-02-02 16:09:52 +0000
+++ util/initctl.c	2013-02-15 11:31:39 +0000
@@ -372,7 +372,7 @@
 
 		dbus_connection_set_exit_on_disconnect (connection, FALSE);
 	} else {
-		if (dest_name) {
+		if (dest_name && ! user_mode) {
 			fprintf (stderr, _("%s: --dest given without --system\n"),
 				 program_name);
 			nih_main_suggest_help ();

=== modified file 'util/tests/test_initctl.c'
--- util/tests/test_initctl.c	2013-02-02 16:09:52 +0000
+++ util/tests/test_initctl.c	2013-02-15 11:31:39 +0000
@@ -32,6 +32,7 @@
 #include <regex.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <ctype.h>
 
 #include <nih-dbus/dbus_error.h>
 #include <nih-dbus/dbus_connection.h>
@@ -50,6 +51,9 @@
 
 #include "dbus/upstart.h"
 
+#include "com.ubuntu.Upstart.h"
+
+
 #ifndef UPSTART_BINARY
 #error unable to find init binary as UPSTART_BINARY not defined
 #endif /* UPSTART_BINARY */
@@ -60,6 +64,24 @@
 
 #define BUFFER_SIZE 1024
 
+/**
+ * TEST_QUIESCE_WAIT_PHASE:
+ *
+ * Maximum time we expect upstart to wait in the QUIESCE_PHASE_WAIT
+ * phase.
+ **/
+#define TEST_EXIT_TIME 5
+
+/**
+ * TEST_QUIESCE_KILL_PHASE:
+ *
+ * Maximum time we expect upstart to wait in the QUIESCE_PHASE_KILL
+ * phase.
+ **/
+#define TEST_QUIESCE_KILL_PHASE 5
+
+#define TEST_QUIESCE_TOTAL_WAIT_TIME (TEST_EXIT_TIME + TEST_QUIESCE_KILL_PHASE)
+
 /* A 'reasonable' path, but which also contains a marker at the end so
  * we know when we're looking at a PATH these tests have set.
  */
@@ -68,53 +90,66 @@
 /* Default value for TERM if not already set */
 #define TEST_INITCTL_DEFAULT_TERM "linux"
 
+int
+set_upstart_session (void);
+
 /**
- * WAIT_FOR_UPSTART:
+ * wait_for_upstart:
+ *
+ * @user: TRUE if waiting for a Session Init (which uses a private bus
+ * rather than the session bus), else FALSE.
  *
  * Wait for Upstart to appear on D-Bus denoting its completion of
  * initialisation. Wait time is somewhat arbitrary (but more
  * than adequate!).
  **/
-#define WAIT_FOR_UPSTART()                                           \
-{                                                                    \
-	nih_local NihDBusProxy *upstart = NULL;                      \
-	DBusConnection         *connection;                          \
-	char                   *address;                             \
-	NihError               *err;                                 \
-	int                     running = FALSE;                     \
-	                                                             \
-	/* XXX: arbitrary value */                                   \
-	int                     attempts = 10;                       \
-	                                                             \
-	address = getenv ("DBUS_SESSION_BUS_ADDRESS");               \
-	TEST_TRUE (address);                                         \
-	                                                             \
-	while (attempts) {                                           \
-		attempts--;                                          \
-		sleep (1);                                           \
-		connection = nih_dbus_connect (address, NULL);       \
-                                                                     \
-		if (! connection) {                                  \
-			err = nih_error_get ();                      \
-			nih_free (err);                              \
-			continue;                                    \
-		}                                                    \
-		                                                     \
-		upstart = nih_dbus_proxy_new (NULL, connection,      \
-				      	      NULL,                  \
-					      DBUS_PATH_UPSTART,     \
-				      	      NULL, NULL);           \
-		                                                     \
-		if (! upstart) {                                     \
-			err = nih_error_get ();                      \
-			nih_free (err);                              \
-			dbus_connection_unref (connection);          \
-		} else {                                             \
-			running = TRUE;                              \
-			break;                                       \
-		}                                                    \
-	}                                                            \
-	TEST_EQ (running, TRUE);                                     \
+void
+wait_for_upstart (int user)
+{
+	nih_local NihDBusProxy *upstart = NULL;
+	DBusConnection         *connection;
+	char                   *address;
+	NihError               *err;
+	int                     running = FALSE;
+
+	/* XXX: arbitrary value */
+	int                     attempts = 10;
+
+	if (user) {
+		set_upstart_session ();
+		address = getenv ("UPSTART_SESSION");
+	} else {
+		address = getenv ("DBUS_SESSION_BUS_ADDRESS");
+	}
+
+	TEST_TRUE (address);
+
+	while (attempts) {
+		attempts--;
+		sleep (1);
+		connection = nih_dbus_connect (address, NULL);
+
+		if (! connection) {
+			err = nih_error_get ();
+			nih_free (err);
+			continue;
+		}
+
+		upstart = nih_dbus_proxy_new (NULL, connection,
+				      	      NULL,
+					      DBUS_PATH_UPSTART,
+				      	      NULL, NULL);
+
+		if (! upstart) {
+			err = nih_error_get ();
+			nih_free (err);
+			dbus_connection_unref (connection);
+		} else {
+			running = TRUE;
+			break;
+		}
+	}
+	TEST_EQ (running, TRUE);
 }
 
 /**
@@ -150,6 +185,10 @@
 		TEST_TRUE (WIFSIGNALED (status));                    \
 		TEST_TRUE (WTERMSIG (status) == signo);              \
 	}                                                            \
+	/* reset since a subsequent start could specify a different  \
+	 * user_mode value.                                          \
+	 */                                                          \
+	test_user_mode = FALSE;                                      \
 }
 
 /**
@@ -160,11 +199,7 @@
  * Stop upstart process @pid.
  **/
 #define STOP_UPSTART(pid)                                            \
-	KILL_UPSTART (pid, SIGKILL, TRUE);                           \
-	/* reset since a subsequent start could specify a different  \
-	 * user_mode value.                                          \
-	 */                                                          \
-	test_user_mode = FALSE
+	KILL_UPSTART (pid, SIGKILL, TRUE)
 
 /**
  * REEXEC_UPSTART:
@@ -175,7 +210,7 @@
  **/
 #define REEXEC_UPSTART(pid)                                          \
 	KILL_UPSTART (pid, SIGTERM, FALSE);                          \
-	WAIT_FOR_UPSTART ()
+	wait_for_upstart (FALSE)
 
 /**
  * RUN_COMMAND:
@@ -475,6 +510,204 @@
 int test_user_mode = FALSE;
 
 /**
+ * set_upstart_session:
+ *
+ * Attempt to "enter" an Upstart session by setting UPSTART_SESSION to
+ * the value of the currently running session.
+ *
+ * It is only legitimate to call this function if you have previously
+ * started a Session Init process.
+ *
+ * Limitations: Assumes that at most 1 session is running.
+ *
+ * Returns: TRUE if it was possible to enter the currently running
+ * Upstart session, else FALSE.
+ **/
+int
+set_upstart_session (void)
+{
+	char                     *value;
+	nih_local char           *cmd = NULL;
+	nih_local char          **output = NULL;
+	size_t                    lines = 0;
+	int                       got = FALSE;
+	int                       i;
+
+	/* XXX: arbitrary value */
+	int                       loops = 5;
+
+	/* list-sessions relies on this */
+	if (! getenv ("XDG_RUNTIME_DIR"))
+		return FALSE;
+
+	cmd = nih_sprintf (NULL, "%s list-sessions 2>&1", INITCTL_BINARY);
+	TEST_NE_P (cmd, NULL);
+
+	/* We expect the list-sessions command to return a valid session
+	 * within a reasonable period of time.
+	 */
+	for (i = 0; i < loops; i++) {
+		sleep (1);
+
+		RUN_COMMAND (NULL, cmd, &output, &lines);
+		if (lines != 1)
+			continue;
+
+		/* No pid in output */
+		if (! isdigit(output[0][0]))
+			continue;
+
+		/* look for separator between pid and value of
+		 * UPSTART_SESSION.
+		 */
+		value = strstr (output[0], " ");
+		if (! value)
+			continue;
+
+		/* jump over space */
+		value  += 1;
+		if (! value)
+			continue;
+
+		/* No socket address */
+		if (strstr (value, "unix:abstract") == value) {
+			got = TRUE;
+			break;
+		}
+	}
+
+	if (got != TRUE)
+		return FALSE;
+
+	assert0 (setenv ("UPSTART_SESSION", value, 1));
+
+	return TRUE;
+}
+
+/**
+ * selfpipe:
+ *
+ * Used to allow a timed process wait.
+ **/
+int selfpipe[2] = { -1, -1 };
+
+void
+selfpipe_write (int n)
+{
+    assert (selfpipe[1] != -1);
+
+    (void)write (selfpipe[1], "", 1);
+}
+
+/**
+ * selfpipe_setup:
+ *
+ * Arrange for SIGCHLD to write to selfpipe such that we can select(2)
+ * on child process status changes.
+ **/
+void
+selfpipe_setup (void)
+{
+    static struct sigaction  act;
+    int                      read_flags;
+    int                      write_flags;
+
+    assert (selfpipe[0] == -1);
+
+    assert (! pipe (selfpipe));
+
+    /* Set non-blocking */
+    read_flags = fcntl (selfpipe[0], F_GETFL);
+    write_flags = fcntl (selfpipe[1], F_GETFL);
+
+    read_flags |= O_NONBLOCK;
+    write_flags |= O_NONBLOCK;
+
+    assert (fcntl (selfpipe[0], F_SETFL, read_flags) == 0);
+    assert (fcntl (selfpipe[1], F_SETFL, write_flags) == 0);
+
+    /* Don't leak */
+    assert (fcntl (selfpipe[0], F_SETFD, FD_CLOEXEC) == 0);
+    assert (fcntl (selfpipe[1], F_SETFD, FD_CLOEXEC) == 0);
+
+    memset (&act, 0, sizeof (act));
+
+    /* register SIGCHLD handler which will cause pipe write when child
+     * changes state.
+     */
+    act.sa_handler = selfpipe_write;
+
+    sigaction (SIGCHLD, &act, NULL);
+}
+
+/**
+ * timed_waitpid:
+ *
+ * @pid: pid to wait for,
+ * @timeout: seconds to wait for @pid to change state.
+ *
+ * Simplified waitpid(2) with timeout using a pipe to allow select(2)
+ * with timeout to be used to wait for process state change.
+ **/
+pid_t
+timed_waitpid (pid_t pid, time_t timeout)
+{
+    static char     buffer[1];
+    fd_set          read_fds;
+    struct timeval  tv;
+    int             status;
+    int             nfds;
+    int             ret;
+    pid_t           ret2;
+
+    assert (pid);
+    assert (timeout);
+
+    if (selfpipe[0] == -1)
+	    selfpipe_setup ();
+
+    FD_ZERO (&read_fds);
+    FD_SET (selfpipe[0], &read_fds);
+
+    nfds = 1 + selfpipe[0];
+
+    tv.tv_sec   = timeout;
+    tv.tv_usec  = 0;
+
+    /* wait for some activity */
+    ret = select (nfds, &read_fds, NULL, NULL, &tv);
+
+    if (! ret)
+	    /* timed out */
+	    return 0;
+
+    /* discard any data written to pipe */
+    while (read (selfpipe[0], buffer, sizeof (buffer)) > 0)
+	    ;
+
+    while (TRUE) {
+	    /* wait for status change or error */
+	    ret2 = waitpid (pid, &status, WNOHANG);
+
+	    if (ret2 < 0)
+		    return -1;
+
+	    if (! ret2)
+		    /* give child a chance to change state */
+		    sleep (1);
+
+	    if (ret2) {
+		    if (WIFEXITED (status))
+			    return ret2;
+
+		    /* unexpected status change */
+		    return -1;
+	    }
+    }
+}
+
+
+/**
  * get_initctl():
  *
  * Determine a suitable initctl command-line for testing purposes.
@@ -504,6 +737,8 @@
  * _start_upstart:
  *
  * @pid: PID of running instance,
+ * @user: TRUE if upstart will run in User Session mode (FALSE to
+ *  use the users D-Bus session bus),
  * @args: optional list of arguments to specify.
  *
  * Start an instance of Upstart.
@@ -511,9 +746,10 @@
  * If the instance fails to start, abort(3) is called.
  **/
 void
-_start_upstart (pid_t *pid, char * const *args)
+_start_upstart (pid_t *pid, int user, char * const *args)
 {
 	nih_local char  **argv = NULL;
+	sigset_t          child_set, orig_set;
 
 	assert (pid);
 
@@ -525,12 +761,29 @@
 	if (args)
 		NIH_MUST (nih_str_array_append (&argv, NULL, NULL, args));
 
+	sigfillset (&child_set);
+	sigprocmask (SIG_BLOCK, &child_set, &orig_set);
+
 	TEST_NE (*pid = fork (), -1);
 
-	if (*pid == 0)
-		execv (argv[0], argv);
-
-	WAIT_FOR_UPSTART ();
+	if (! *pid) {
+		int fd;
+		nih_signal_reset ();
+		sigprocmask (SIG_SETMASK, &orig_set, NULL);
+
+		if (! getenv ("UPSTART_TEST_VERBOSE")) {
+			fd = open ("/dev/null", O_RDWR);
+			assert (fd >= 0);
+			assert (dup2 (fd, STDIN_FILENO) != -1);
+			assert (dup2 (fd, STDOUT_FILENO) != -1);
+			assert (dup2 (fd, STDERR_FILENO) != -1);
+		}
+
+		assert (execv (argv[0], argv) != -1);
+	}
+
+	sigprocmask (SIG_SETMASK, &orig_set, NULL);
+	wait_for_upstart (user);
 }
 
 /**
@@ -588,7 +841,7 @@
 	if (extra)
 		NIH_MUST (nih_str_array_append (&args, NULL, NULL, extra));
 
-	_start_upstart (pid, args);
+	_start_upstart (pid, user, args);
 }
 
 /**
@@ -11782,9 +12035,7 @@
 	char             dirname[PATH_MAX];
 	char             confdir[PATH_MAX];
 	nih_local char  *cmd = NULL;
-	nih_local char  **args = NULL;
 	pid_t            upstart_pid = 0;
-	pid_t            dbus_pid    = 0;
 	char           **output;
 	size_t           lines;
 	struct stat      statbuf;
@@ -11839,12 +12090,10 @@
 	TEST_EQ (setenv ("UPSTART_CONFDIR", confdir, 1), 0);
 	TEST_EQ (setenv ("XDG_RUNTIME_DIR", dirname, 1), 0);
 
-	args = NIH_MUST (nih_str_array_new (NULL));
-	NIH_MUST (nih_str_array_add (&args, NULL, NULL, "--user"));
+	/* Reset initctl global from previous tests */
+	dest_name = NULL;
 
-	/* Start to create session file */
-	TEST_DBUS (dbus_pid);
-	start_upstart_common (&upstart_pid, FALSE, NULL, NULL, args);
+	start_upstart_common (&upstart_pid, TRUE, NULL, NULL, NULL);
 
 	session_file = nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
 			dirname, (int)upstart_pid);
@@ -11877,7 +12126,6 @@
 	nih_free (output);
 
 	STOP_UPSTART (upstart_pid);
-	TEST_DBUS_END (dbus_pid);
 
 	/* Upstart cannot yet be instructed to shutdown cleanly, so for
 	 * now we have to remove the session file manually.
@@ -11908,6 +12156,571 @@
 }
 
 void
+test_quiesce (void)
+{
+	char                      confdir[PATH_MAX];
+	char                      logdir[PATH_MAX];
+	char                      sessiondir[PATH_MAX];
+	nih_local char           *cmd = NULL;
+	pid_t                     upstart_pid = 0;
+	nih_local char           *logfile = NULL;
+	FILE                     *file;
+	char                    **output;
+	size_t                    lines;
+	nih_local NihDBusProxy   *upstart = NULL;
+	nih_local char           *orig_xdg_runtime_dir = NULL;
+	nih_local char           *session_file = NULL;
+
+	TEST_GROUP ("Session Init quiesce");
+
+        TEST_FILENAME (confdir);
+        TEST_EQ (mkdir (confdir, 0755), 0);
+
+        TEST_FILENAME (logdir);
+        TEST_EQ (mkdir (logdir, 0755), 0);
+
+        TEST_FILENAME (sessiondir);
+        TEST_EQ (mkdir (sessiondir, 0755), 0);
+
+	/* Take care to avoid disrupting users environment by saving and
+	 * restoring this variable (assuming the tests all pass...).
+	 */
+	orig_xdg_runtime_dir = getenv ("XDG_RUNTIME_DIR");
+	if (orig_xdg_runtime_dir)
+		orig_xdg_runtime_dir = NIH_MUST (nih_strdup (NULL, orig_xdg_runtime_dir));
+
+	/* Use the "secret" interface */
+	TEST_EQ (setenv ("UPSTART_CONFDIR", confdir, 1), 0);
+	TEST_EQ (setenv ("UPSTART_LOGDIR", logdir, 1), 0);
+	TEST_EQ (setenv ("XDG_RUNTIME_DIR", sessiondir, 1), 0);
+
+	/* Reset initctl global from previous tests */
+	dest_name = NULL;
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: no jobs");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: one long-running job");
+
+	CREATE_FILE (confdir, "long-running.conf",
+			"exec sleep 999");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: one long-running job which ignores SIGTERM");
+
+	CREATE_FILE (confdir, "long-running-term.conf",
+			"script\n"
+			"  trap '' TERM\n"
+		        "  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running-term");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running-term.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: one job which starts on session-end");
+
+	CREATE_FILE (confdir, "session-end.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  echo hello\n"
+			"  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	logfile = NIH_MUST (nih_sprintf (NULL, "%s/%s",
+				logdir,
+				"session-end.log"));
+
+	file = fopen (logfile, "r");
+	TEST_NE_P (file, NULL);
+	TEST_FILE_EQ (file, "hello\r\n");
+	TEST_FILE_END (file);
+	TEST_EQ (fclose (file), 0);
+	assert0 (unlink (logfile));
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "session-end.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: one job which starts on session-end and ignores SIGTERM");
+
+	CREATE_FILE (confdir, "session-end-term.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  trap '' TERM\n"
+			"  echo hello\n"
+			"  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	logfile = NIH_MUST (nih_sprintf (NULL, "%s/%s",
+				logdir,
+				"session-end-term.log"));
+
+	file = fopen (logfile, "r");
+	TEST_NE_P (file, NULL);
+	TEST_FILE_EQ (file, "hello\r\n");
+	TEST_FILE_END (file);
+	TEST_EQ (fclose (file), 0);
+	assert0 (unlink (logfile));
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "session-end-term.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("system shutdown: 2 jobs "
+			"(1 long-running job which ignores SIGTERM, "
+			"1 which starts on session-end and ignores SIGTERM)");
+
+	CREATE_FILE (confdir, "long-running-term.conf",
+			"script\n"
+			"  trap '' TERM\n"
+		        "  sleep 999\n"
+			"end script");
+
+	CREATE_FILE (confdir, "session-end-term.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  trap '' TERM\n"
+			"  sleep 999\n"
+			"end script");
+
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running-term");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	/* Trigger shutdown */
+	assert0 (kill (upstart_pid, SIGTERM));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running-term.conf");
+	DELETE_FILE (confdir, "session-end-term.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: no jobs");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	/* Further required initctl global resets. Shudder. */
+	user_mode = TRUE;
+	use_dbus = -1;
+	dbus_bus_type = DBUS_BUS_SESSION;
+	dbus_bus_type = -1;
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	/* no jobs, so Session Init should shutdown "immediately" */
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: one long-running job");
+
+	CREATE_FILE (confdir, "long-running.conf",
+			"exec sleep 999");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: one long-running job which ignores SIGTERM");
+
+	CREATE_FILE (confdir, "long-running-term.conf",
+			"script\n"
+			"  trap '' TERM\n"
+		        "  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running-term.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: one job which starts on session-end");
+
+	CREATE_FILE (confdir, "session-end.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  echo hello\n"
+			"  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	logfile = NIH_MUST (nih_sprintf (NULL, "%s/%s",
+				logdir,
+				"session-end.log"));
+
+	file = fopen (logfile, "r");
+	TEST_NE_P (file, NULL);
+	TEST_FILE_EQ (file, "hello\r\n");
+	TEST_FILE_END (file);
+	TEST_EQ (fclose (file), 0);
+	assert0 (unlink (logfile));
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "session-end.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: one job which starts on session-end");
+
+	CREATE_FILE (confdir, "session-end-term.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  trap '' TERM\n"
+			"  echo hello\n"
+			"  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_KILL_PHASE), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	logfile = NIH_MUST (nih_sprintf (NULL, "%s/%s",
+				logdir,
+				"session-end-term.log"));
+
+	file = fopen (logfile, "r");
+	TEST_NE_P (file, NULL);
+	TEST_FILE_EQ (file, "hello\r\n");
+	TEST_FILE_END (file);
+	TEST_EQ (fclose (file), 0);
+	assert0 (unlink (logfile));
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "session-end-term.conf");
+
+	/*******************************************************************/
+	TEST_FEATURE ("session shutdown: 2 jobs "
+			"(1 long-running job which ignores SIGTERM, "
+			"1 which starts on session-end and ignores SIGTERM)");
+
+	CREATE_FILE (confdir, "long-running-term.conf",
+			"script\n"
+			"  trap '' TERM\n"
+		        "  sleep 999\n"
+			"end script");
+
+	CREATE_FILE (confdir, "session-end-term.conf",
+			"start on session-end\n"
+			"\n"
+			"script\n"
+			"  trap '' TERM\n"
+			"  sleep 999\n"
+			"end script");
+
+	start_upstart_common (&upstart_pid, TRUE, confdir, logdir, NULL);
+
+	cmd = nih_sprintf (NULL, "%s start %s 2>&1",
+			get_initctl (), "long-running-term");
+	TEST_NE_P (cmd, NULL);
+
+	RUN_COMMAND (NULL, cmd, &output, &lines);
+	TEST_EQ (lines, 1);
+	nih_free (output);
+
+	upstart = upstart_open (NULL);
+	TEST_NE_P (upstart, NULL);
+
+	/* Should be running */
+	assert0 (kill (upstart_pid, 0));
+
+	/* Force reset */
+	test_user_mode = FALSE;
+
+	/* Trigger session shutdown */
+	assert0 (upstart_end_session_sync (NULL, upstart));
+
+	TEST_EQ (timed_waitpid (upstart_pid, TEST_QUIESCE_TOTAL_WAIT_TIME), upstart_pid);
+
+	/* Should not now be running */
+	TEST_EQ (kill (upstart_pid, 0), -1);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				sessiondir, (int)upstart_pid));
+	unlink (session_file);
+
+	DELETE_FILE (confdir, "long-running-term.conf");
+	DELETE_FILE (confdir, "session-end-term.conf");
+
+	/*******************************************************************/
+	assert0 (unsetenv ("UPSTART_CONFDIR"));
+	assert0 (unsetenv ("UPSTART_LOGDIR"));
+
+	if (orig_xdg_runtime_dir) {
+		/* restore */
+		setenv ("XDG_RUNTIME_DIR", orig_xdg_runtime_dir, 1);
+	} else {
+		assert0 (unsetenv ("XDG_RUNTIME_DIR"));
+	}
+
+        TEST_EQ (rmdir (logdir), 0);
+        TEST_EQ (rmdir (confdir), 0);
+
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions", sessiondir));
+        TEST_EQ (rmdir (session_file), 0);
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart", sessiondir));
+        TEST_EQ (rmdir (session_file), 0);
+        TEST_EQ (rmdir (sessiondir), 0);
+
+	/*******************************************************************/
+}
+
+void
 test_show_config (void)
 {
 	char             dirname[PATH_MAX];
@@ -15570,6 +16383,9 @@
 	out = tmpfile ();
 	err = tmpfile ();
 
+	TEST_NE_P (out, NULL);
+	TEST_NE_P (err, NULL);
+
 	TEST_DIVERT_STDOUT (out) {
 		TEST_DIVERT_STDERR (err) {
 			ret = status_action (&command, args);
@@ -15588,12 +16404,16 @@
 	TEST_FILE_END (err);
 	TEST_FILE_RESET (err);
 
+	assert0 (fclose (out));
+	assert0 (fclose (err));
+
 	DELETE_FILE (dirname, "foo.conf");
 
-
 	STOP_UPSTART (upstart_pid);
 	TEST_EQ (unsetenv ("UPSTART_CONFDIR"), 0);
 	TEST_DBUS_END (dbus_pid);
+
+	assert0 (rmdir (dirname));
 }
 
 void
@@ -16525,6 +17345,7 @@
 	nih_local char  *orig_xdg_runtime_dir = NULL;
 	nih_local char  *cmd = NULL;
 	char           **output;
+	nih_local char  *session_file = NULL;
 
 	TEST_GROUP ("job process table commands");
 
@@ -16589,6 +17410,15 @@
 	assert0 (unsetenv ("UPSTART_LOGDIR"));
 	assert0 (unsetenv ("UPSTART_SESSION"));
 
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions/%d.session",
+				runtimedir, (int)upstart_pid));
+	unlink (session_file);
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart/sessions", runtimedir));
+        TEST_EQ (rmdir (session_file), 0);
+	session_file = NIH_MUST (nih_sprintf (NULL, "%s/upstart", runtimedir));
+        TEST_EQ (rmdir (session_file), 0);
+        TEST_EQ (rmdir (runtimedir), 0);
+
 	if (orig_xdg_runtime_dir) {
 		/* restore */
 		setenv ("XDG_RUNTIME_DIR", orig_xdg_runtime_dir, 1);
@@ -16675,6 +17505,7 @@
 	test_job_env ();
 	test_reexec ();
 	test_list_sessions ();
+	test_quiesce ();
 
 	if (in_chroot () && !dbus_configured ()) {
 		fprintf(stderr, "\n\n"