Merge lp:~upstart-devel/upstart/stateful-reexec into lp:upstart

[James Hunt]

* Added stateful re-exec support such that when Upstart is asked
  to restart itself using 'telinit u', the new instance of PID 1
  will retain knowledge of all system jobs and running instances.

See also: https://wiki.ubuntu.com/FoundationsTeam/Specs/QuantalUpstartStatefulReexec

[lp:~upstart-devel/upstart/stateful-reexec]

1473. By James Hunt on 2012-11-07

Upstream sync.

1474. By James Hunt on 2012-11-14

Sync with lp:~upstart-devel/upstart/stateful-reexec.

1475. By James Hunt on 2012-11-14

* init/job_class.c: Formatting.
* init/log.c: Corrected documentation for log_unflushed_files.
* init/state.h: Explained why log_unflushed_files is not currently
  serialised.

1476. By James Hunt on 2012-11-14

* extra/man/upstart-udev-bridge.8: Corrected explanation of actions in
  udev events (thanks to Stefan Bader for pointing out this problem).
* init/blocked.c: blocked_type_str_to_enum(): Assert argument.
* init/job_class.c: job_class_expect_type_str_to_enum(): Assert
  argument.
* init/job_process.c: job_process_run(): Reverted unnecessary check on 'p'.
* init/log.c: log_deserialise(): Added cast and explanation why return code
  from state_toggle_cloexec() not checked.
* init/process.c: process_type_str_to_enum(): Assert argument.
* init/session.c:
  - session_create_conf_source(): Removed redundant getenv() call.
  - session_deserialise(): Removed incorrect uid_t initialisation.
* init/state.h:
  - state_get_json_str_array_generic(): Actually use env parameter.
  - Remove warn_unused_result from state_toggle_cloexec() to avoid compile
    failure with strict flags.
* init/tests/test_state.c:
  - Use rlim_t.
  - test_enums():
    - Don't call *_str_to_enum() if previous *_enum_to_str() failed.
    - Add additional checks for invalid enum values.
  - main(): Remove redundant setenv().
* init/tests/test_util.c: string_check(): Make initial test less
  cryptic.

Unmerged revisions

=== modified file 'ChangeLog'
--- ChangeLog	2012-10-22 13:54:50 +0000
+++ ChangeLog	2012-11-07 15:22:20 +0000
@@ -1,3 +1,19 @@
[phone]  James Hunt  <[e-mail]>
+
+	* Added stateful re-exec support such that when Upstart is asked
+	  to restart itself using 'telinit u', the new instance of PID 1
+	  will retain knowledge of all system jobs and running instances.
+
[phone]  James Hunt  <[e-mail]>
+
+	* Merged lp:~jconti/upstart/fix_empty_chroot.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/main.c: Add in "bare" re-exec handling from Ubuntu
+	  branch.
+	* init/main.c: Unhide "restart" option.
+
 2012-10-22  James Hunt  <[e-mail]>
 
 	* init/parse_job.c: stanza_kill(): Actually save parsed

=== modified file 'configure.ac'
--- configure.ac	2012-03-22 11:37:20 +0000
+++ configure.ac	2012-11-07 15:22:20 +0000
@@ -32,6 +32,24 @@
 PKG_CHECK_MODULES([DBUS], [dbus-1 >= 1.2.16])
 PKG_CHECK_MODULES([UDEV], [libudev >= 146], [have_udev=yes], [have_udev=no])
 
+# Reasons for requiring this library version:
+#
+# 1) RFC 4627, the JSON "memo" (it is *NOT* a standard!) helpfully fails
+#    to specify the maximum size of an integer type. And yet, JSON is
+#    supposedly a subset of ECMA-262, which specifies a Number type to
+#    be 64-bits.
+#
+#    The loose JSON "memo" might expalain why older versions of JSON-C encode
+#    a JSON Number in sizoef(int) bytes which is only 32-bits on 32-bit
+#    systems. This is not acceptable for Upstart which needs to be able
+#    to encode 'size_t' and 'unsigned long' types which can be larger
+#    than 'int'.
+#
+# 2) New json_tokener_parse_verbose() function required to detect invalid
+#    JSON (!)
+#
+PKG_CHECK_MODULES([JSON], [json >= 0.10])
+
 AM_CONDITIONAL([HAVE_UDEV], [test "$have_udev" = yes])
 
 # Checks for header files.
@@ -42,6 +60,21 @@
 AM_PROG_CC_C_O
 NIH_C_THREAD
 
+AC_CHECK_SIZEOF(int)
+AC_CHECK_SIZEOF(uid_t)
+AC_CHECK_SIZEOF(pid_t)
+AC_CHECK_SIZEOF(time_t)
+AC_CHECK_SIZEOF(mode_t)
+AC_CHECK_SIZEOF(size_t)
+AC_CHECK_SIZEOF(ssize_t)
+
+# Unlikely to hit this limit for a while, but it pays to be safe.
+for type in int uid_t pid_t time_t mode_t size_t ssize_t
+do
+	eval value="\$ac_cv_sizeof_${type}"
+	test "$value" -gt 8 && AC_MSG_ERROR([type $type is $value bytes, larger than JSON-C can represent])
+done
+
 # Checks for library functions.
 
 # Other checks

=== modified file 'init/Makefile.am'
--- init/Makefile.am	2012-10-22 13:54:50 +0000
+++ init/Makefile.am	2012-11-07 15:22:20 +0000
@@ -5,7 +5,8 @@
 AM_CFLAGS = \
 	$(NIH_CFLAGS) \
 	$(NIH_DBUS_CFLAGS) \
-	$(DBUS_CFLAGS)
+	$(DBUS_CFLAGS) \
+	$(JSON_CFLAGS)
 
 AM_CPPFLAGS = \
 	-DLOCALEDIR="\"$(localedir)\"" \
@@ -41,6 +42,7 @@
 	environ.c environ.h \
 	process.c process.h \
 	session.c session.h \
+	state.c state.h \
 	job_class.c job_class.h \
 	job_process.c job_process.h \
 	job.c job.h \
@@ -62,6 +64,7 @@
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
 	$(DBUS_LIBS) \
+	$(JSON_LIBS) \
 	-lrt
 
 
@@ -109,7 +112,6 @@
 		--default-interface=com.ubuntu.Upstart0_6.Instance \
 		--output=$@ $<
 
-
 # These have to be built sources because we can't compile object files
 # without the header file existing first
 BUILT_SOURCES = \
@@ -125,6 +127,8 @@
 
 EXTRA_DIST = init.supp
 
+test_util_SOURCES = \
+	tests/test_util.c tests/test_util.h
 
 TESTS = \
 	test_system \
@@ -134,6 +138,7 @@
 	test_job_process \
 	test_job \
 	test_log \
+	test_state \
 	test_event \
 	test_event_operator \
 	test_blocked \
@@ -156,41 +161,44 @@
 	environ.o \
 	$(NIH_LIBS)
 
-test_process_SOURCES = tests/test_process.c
+test_process_SOURCES = tests/test_process.c $(test_util_SOURCES)
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_job_class_SOURCES = tests/test_job_class.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
-test_job_process_SOURCES = tests/test_job_process.c
+test_job_process_SOURCES = tests/test_job_process.c $(test_util_SOURCES)
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
 	$(DBUS_LIBS) \
+	$(JSON_LIBS) \
 	-lutil
 
 test_job_SOURCES = tests/test_job.c
@@ -198,24 +206,40 @@
 	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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
-test_log_SOURCES = tests/test_log.c
+test_log_SOURCES = tests/test_log.c $(test_util_SOURCES)
 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 \
-	session.o log.o \
-	com.ubuntu.Upstart.o \
-	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
-	$(NIH_LIBS) \
-	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS) \
+	session.o log.o state.o \
+	com.ubuntu.Upstart.o \
+	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
+	$(NIH_LIBS) \
+	$(NIH_DBUS_LIBS) \
+	$(DBUS_LIBS) \
+	$(JSON_LIBS) \
+	-lutil
+
+test_state_SOURCES = tests/test_state.c $(test_util_SOURCES)
+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 \
+	session.o log.o state.o \
+	com.ubuntu.Upstart.o \
+	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
+	$(NIH_LIBS) \
+	$(NIH_DBUS_LIBS) \
+	$(DBUS_LIBS) \
+	$(JSON_LIBS) \
 	-lutil
 
 test_event_SOURCES = tests/test_event.c
@@ -223,84 +247,91 @@
 	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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_event_operator_SOURCES = tests/test_event_operator.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_blocked_SOURCES = tests/test_blocked.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_parse_job_SOURCES = tests/test_parse_job.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_parse_conf_SOURCES = tests/test_parse_conf.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
-test_conf_SOURCES = tests/test_conf.c
+test_conf_SOURCES = tests/test_conf.c $(test_util_SOURCES)
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 test_control_SOURCES = tests/test_control.c
 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 \
-	session.o log.o \
+	session.o log.o state.o \
 	com.ubuntu.Upstart.o \
 	com.ubuntu.Upstart.Job.o com.ubuntu.Upstart.Instance.o \
 	$(NIH_LIBS) \
 	$(NIH_DBUS_LIBS) \
-	$(DBUS_LIBS)
+	$(DBUS_LIBS) \
+	$(JSON_LIBS)
 
 
 install-data-local:

=== modified file 'init/blocked.c'
--- init/blocked.c	2009-06-23 09:29:35 +0000
+++ init/blocked.c	2012-11-07 15:22:20 +0000
@@ -92,3 +92,58 @@
 
 	return blocked;
 }
+
+
+/**
+ * blocked_enum_to_str:
+ *
+ * @type: BlockedType.
+ *
+ * Convert Blocked to a string representation.
+ *
+ * Returns: string representation of @type, or NULL if not known.
+ **/
+const char *
+blocked_type_enum_to_str (BlockedType type)
+{
+	state_enum_to_str (BLOCKED_JOB, type);
+	state_enum_to_str (BLOCKED_EVENT, type);
+	state_enum_to_str (BLOCKED_EMIT_METHOD, type);
+	state_enum_to_str (BLOCKED_JOB_START_METHOD, type);
+	state_enum_to_str (BLOCKED_JOB_STOP_METHOD, type);
+	state_enum_to_str (BLOCKED_JOB_RESTART_METHOD, type);
+	state_enum_to_str (BLOCKED_INSTANCE_START_METHOD, type);
+	state_enum_to_str (BLOCKED_INSTANCE_STOP_METHOD, type);
+	state_enum_to_str (BLOCKED_INSTANCE_RESTART_METHOD, type);
+
+	return NULL;
+}
+
+/**
+ * blocked_type_str_to_enum:
+ *
+ * @type: string BlockedType value.
+ *
+ * Convert @type back into enum value.
+ *
+ * Returns: BlockedType representation of @type, or -1 if not known.
+ **/
+BlockedType
+blocked_type_str_to_enum (const char *type)
+{
+	if (! type)
+		goto error;
+
+	state_str_to_enum (BLOCKED_JOB, type);
+	state_str_to_enum (BLOCKED_EVENT, type);
+	state_str_to_enum (BLOCKED_EMIT_METHOD, type);
+	state_str_to_enum (BLOCKED_JOB_START_METHOD, type);
+	state_str_to_enum (BLOCKED_JOB_STOP_METHOD, type);
+	state_str_to_enum (BLOCKED_JOB_RESTART_METHOD, type);
+	state_str_to_enum (BLOCKED_INSTANCE_START_METHOD, type);
+	state_str_to_enum (BLOCKED_INSTANCE_STOP_METHOD, type);
+	state_str_to_enum (BLOCKED_INSTANCE_RESTART_METHOD, type);
+
+error:
+	return -1;
+}

=== modified file 'init/blocked.h'
--- init/blocked.h	2009-06-23 09:29:35 +0000
+++ init/blocked.h	2012-11-07 15:22:20 +0000
@@ -79,6 +79,14 @@
 Blocked *blocked_new (const void *parent, BlockedType type, void *data)
 	__attribute__ ((warn_unused_result, malloc));
 
+const char *
+blocked_type_enum_to_str (BlockedType type)
+	__attribute__ ((warn_unused_result));
+
+BlockedType
+blocked_type_str_to_enum (const char *type)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_BLOCKED_H */

=== modified file 'init/conf.c'
--- init/conf.c	2011-06-06 17:05:11 +0000
+++ init/conf.c	2012-11-07 15:22:20 +0000
@@ -952,8 +952,8 @@
  **/
 static int
 conf_reload_path (ConfSource *source,
-	  const char *path,
-	  const char *override_path)
+		  const char *path,
+		  const char *override_path)
 {
 	ConfFile       *file = NULL;
 	nih_local char *buf = NULL;
@@ -1209,52 +1209,58 @@
 }
 
 void
-debug_show_job_class (const JobClass *job)
+debug_show_job_class (const JobClass *class)
 {
-	int i;
-	char **env    = (char **)job->env;
-	char **export = (char **)job->export;
+	nih_local char *start_on = NULL;
+	nih_local char *stop_on = NULL;
 
-	nih_assert (job);
+	nih_assert (class);
 
 	nih_debug ("JobClass %p: name='%s', path='%s', task=%d, "
 			"respawn=%d, console=%x, deleted=%d, debug=%d",
-			job, job->name, job->path, job->task,
-			job->respawn, job->console, job->deleted, job->debug);
-
-	nih_debug ("\tstart_on=%p, stop_on=%p, emits=%p, process=%p",
-			job->start_on, job->stop_on, job->emits, job->process);
+			class, class->name, class->path, class->task,
+			class->respawn, class->console, class->deleted, class->debug);
+
+	if (class->start_on) start_on = event_operator_collapse (class->start_on);
+	if (class->stop_on)  stop_on = event_operator_collapse (class->stop_on);
+
+	nih_debug ("\tstart_on=%p (%s), stop_on=%p (%s), emits=%p, process=%p",
+			class->start_on, start_on ? start_on : "",
+			class->stop_on, stop_on ? stop_on : "",
+			class->emits, class->process);
+
+	for (int i = 0; i < PROCESS_LAST; i++) {
+		if (class->process[i]) {
+			nih_debug ("Process[%d]=%p: script=%d, cmd='%s'",
+					i, class->process[i],
+					class->process[i]->script,
+					class->process[i]->command);
+		} else {
+			nih_debug ("Process[%d]=%p",
+					i, class->process[i]);
+		}
+
+
+	}
 
 	nih_debug ("\tauthor='%s', description='%s'",
-			job->author, job->description);
+			class->author, class->description);
 
-	if (env && *env) {
-		nih_debug ("\tenv:");
-		i = 0;
-		while ( *env ) {
-			nih_debug ("\t\tenv[%d]='%s' (len=%u+1)",
-					i, *env, strlen (*env));
-			env++;
-			++i;
-		}
+	if (class->env && *class->env) {
+		nih_local char *env = state_collapse_env ((const char **)class->env);
+		nih_debug ("\tenv:%s", env);
 	} else {
 		nih_debug ("\tenv: none.");
 	}
 
-
-	if (export && *export) {
-		nih_debug ("\texport:");
-		i = 0;
-		while ( *export ) {
-			nih_debug ("\t\tenv[%d]='%s' (len=%u+1)",
-					i, *export, strlen (*export));
-			export++;
-			++i;
-		}
-	}
-	else {
+	if (class->export && *class->export) {
+		nih_local char *export = state_collapse_env ((const char **)class->export);
+		nih_debug ("\texport:%s", export);
+	} else {
 		nih_debug ("\texport: none");
 	}
+
+	debug_show_jobs (class->instances);
 }
 
 void
@@ -1269,6 +1275,58 @@
 }
 
 void
+debug_show_job (const Job *job)
+{
+	nih_local char *env = NULL;
+	nih_local char *start_env = NULL;
+	nih_local char *stop_env = NULL;
+	nih_local char *stop_on = NULL;
+
+	nih_assert (job);
+
+	if (job->env)
+		env = state_collapse_env ((const char **)job->env);
+
+	if (job->start_env)
+		start_env = state_collapse_env ((const char **)job->start_env);
+
+	if (job->stop_env)
+		stop_env = state_collapse_env ((const char **)job->stop_env);
+
+	if (job->stop_on)
+		stop_on = event_operator_collapse (job->stop_on);
+
+	nih_debug ("Job %p: name=%s, class=%p (%s), path=%s, env='%s'"
+			"start_env='%s', stop_env='%s', stop_on='%s', "
+			"goal=%d, state=%d, failed=%d, exit_status=%d",
+			job,
+			job->name ? job->name : "",
+			job->class, job->class->name,
+			job->path,
+			env ? env : "",
+			start_env ? start_env : "",
+			stop_env ? stop_env : "",
+			stop_on ? stop_on : "",
+			job->goal,
+			job->state,
+			job->failed,
+			job->exit_status);
+}
+
+void
+debug_show_jobs (const NihHash *instances)
+{
+	nih_assert (instances);
+
+	nih_debug ("jobs:");
+
+	NIH_HASH_FOREACH (instances, iter) {
+		Job *job = (Job *)iter;
+		debug_show_job (job);
+	}
+}
+
+void
 debug_show_event (const Event *event)
 {
 	nih_assert (event);
@@ -1308,7 +1366,7 @@
 			source, source->path, source->type, source->flag);
 
 	nih_debug ("ConfSource %p files (%d):", source,
-			debug_count_hash_entries (source->files));
+			(int)debug_count_hash_entries (source->files));
 
 	NIH_HASH_FOREACH (source->files, file_iter) {
 		ConfFile *file = (ConfFile *)file_iter;

=== modified file 'init/conf.h'
--- init/conf.h	2011-06-06 12:52:08 +0000
+++ init/conf.h	2012-11-07 15:22:20 +0000
@@ -39,9 +39,9 @@
  * what they define within themselves.
  **/
 typedef enum conf_source_type {
-	CONF_FILE,
-	CONF_DIR,
-	CONF_JOB_DIR,
+	CONF_FILE,    /* solitary file */
+	CONF_DIR,     /* FIXME: */
+	CONF_JOB_DIR, /* directory tree of jobs */
 } ConfSourceType;
 
 
@@ -133,6 +133,7 @@
 #ifdef DEBUG
 
 /* used for debugging only */
+#include "job.h"
 
 size_t
 debug_count_hash_entries       (const NihHash *hash);
@@ -142,7 +143,7 @@
 	__attribute__ ((unused));
 
 void
-debug_show_job_class           (const JobClass *job)
+debug_show_job_class           (const JobClass *class)
 	__attribute__ ((unused));
 
 void
@@ -150,6 +151,13 @@
 	__attribute__ ((unused));
 
 void
+debug_show_job                 (const Job *job)
+	__attribute__ ((unused));
+
+void
+debug_show_jobs (const NihHash *instances)
+	__attribute__ ((unused));
+void
 debug_show_event               (const Event *event)
 	__attribute__ ((unused));
 

=== modified file 'init/control.c'
--- init/control.c	2012-03-16 21:02:13 +0000
+++ init/control.c	2012-11-07 15:22:20 +0000
@@ -54,6 +54,7 @@
 #include "conf.h"
 #include "control.h"
 #include "errors.h"
+#include "state.h"
 
 #include "com.ubuntu.Upstart.h"
 
@@ -62,6 +63,8 @@
 static void  control_disconnected   (DBusConnection *conn);
 static void  control_register_all   (DBusConnection *conn);
 
+static void  control_bus_flush      (void);
+
 /**
  * use_session_bus:
  *
@@ -188,7 +191,8 @@
 void
 control_server_close (void)
 {
-	nih_assert (control_server != NULL);
+	if (! control_server)
+		return;
 
 	dbus_server_disconnect (control_server);
 	dbus_server_unref (control_server);
@@ -292,7 +296,7 @@
  *
  * This function is called when the connection to the D-Bus system bus,
  * or a client connection to our D-Bus server, is dropped and our reference
- * is about to be list.  We clear the connection from our current list
+ * is about to be lost.  We clear the connection from our current list
  * and drop the control_bus global if relevant.
  **/
 static void
@@ -301,6 +305,10 @@
 	nih_assert (conn != NULL);
 
 	if (conn == control_bus) {
+		DBusError  error;
+
+		dbus_error_init (&error);
+
 		nih_warn (_("Disconnected from system bus"));
 
 		control_bus = NULL;
@@ -368,6 +376,8 @@
 	nih_assert (message != NULL);
 
 	nih_info (_("Reloading configuration"));
+
+	/* This can only be called after deserialisation */
 	conf_reload ();
 
 	return 0;
@@ -806,3 +816,136 @@
 
 	return 0;
 }
+
+/**
+ * control_bus_flush:
+ *
+ * Drain any remaining messages in the D-Bus queue.
+ **/
+static void
+control_bus_flush (void)
+{
+	control_init ();
+
+	if (! control_bus)
+		return;
+
+	while (dbus_connection_dispatch (control_bus) == DBUS_DISPATCH_DATA_REMAINS)
+		;
+}
+
+/**
+ * control_prepare_reexec:
+ *
+ * Prepare for a re-exec by allowing the bus connection to be retained
+ * over re-exec and clearing all queued messages.
+ **/
+void
+control_prepare_reexec (void)
+{
+	control_init ();
+
+	/* Necessary to disallow further commands but also to allow the
+	 * new instance to open the control server.
+	 */
+	if (control_server)
+		control_server_close ();
+
+	control_bus_flush ();
+
+}
+
+
+/**
+ * control_conn_to_index:
+ *
+ * @event: event.
+ *
+ * Convert a control (DBusConnection) connection to an index number
+ * the list of control connections.
+ *
+ * Returns: connection index, or -1 on error.
+ **/
+int
+control_conn_to_index (const DBusConnection *connection)
+{
+	int conn_index = 0;
+	int found = FALSE;
+
+	nih_assert (connection);
+
+	NIH_LIST_FOREACH (control_conns, iter) {
+		NihListEntry    *entry = (NihListEntry *)iter;
+		DBusConnection  *conn = (DBusConnection *)entry->data;
+
+		if (connection == conn) {
+			found = TRUE;
+			break;
+		}
+
+		conn_index++;
+	}
+	if (! found)
+		return -1;
+
+	return conn_index;
+}
+
+/**
+ * control_conn_from_index:
+ *
+ * @conn_index: control connection index number.
+ *
+ * Lookup control connection based on index number.
+ *
+ * Returns: existing connection on success, or NULL if connection
+ * not found.
+ **/
+DBusConnection *
+control_conn_from_index (int conn_index)
+{
+	int i = 0;
+
+	nih_assert (conn_index >= 0);
+	nih_assert (control_conns);
+
+	NIH_LIST_FOREACH (control_conns, iter) {
+		NihListEntry    *entry = (NihListEntry *)iter;
+		DBusConnection  *conn = (DBusConnection *)entry->data;
+
+		if (i == conn_index)
+			return conn;
+		i++;
+	}
+
+	return NULL;
+}
+
+/**
+ * control_bus_release_name:
+ *
+ * Unregister well-known D-Bus name.
+ *
+ * Returns: 0 on success, -1 on raised error.
+ **/
+int
+control_bus_release_name (void)
+{
+	DBusError  error;
+	int        ret;
+
+	if (! control_bus)
+		return 0;
+
+	dbus_error_init (&error);
+	ret = dbus_bus_release_name (control_bus,
+				     DBUS_SERVICE_UPSTART,
+				     &error);
+	if (ret < 0) {
+		nih_dbus_error_raise (error.name, error.message);
+		dbus_error_free (&error);
+		return -1;
+	}
+
+	return 0;
+}

=== modified file 'init/control.h'
--- init/control.h	2011-06-06 17:05:11 +0000
+++ init/control.h	2012-11-07 15:22:20 +0000
@@ -23,10 +23,13 @@
 #include <dbus/dbus.h>
 
 #include <nih/macros.h>
+#include <nih/list.h>
 
 #include <nih-dbus/dbus_connection.h>
 #include <nih-dbus/dbus_message.h>
 
+#include <json.h>
+
 /**
  * USE_SESSION_BUS_ENV:
  *
@@ -90,6 +93,18 @@
 
 void control_handle_bus_type      (void);
 
+void control_prepare_reexec       (void);
+
+int control_conn_to_index (const DBusConnection *connection)
+	__attribute__ ((warn_unused_result));
+
+DBusConnection *
+control_conn_from_index (int conn_index)
+	__attribute__ ((warn_unused_result));
+
+int control_bus_release_name (void)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_CONTROL_H */

=== modified file 'init/event.c'
--- init/event.c	2011-06-06 17:05:11 +0000
+++ init/event.c	2012-11-07 15:22:20 +0000
@@ -52,6 +52,14 @@
 static void event_pending_handle_jobs  (Event *event);
 static void event_finished             (Event *event);
 
+static const char * event_progress_enum_to_str (EventProgress progress)
+	__attribute__ ((warn_unused_result));
+
+static EventProgress
+event_progress_str_to_enum (const char *name)
+	__attribute__ ((warn_unused_result));
+
+extern json_object *json_events;
 
 /**
  * events:
@@ -501,3 +509,326 @@
 
 	nih_free (event);
 }
+
+/**
+ * event_serialise:
+ * @event: event to serialise.
+ *
+ * Convert @event into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Note that event->blocking is NOT serialised. Instead, those objects
+ * which event->blocking refers to encode the fact that they are blocked
+ * on the event (index in the JSON) in question. Deserialisation
+ * restores event->blocking via a 2-pass technique. event->blockers is
+ * recorded to allow a double-check.
+ *
+ * Returns: JSON-serialised Event object, or NULL on error.
+ **/
+json_object *
+event_serialise (const Event *event)
+{
+	json_object  *json;
+	int           session_index;
+
+	nih_assert (event);
+	nih_assert (event->name);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	session_index = session_get_index (event->session);
+	if (session_index < 0)
+		goto error;
+
+	if (! state_set_json_int_var (json, "session", session_index))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, event, name))
+		goto error;
+
+	if (event->env) {
+		if (! state_set_json_str_array_from_obj (json, event, env))
+			goto error;
+	}
+
+	if (! state_set_json_int_var_from_obj (json, event, fd))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				event_progress_enum_to_str,
+				"progress", event->progress))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, event, failed))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, event, blockers))
+		goto error;
+
+	if (! NIH_LIST_EMPTY (&event->blocking)) {
+		json_object *json_blocking;
+
+		json_blocking = state_serialise_blocking (&event->blocking);
+		if (! json_blocking)
+			goto error;
+
+		json_object_object_add (json, "blocking", json_blocking);
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * event_serialise_all:
+ *
+ * Convert existing Event objects to JSON representation.
+ *
+ * Returns: JSON object containing array of Events, or NULL on error.
+ **/
+json_object *
+event_serialise_all (void)
+{
+	json_object  *json;
+
+	event_init ();
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_LIST_FOREACH (events, iter) {
+		Event         *event = (Event *)iter;
+		json_object   *json_event;
+
+		json_event = event_serialise (event);
+
+		if (! json_event)
+			goto error;
+
+		json_object_array_add (json, json_event);
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * event_deserialise:
+ * @json: JSON-serialised Event object to deserialise.
+ *
+ * Convert @json into an Event object.
+ *
+ * Returns: Event object, or NULL on error.
+ **/
+Event *
+event_deserialise (json_object *json)
+{
+	json_object        *json_env;
+	Event              *event = NULL;
+	nih_local char     *name = NULL;
+        char              **env = NULL;
+	int                 session_index = -1;
+
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		return NULL;
+
+	if (! state_get_json_string_var_strict (json, "name", NULL, name))
+		goto error;
+
+	if (json_object_object_get (json, "env")) {
+		if (! state_get_json_var_full (json, "env", array, json_env))
+			goto error;
+
+		if (! state_deserialise_str_array (NULL, json_env, &env))
+			goto error;
+	}
+
+	event = event_new (NULL, name, env);
+	if (! event)
+		return NULL;
+
+	if (! state_get_json_int_var_to_obj (json, event, fd))
+		goto error;
+
+	if (! state_get_json_int_var (json, "session", session_index))
+		goto error;
+
+	/* can't check return value here (as all values are legitimate) */
+	event->session = session_from_index (session_index);
+
+	if (! state_get_json_enum_var (json,
+				event_progress_str_to_enum,
+				"progress", event->progress))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, event, failed))
+		goto error;
+
+	return event;
+
+error:
+	nih_free (event);
+	return NULL;
+}
+
+/**
+ * event_deserialise_all:
+ *
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of events back into Event objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+event_deserialise_all (json_object *json)
+{
+	Event            *event;
+
+	nih_assert (json);
+
+	event_init ();
+
+	nih_assert (NIH_LIST_EMPTY (events));
+	json_events = json_object_object_get (json, "events");
+
+	if (! json_events)
+		goto error;
+
+	if (! state_check_json_type (json_events, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_events); i++) {
+		json_object   *json_event;
+
+		json_event = json_object_array_get_idx (json_events, i);
+		if (! json_event)
+			goto error;
+
+		if (! state_check_json_type (json_event, object))
+			goto error;
+
+		event = event_deserialise (json_event);
+		if (! event)
+			goto error;
+	}
+
+	return 0;
+
+error:
+	return -1;
+}
+
+/**
+ * event_progress_enum_to_str:
+ *
+ * @progress: event progress.
+ *
+ * Convert EventProgress to a string representation.
+ *
+ * Returns: string representation of @progress, or NULL if not known.
+ **/
+static const char *
+event_progress_enum_to_str (EventProgress progress)
+{
+	state_enum_to_str (EVENT_PENDING, progress);
+	state_enum_to_str (EVENT_HANDLING, progress);
+	state_enum_to_str (EVENT_FINISHED, progress);
+
+	return NULL;
+}
+
+/**
+ * event_progress_str_to_enum:
+ *
+ * @: name of EventOperator value.
+ *
+ * Convert string representation of EventProgress into a
+ * real EventProgress value.
+ *
+ * Returns: EventProgress representing @progress, or -1 if not known.
+ **/
+static EventProgress
+event_progress_str_to_enum (const char *progress)
+{
+	state_str_to_enum (EVENT_PENDING, progress);
+	state_str_to_enum (EVENT_HANDLING, progress);
+	state_str_to_enum (EVENT_FINISHED, progress);
+
+	return -1;
+}
+
+/**
+ * event_to_index:
+ *
+ * @event: event.
+ *
+ * Convert an Event to an index number within
+ * the list of events.
+ *
+ * Returns: event index, or -1 on error.
+ **/
+int
+event_to_index (const Event *event)
+{
+	int event_index = 0;
+	int found = FALSE;
+
+	nih_assert (event);
+	event_init ();
+
+	NIH_LIST_FOREACH (events, iter) {
+		Event *tmp = (Event *)iter;
+
+		if (tmp == event) {
+			found = TRUE;
+			break;
+		}
+
+		event_index++;
+	}
+
+	if (! found)
+		return -1;
+
+	return event_index;
+}
+
+/**
+ * event_from_index:
+ *
+ * @event_index: event index number.
+ *
+ * Lookup Event based on index number.
+ *
+ * Returns: existing Event on success, or NULL if event not found.
+ **/
+Event *
+event_from_index (int event_index)
+{
+	int i = 0;
+
+	nih_assert (event_index >= 0);
+	event_init ();
+
+	NIH_LIST_FOREACH (events, iter) {
+		Event *event = (Event *)iter;
+
+		if (i == event_index)
+			return event;
+		i++;
+	}
+
+	return NULL;
+}

=== modified file 'init/event.h'
--- init/event.h	2011-06-06 17:05:11 +0000
+++ init/event.h	2012-11-07 15:22:20 +0000
@@ -24,7 +24,9 @@
 #include <nih/list.h>
 
 #include "session.h"
+#include "state.h"
 
+#include <json.h>
 
 /**
  * EventProgress:
@@ -45,6 +47,8 @@
  * @session: session the event is attached to,
  * @name: string name of the event,
  * @env: NULL-terminated array of environment variables,
+ * @fd: open file descriptor associated with a particular
+ *      socket-bridge socket (see socket-event(8)),
  * @progress: progress of event,
  * @failed: whether this event has failed,
  * @blockers: number of blockers for finishing,
@@ -93,6 +97,24 @@
 
 void   event_poll    (void);
 
+json_object *event_serialise (const Event *event)
+	__attribute__ ((malloc, warn_unused_result));
+
+Event *event_deserialise (json_object *json)
+	__attribute__ ((malloc, warn_unused_result));
+
+json_object  * event_serialise_all (void)
+	__attribute__ ((malloc, warn_unused_result));
+
+int            event_deserialise_all (json_object *json)
+	__attribute__ ((warn_unused_result));
+
+int    event_to_index (const Event *event)
+	__attribute__ ((warn_unused_result));
+
+Event * event_from_index (int event_index)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_EVENT_H */

=== modified file 'init/event_operator.c'
--- init/event_operator.c	2010-12-10 07:18:34 +0000
+++ init/event_operator.c	2012-11-07 15:22:20 +0000
@@ -552,14 +552,31 @@
 	return *env;
 }
 
+/**
+ * event_operator_fds:
+ * @root: operator tree to update,
+ * @parent: parent object for new array,
+ * @fds: output location for array of ints
+ * @num_fds: number of elements in @fds,
+ * @env: NULL-terminated array of environment variables to add to,
+ * @len: length of @env,
+ * @key: key of variable to contain event names.
+ *
+ * Iterate over tree rooted at @root adding all file descriptor values found
+ * to the dynamically allocated @fds array. In addition, all file
+ * descriptors found are also added to @env will contain a new entry with key @key
+ * whose value is a space-separated list of file descriptor numbers.
+ *
+ * Returns: 1 on success, NULL on failure.
+ **/
 int *
-event_operator_fds (EventOperator *root,
-		    const void *parent,
-		    int **fds,
-		    size_t *num_fds,
-		    char          ***env,
-		    size_t          *len,
-		    const char      *key)
+event_operator_fds (EventOperator  *root,
+		    const void     *parent,
+		    int           **fds,
+		    size_t         *num_fds,
+		    char         ***env,
+		    size_t         *len,
+		    const char     *key)
 {
 	nih_local char *evlist = NULL;
 
@@ -696,3 +713,154 @@
 		}
 	}
 }
+
+/**
+ * event_operator_collapse:
+ *
+ * @condition: start on/stop on condition.
+ *
+ * Collapsed condition will be fully bracketed. Note that as such it may
+ * not be lexicographically identical to the original expression that
+ * resulted in @condition, but it will be logically identical.
+ *
+ * The condition is reconstructed from the EventOperator tree by using
+ * a post-order traversal (since this allows the tree to be traversed
+ * bottom-to-top). Leaf nodes (EVENT_MATCH) are ignored when visited,
+ * allowing non-leaf nodes (EVENT_AND and EVENT_OR) to simply grab the
+ * value of their children, construct a bracketed expression and add it
+ * to a stack. If a child is a leaf node, the value can be read
+ * directly. If a child is a non-leaf node, the value is obtained by
+ * popping the stack before adding the new value back onto the stack.
+ * When finally the root node is visited, the final expression can be
+ * removed from the stack and returned. A single-node tree (comprising a
+ * lone EVENT_MATCH at the root) is special-cased.
+ *
+ * Returns: newly-allocated flattened string representing @condition
+ * on success, or NULL on error.
+ **/
+char *
+event_operator_collapse (EventOperator *condition)
+{
+	nih_local NihList       *stack = NULL;
+	NihListEntry            *latest = NULL;
+	NihTree                 *root;
+
+	nih_assert (condition);
+
+	root = &condition->node;
+
+	stack = NIH_MUST (nih_list_new (NULL));
+
+	NIH_TREE_FOREACH_POST (root, iter) {
+		EventOperator   *oper = (EventOperator *)iter;
+		EventOperator   *left;
+		EventOperator   *right;
+		NihListEntry    *expr;
+		NihTree         *tree;
+		nih_local char  *left_expr = NULL;
+		nih_local char  *right_expr = NULL;
+
+		tree = &oper->node;
+
+		left = (EventOperator *)tree->left;
+		right = (EventOperator *)tree->right;
+
+		if (oper->type == EVENT_MATCH) {
+			/* Entire expression comprises a single event,
+			 * so push it and leave.
+			 */
+			if (tree == root) {
+				nih_local char *env = NULL;
+
+				if (oper->env)
+					env = NIH_MUST (state_collapse_env ((const char **)oper->env));
+
+				expr = NIH_MUST (nih_list_entry_new (stack));
+				expr->str = NIH_MUST (nih_sprintf (expr, "%s%s%s",
+							oper->name,
+							env ? " " : "",
+							env ? env : ""));
+				nih_list_add_after (stack, &expr->entry);
+				break;
+			}
+			else {
+				/* We build the expression from visiting the logical
+				 * operators (and their children) only.
+				 */
+				continue;
+			}
+		}
+
+		/* oper cannot now be a leaf node, so must have children */
+		nih_assert (left);
+		nih_assert (right);
+
+		expr = NIH_MUST (nih_list_entry_new (stack));
+
+		/* If a child is an EVENT_MATCH, expand its event
+		 * details and push onto the stack.
+		 * If a child is not an EVENT_MATCH, to obtains it
+		 * value, pop the stack.
+		 *
+		 * Having obtained the child values, construct a new
+		 * bracketed expression and push onto the stack.
+		 *
+		 * Note that we must consider the right child first.
+		 * This is because since the tree is traversed
+		 * left-child first, any value pushed onto the stack by
+		 * a right child is at the top so must be removed before
+		 * any left child value. Failure to do this results in
+		 * tree reflection which although logically equivalent
+		 * to the original could confuse as the resultant
+		 * expression will look rather different.
+		 */
+		if (right->type != EVENT_MATCH) {
+			nih_assert (! NIH_LIST_EMPTY (stack));
+
+			latest = (NihListEntry *)nih_list_remove (stack->next);
+			right_expr = NIH_MUST (nih_strdup (NULL, latest->str));
+		} else {
+			nih_local char *env = NULL;
+
+			if (right->env)
+				env = NIH_MUST (state_collapse_env ((const char **)right->env));
+
+			right_expr = NIH_MUST (nih_sprintf (NULL, "%s%s%s",
+						right->name,
+						env ? " " : "",
+						env ? env : ""));
+		}
+
+		if (left->type != EVENT_MATCH) {
+			nih_assert (! NIH_LIST_EMPTY (stack));
+
+			latest = (NihListEntry *)nih_list_remove (stack->next);
+			left_expr = NIH_MUST (nih_strdup (NULL, latest->str));
+		} else {
+			nih_local char *env = NULL;
+
+			if (left->env)
+				env = NIH_MUST (state_collapse_env ((const char **)left->env));
+
+			left_expr = NIH_MUST (nih_sprintf (NULL, "%s%s%s",
+						left->name,
+						env ? " " : "",
+						env ? env : ""));
+		}
+
+		expr->str = NIH_MUST (nih_sprintf (expr, "(%s %s %s)",
+					left_expr,
+					oper->type == EVENT_OR ? "or" : "and",
+					right_expr));
+
+		nih_list_add_after (stack, &expr->entry);
+	}
+
+	nih_assert (! NIH_LIST_EMPTY (stack));
+
+	latest = (NihListEntry *)nih_list_remove (stack->next);
+
+	nih_assert (NIH_LIST_EMPTY (stack));
+
+	return NIH_MUST (nih_strdup (NULL, latest->str));
+}

=== modified file 'init/event_operator.h'
--- init/event_operator.h	2010-12-10 07:18:34 +0000
+++ init/event_operator.h	2012-11-07 15:22:20 +0000
@@ -96,10 +96,10 @@
 					   const void *parent, size_t *len,
 					   const char *key);
 int *
-event_operator_fds (EventOperator *root,
-		    const void *parent,
-		    int **fds,
-		    size_t *num_fds,
+event_operator_fds (EventOperator   *root,
+		    const void      *parent,
+		    int            **fds,
+		    size_t          *num_fds,
 		    char          ***env,
 		    size_t          *len,
 		    const char      *key);
@@ -108,6 +108,9 @@
 
 void           event_operator_reset       (EventOperator *root);
 
+char *event_operator_collapse (EventOperator *condition)
+	__attribute__ ((malloc, warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_EVENT_OPERATOR_H */

=== modified file 'init/job.c'
--- init/job.c	2012-03-07 12:13:28 +0000
+++ init/job.c	2012-11-07 15:22:20 +0000
@@ -23,7 +23,6 @@
 # include <config.h>
 #endif /* HAVE_CONFIG_H */
 
-
 #include <sys/types.h>
 
 #include <errno.h>
@@ -55,10 +54,43 @@
 #include "event_operator.h"
 #include "blocked.h"
 #include "control.h"
+#include "parse_job.h"
+#include "state.h"
 
 #include "com.ubuntu.Upstart.Job.h"
 #include "com.ubuntu.Upstart.Instance.h"
 
+/* Prototypes for static functions */
+static const char *
+job_goal_enum_to_str (JobGoal goal)
+	__attribute__ ((warn_unused_result));
+
+static JobGoal job_goal_str_to_enum (const char *goal)
+	__attribute__ ((warn_unused_result));
+
+static const char *
+job_state_enum_to_str (JobState state)
+	__attribute__ ((warn_unused_result));
+
+static JobState
+job_state_str_to_enum (const char *state)
+	__attribute__ ((warn_unused_result));
+
+static const char *
+job_trace_state_enum_to_str (TraceState state)
+	__attribute__ ((warn_unused_result));
+
+static TraceState
+job_trace_state_str_to_enum (const char *state)
+	__attribute__ ((warn_unused_result));
+
+static json_object *
+job_serialise_kill_timer (NihTimer *timer)
+	__attribute__ ((malloc, warn_unused_result));
+
+static NihTimer *
+job_deserialise_kill_timer (json_object *json)
+	__attribute__ ((malloc, warn_unused_result));
 
 /**
  * job_new:
@@ -119,6 +151,7 @@
 	job->stop_env = NULL;
 
 	job->stop_on = NULL;
+
 	if (class->stop_on) {
 		job->stop_on = event_operator_copy (job, class->stop_on);
 		if (! job->stop_on)
@@ -152,10 +185,10 @@
 	nih_list_init (&job->blocking);
 
 	job->kill_timer = NULL;
-	job->kill_process = -1;
+	job->kill_process = PROCESS_INVALID;
 
 	job->failed = FALSE;
-	job->failed_process = -1;
+	job->failed_process = PROCESS_INVALID;
 	job->exit_status = 0;
 
 	job->respawn_time = 0;
@@ -262,7 +295,7 @@
 	 * will finish naturally, so all we need do is change the goal and
 	 * we'll change direction through the state machine at that point.
 	 *
-	 * The exceptions are the natural rest sates of waiting and a
+	 * The exceptions are the natural rest states of waiting and a
 	 * running process; these need induction to get them moving.
 	 */
 	switch (goal) {
@@ -358,7 +391,7 @@
 
 			/* Clear any old failed information */
 			job->failed = FALSE;
-			job->failed_process = -1;
+			job->failed_process = PROCESS_INVALID;
 			job->exit_status = 0;
 
 			job->blocker = job_emit_event (job);
@@ -882,7 +915,7 @@
 		 * if it was a respawn failure, we use the special "respawn"
 		 * argument instead of the process name,
 		 */
-		if ((job->failed_process != (ProcessType)-1)
+		if ((job->failed_process != PROCESS_INVALID)
 		    && (job->exit_status != -1)) {
 			NIH_MUST (environ_set (&env, NULL, &len, TRUE,
 					       "PROCESS=%s",
@@ -907,7 +940,7 @@
 				NIH_MUST (environ_set (&env, NULL, &len, TRUE,
 						       "EXIT_STATUS=%d", job->exit_status));
 			}
-		} else if (job->failed_process != (ProcessType)-1) {
+		} else if (job->failed_process != PROCESS_INVALID) {
 			NIH_MUST (environ_set (&env, NULL, &len, TRUE,
 					       "PROCESS=%s",
 					       process_name (job->failed_process)));
@@ -1492,3 +1525,689 @@
 
 	return 0;
 }
+
+/**
+ * job_serialise:
+ * @job: job serialise.
+ *
+ * Convert @job into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Note that the 'class' element is not encoded - it is assumed the
+ * caller will encode the returned JSON Job object as a child of the
+ * parent JSON-encoded JobClass object so a reference is not required.
+ *
+ * Returns: JSON-serialised Job object, or NULL on error.
+ **/
+json_object *
+job_serialise (const Job *job)
+{
+	json_object      *json;
+	json_object      *json_pid;
+	json_object      *json_fds;
+	json_object      *json_logs;
+	nih_local char   *stop_on = NULL;
+
+	nih_assert (job);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! state_set_json_string_var_from_obj (json, job, name))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, job, path))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				job_goal_enum_to_str,
+				"goal", job->goal))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				job_state_enum_to_str,
+				"state", job->state))
+		goto error;
+
+	if (! state_set_json_str_array_from_obj (json, job, env))
+		goto error;
+
+	if (! state_set_json_str_array_from_obj (json, job, start_env))
+		goto error;
+
+	if (! state_set_json_str_array_from_obj (json, job, stop_env))
+		goto error;
+
+	if (job->stop_on) {
+		stop_on = event_operator_collapse (job->stop_on);
+		if (! stop_on)
+			goto error;
+
+		if (! state_set_json_string_var (json, "stop_on", stop_on))
+			goto error;
+	}
+
+	json_fds = state_serialise_int_array (int, job->fds, job->num_fds);
+	if (! json_fds)
+		goto error;
+
+	json_object_object_add (json, "fds", json_fds);
+
+	json_pid = state_serialise_int_array (pid_t, job->pid,
+					     PROCESS_LAST);
+	if (! json_pid)
+		goto error;
+
+	json_object_object_add (json, "pid", json_pid);
+
+	/* Encode the blocking event as an index number which represents
+	 * the event's position in the JSON events array.
+	 */
+	if (job->blocker) {
+		int event_index;
+
+		event_index = event_to_index (job->blocker);
+		if (event_index < 0)
+			goto error;
+
+		/* For consistency, it would be preferable to encode the
+		 * event name, but the index is actually better since it is
+		 * simple and unambiguous - encoding the name would also require
+		 * us to encode the env to make the event unique.
+		 */
+		if (! state_set_json_int_var (json, "blocker", event_index))
+			goto error;
+
+	}
+
+	if (! NIH_LIST_EMPTY (&job->blocking)) {
+		json_object *json_blocking;
+
+		json_blocking = state_serialise_blocking (&job->blocking);
+		if (! json_blocking)
+			goto error;
+
+		json_object_object_add (json, "blocking", json_blocking);
+	}
+
+	/* conditionally encode kill timer */
+	if (job->kill_timer) {
+		json_object *kill_timer;
+
+		kill_timer = job_serialise_kill_timer (job->kill_timer);
+
+		if (! kill_timer)
+			goto error;
+
+		json_object_object_add (json, "kill_timer", kill_timer);
+	}
+
+	if (! state_set_json_enum_var (json,
+				process_type_enum_to_str,
+				"kill_process", job->kill_process))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, job, failed))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				process_type_enum_to_str,
+				"failed_process", job->failed_process))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, job, exit_status))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, job, respawn_time))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, job, respawn_count))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, job, trace_forks))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				job_trace_state_enum_to_str,
+				"trace_state", job->trace_state))
+		goto error;
+
+	json_logs = json_object_new_array ();
+
+	if (! json_logs)
+		return json;
+
+	for (int process = 0; process < PROCESS_LAST; process++) {
+		json_object *json_log;
+
+		json_log = log_serialise (job->log[process]);
+		if (! json_log)
+			goto error;
+
+		if (json_object_array_add (json_logs, json_log) < 0)
+			goto error;
+	}
+
+	json_object_object_add (json, "log", json_logs);
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * job_serialise_all:
+ *
+ * Convert existing Session objects to JSON representation.
+ *
+ * Returns: JSON object containing array of Job objects, or NULL on error.
+ **/
+json_object *
+job_serialise_all (const NihHash *jobs)
+{
+	int          count = 0;
+	json_object *json;
+
+	nih_assert (jobs);
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_HASH_FOREACH (jobs, iter) {
+		json_object  *json_job;
+		Job *job = (Job *)iter;
+
+		count++;
+		json_job = job_serialise (job);
+
+		if (! json_job)
+			goto error;
+
+		json_object_array_add (json, json_job);
+	}
+
+	/* Raise an error to avoid serialising job classes with
+	 * no associated jobs.
+	 */
+	if (! count)
+		goto error;
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * job_deserialise:
+ * @parent: job class for JSON-encoded jobs,
+ * @json: JSON-serialised Job object to deserialise.
+ *
+ * XXX: All events must have been deserialised prior to this function
+ * XXX: being called.
+ *
+ * Returns: Job object, or NULL on error.
+ **/
+Job *
+job_deserialise (JobClass *parent, json_object *json)
+{
+	nih_local char *name = NULL;
+	Job            *job = NULL;
+	json_object    *json_kill_timer;
+	json_object    *blocker;
+	json_object    *json_fds;
+	json_object    *json_pid;
+	json_object    *json_logs;
+	size_t          len;
+	int             ret;
+
+	nih_assert (parent);
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		return NULL;
+
+	if (! state_get_json_string_var_strict (json, "name", NULL, name))
+		goto error;
+
+	job = NIH_MUST (job_new (parent, name));
+
+	if (! job)
+		return NULL;
+
+	if (! state_get_json_string_var_to_obj_strict (json, job, path))
+		goto error;
+
+	if (! state_get_json_enum_var (json,
+				job_goal_str_to_enum,
+				"goal", job->goal))
+		goto error;
+
+	if (! state_get_json_enum_var (json,
+				job_state_str_to_enum,
+				"state", job->state))
+		goto error;
+
+	if (! state_get_json_env_array_to_obj (json, job, env))
+		goto error;
+
+	if (! state_get_json_env_array_to_obj (json, job, start_env))
+		goto error;
+
+	if (! state_get_json_env_array_to_obj (json, job, stop_env))
+		goto error;
+
+	if (json_object_object_get (json, "stop_on")) {
+		nih_local char *stop_on = NULL;
+
+		if (! state_get_json_string_var_strict (json, "stop_on", NULL, stop_on))
+			goto error;
+
+		if (*stop_on) {
+			nih_local JobClass *tmp = NULL;
+
+			tmp = NIH_MUST (job_class_new (NULL, "tmp", NULL));
+
+			tmp->stop_on = parse_on_simple (tmp, "stop", stop_on);
+			if (! tmp->stop_on) {
+				NihError *err;
+
+				err = nih_error_get ();
+
+				nih_error ("%s %s: %s",
+						_("BUG"),
+						_("instance 'stop on' parse error"),
+						err->message);
+
+				nih_free (err);
+
+				goto error;
+			}
+
+			nih_free (job->stop_on);
+			job->stop_on = event_operator_copy (job, tmp->stop_on);
+			if (! job->stop_on)
+				goto error;
+		}
+	}
+
+	/* fds and num_fds handled by caller */
+	/* pid handled by caller */
+
+	/* blocking is handled by state_deserialise_blocking() */
+
+	blocker = json_object_object_get (json, "blocker");
+
+	if (blocker) {
+		int event_index = -1;
+
+		if (! state_get_json_int_var (json, "blocker", event_index))
+			goto error;
+		job->blocker = event_from_index (event_index);
+
+		if (! job->blocker)
+			goto error;
+	}
+
+	if (! state_get_json_enum_var (json,
+				process_type_str_to_enum,
+				"kill_process", job->kill_process))
+		goto error;
+
+	/* Check to see if a kill timer exists first since we do not
+	 * want to end up creating a real but empty timer.
+	 */
+	json_kill_timer = json_object_object_get (json, "kill_timer");
+
+	if (json_kill_timer) {
+		/* Found a partial kill timer, so create a new one and
+		 * adjust its due time. By the time the main loop gets
+		 * called, the due time will probably be in the past
+		 * such that the job will be stopped.
+		 *
+		 * To be completely fair we should:
+		 *
+		 * - encode the time at the point of serialisation in a
+		 *   JSON 'meta' header.
+		 * - query the time post-deserialisation and calculate
+		 *   the delta (being the time to perform the stateful
+		 *   re-exec).
+		 * - add that time to all jobs with active kill timers
+		 *   to give their processes the full amount of time to
+		 *   end.
+		 */
+		nih_local NihTimer *kill_timer = job_deserialise_kill_timer (json_kill_timer);
+		if (! kill_timer)
+			goto error;
+
+		nih_assert (job->kill_process);
+		job_process_set_kill_timer (job, job->kill_process,
+		                            kill_timer->timeout);
+		job_process_adj_kill_timer (job, kill_timer->due);
+	}
+
+	if (! state_get_json_int_var_to_obj (json, job, failed))
+			goto error;
+
+	if (! state_get_json_enum_var (json,
+				process_type_str_to_enum,
+				"failed_process", job->failed_process))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, job, exit_status))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, job, respawn_time))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, job, respawn_count))
+		goto error;
+
+	json_fds = json_object_object_get (json, "fds");
+	if (! json_fds)
+		goto error;
+
+	ret = state_deserialise_int_array (job, json_fds,
+			int, &job->fds, &job->num_fds);
+	if (ret < 0)
+		goto error;
+
+	json_pid = json_object_object_get (json, "pid");
+	if (! json_pid)
+		goto error;
+
+	ret = state_deserialise_int_array (job, json_pid,
+			pid_t, &job->pid, &len);
+	if (ret < 0)
+		goto error;
+
+	if (len != PROCESS_LAST)
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, job, trace_forks))
+			goto error;
+
+	if (! state_get_json_enum_var (json,
+				job_trace_state_str_to_enum,
+				"trace_state", job->trace_state))
+		goto error;
+
+	json_logs = json_object_object_get (json, "log");
+
+	if (! json_logs)
+		goto error;
+
+	if (! state_check_json_type (json_logs, array))
+		goto error;
+
+	for (int process = 0; process < PROCESS_LAST; process++) {
+		json_object  *json_log;
+
+		json_log = json_object_array_get_idx (json_logs, process);
+		if (! json_log)
+			goto error;
+
+		/* NULL if there was no log configured, or we failed to
+		 * deserialise it; either way, this should be non-fatal.
+		 */
+		job->log[process] = log_deserialise (job->log, json_log);
+	}
+
+	return job;
+
+error:
+	nih_free (job);
+	return NULL;
+}
+
+/**
+ * job_deserialise_all:
+ *
+ * @parent: job class for JSON-encoded jobs,
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of jobs back into Job objects associated
+ * with @parent.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+job_deserialise_all (JobClass *parent, json_object *json)
+{
+	json_object  *json_jobs;
+	Job          *job;
+
+	nih_assert (parent);
+	nih_assert (json);
+
+	json_jobs = json_object_object_get (json, "jobs");
+
+	if (! json_jobs)
+		goto error;
+
+	if (! state_check_json_type (json_jobs, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_jobs); i++) {
+		json_object    *json_job;
+
+		json_job = json_object_array_get_idx (json_jobs, i);
+		if (! json_job)
+			goto error;
+
+		if (! state_check_json_type (json_job, object))
+			goto error;
+
+		job = job_deserialise (parent, json_job);
+		if (! job)
+			goto error;
+	}
+
+	return 0;
+
+error:
+	return -1;
+}
+
+/**
+ * job_goal_enum_to_str:
+ *
+ * @goal: JobGoal.
+ *
+ * Convert JobGoal to a string representation.
+ *
+ * Returns: string representation of @goal, or NULL if not known.
+ **/
+static const char *
+job_goal_enum_to_str (JobGoal goal)
+{
+	state_enum_to_str (JOB_STOP, goal);
+	state_enum_to_str (JOB_START, goal);
+	state_enum_to_str (JOB_RESPAWN, goal);
+
+	return NULL;
+}
+
+/**
+ * job_goal_str_to_enum:
+ *
+ * @goal: string JobGoal value.
+ *
+ * Convert @goal back into enum value.
+ *
+ * Returns: JobGoal representation of @goal, or -1 if not known.
+ **/
+static JobGoal
+job_goal_str_to_enum (const char *goal)
+{
+	state_str_to_enum (JOB_STOP, goal);
+	state_str_to_enum (JOB_START, goal);
+	state_str_to_enum (JOB_RESPAWN, goal);
+
+	return -1;
+}
+
+/**
+ * job_state_enum_to_str:
+ *
+ * @state: JobState.
+ *
+ * Convert JobState to a string representation.
+ *
+ * Returns: string representation of @state, or NULL if not known.
+ **/
+static const char *
+job_state_enum_to_str (JobState state)
+{
+	state_enum_to_str (JOB_WAITING, state);
+	state_enum_to_str (JOB_STARTING, state);
+	state_enum_to_str (JOB_PRE_START, state);
+	state_enum_to_str (JOB_SPAWNED, state);
+	state_enum_to_str (JOB_POST_START, state);
+	state_enum_to_str (JOB_RUNNING, state);
+	state_enum_to_str (JOB_PRE_STOP, state);
+	state_enum_to_str (JOB_STOPPING, state);
+	state_enum_to_str (JOB_KILLED, state);
+	state_enum_to_str (JOB_POST_STOP, state);
+
+	return NULL;
+}
+
+/**
+ * job_state_str_to_enum:
+ *
+ * @state: string JobState value.
+ *
+ * Convert @state back into enum value.
+ *
+ * Returns: JobState representation of @state, or -1 if not known.
+ **/
+static JobState
+job_state_str_to_enum (const char *state)
+{
+	state_str_to_enum (JOB_WAITING, state);
+	state_str_to_enum (JOB_STARTING, state);
+	state_str_to_enum (JOB_PRE_START, state);
+	state_str_to_enum (JOB_SPAWNED, state);
+	state_str_to_enum (JOB_POST_START, state);
+	state_str_to_enum (JOB_RUNNING, state);
+	state_str_to_enum (JOB_PRE_STOP, state);
+	state_str_to_enum (JOB_STOPPING, state);
+	state_str_to_enum (JOB_KILLED, state);
+	state_str_to_enum (JOB_POST_STOP, state);
+
+	return -1;
+}
+
+/**
+ * job_state_enum_to_str:
+ *
+ * @state: TraceState.
+ *
+ * Convert TraceState to a string representation.
+ *
+ * Returns: string representation of @state, or NULL if not known.
+ **/
+static const char *
+job_trace_state_enum_to_str (TraceState state)
+{
+	state_enum_to_str (TRACE_NONE, state);
+	state_enum_to_str (TRACE_NEW, state);
+	state_enum_to_str (TRACE_NEW_CHILD, state);
+	state_enum_to_str (TRACE_NORMAL, state);
+
+	return NULL;
+}
+
+/**
+ * job_trace_state_str_to_enum:
+ *
+ * @state: string TraceState value.
+ *
+ * Convert @state back into enum value.
+ *
+ * Returns: TraceState representation of @state, or -1 if not known.
+ **/
+static TraceState
+job_trace_state_str_to_enum (const char *state)
+{
+	state_str_to_enum (TRACE_NONE, state);
+	state_str_to_enum (TRACE_NEW, state);
+	state_str_to_enum (TRACE_NEW_CHILD, state);
+	state_str_to_enum (TRACE_NORMAL, state);
+
+	return -1;
+}
+
+/**
+ * job_serialise_kill_timer:
+ *
+ * @timer: NihTimer to serialise.
+ *
+ * Serialise @timer into JSON.
+ *
+ * Returns: JSON-serialised NihTimer object, or NULL on error.
+ **/
+static json_object *
+job_serialise_kill_timer (NihTimer *timer)
+{
+	json_object  *json;
+
+	nih_assert (timer);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! state_set_json_int_var_from_obj (json, timer, timeout))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, timer, due))
+		goto error;
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * job_deserialise_kill_timer:
+ *
+ * @json: JSON representation of NihTimer.
+ *
+ * Deserialise @json back into an NihTimer.
+ *
+ * Returns: NihTimer on NULL on error.
+ **/
+static NihTimer *
+job_deserialise_kill_timer (json_object *json)
+{
+	NihTimer *timer;
+
+	nih_assert (json);
+
+	timer = nih_new (NULL, NihTimer);
+	if (! timer)
+		return NULL;
+
+	memset (timer, '\0', sizeof (NihTimer));
+
+	if (! state_get_json_int_var_to_obj (json, timer, due))
+			goto error;
+
+	if (! state_get_json_int_var_to_obj (json, timer, timeout))
+			goto error;
+
+	return timer;
+
+error:
+	nih_free (timer);
+	return NULL;
+}

=== modified file 'init/job.h'
--- init/job.h	2012-03-07 12:13:28 +0000
+++ init/job.h	2012-11-07 15:22:20 +0000
@@ -103,6 +103,9 @@
  * @start_env: environment to use next time the job is started,
  * @stop_env: environment to add for the next pre-stop script,
  * @stop_on: event operator expression that can stop this job.
+ * @fds: array of file descriptors associated with events in parent
+ *       JobClasses @start_on condition,
+ * @num_fds: number of elements in @fds,
  * @pid: current process ids,
  * @blocker: emitted event we're waiting to finish,
  * @blocking: list of events we're blocking from finishing,
@@ -136,8 +139,8 @@
 	char          **stop_env;
 	EventOperator  *stop_on;
 
-	int *fds;
-	size_t num_fds;
+	int            *fds;
+	size_t          num_fds;
 
 	pid_t          *pid;
 	Event          *blocker;
@@ -208,6 +211,15 @@
 				 JobProcessesElement ***processes)
 	__attribute__ ((warn_unused_result));
 
+json_object *job_serialise (const Job *job);
+Job *job_deserialise (JobClass *parent, json_object *json);
+
+json_object *job_serialise_all (const NihHash *jobs)
+	__attribute__ ((malloc, warn_unused_result));
+
+int         job_deserialise_all (JobClass *parent, json_object *json)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_H */

=== modified file 'init/job_class.c'
--- init/job_class.c	2012-03-01 11:55:19 +0000
+++ init/job_class.c	2012-11-07 15:22:20 +0000
@@ -52,14 +52,18 @@
 #include "blocked.h"
 #include "conf.h"
 #include "control.h"
+#include "parse_job.h"
 
 #include "com.ubuntu.Upstart.h"
 #include "com.ubuntu.Upstart.Job.h"
 
+#include <json.h>
+
+extern json_object *json_classes;
 
 /* Prototypes for static functions */
-static void job_class_add    (JobClass *class);
-static int  job_class_remove (JobClass *class, const Session *session);
+static void  job_class_add (JobClass *class);
+static int   job_class_remove (JobClass *class, const Session *session);
 
 /**
  * default_console:
@@ -356,6 +360,30 @@
 }
 
 /**
+ * job_class_add_safe:
+ * @class: new class to select.
+ *
+ * Adds @class to the hash table iff no existing entry of the
+ * same name exists.
+ **/
+void
+job_class_add_safe (JobClass *class)
+{
+	JobClass *existing = NULL;
+
+	nih_assert (class);
+	nih_assert (class->name);
+
+	control_init ();
+
+	existing = (JobClass *)nih_hash_search (job_classes, class->name, NULL);
+
+	nih_assert (! existing);
+
+	job_class_add (class);
+}
+
+/**
  * job_class_remove:
  * @class: class to remove,
  * @session: Session of @class.
@@ -720,7 +748,7 @@
  * If the instance goal is already start,
  * the com.ubuntu.Upstart.Error.AlreadyStarted D-Bus error will be returned
  * immediately.  If the instance fails to start, the
- * com.ubuntu.Upstart.Error.JobFailed D-BUs error will be returned when the
+ * com.ubuntu.Upstart.Error.JobFailed D-Bus error will be returned when the
  * problem occurs.
  *
  * When @wait is TRUE the method call will not return until the job has
@@ -1112,6 +1140,39 @@
 	return 0;
 }
 
+/**
+ * job_class_get:
+ *
+ * @name: name of job class,
+ * @session: session of job class.
+ *
+ * Obtain JobClass with name @name and session @session.
+ *
+ * Returns: JobClass, or NULL if no matching job class found.
+ **/
+JobClass *
+job_class_get (const char *name, Session *session)
+{
+	JobClass  *class = NULL;
+	NihList   *prev = NULL;
+
+	nih_assert (name);
+
+	do {
+		class = (JobClass *)nih_hash_search (job_classes, name, prev);
+		if (! class)
+			return NULL;
+		if (class && class->session == session)
+			return class;
+
+		nih_assert (class);
+
+		prev = (NihList *)class;
+	} while (TRUE);
+
+	nih_assert_not_reached ();
+}
+
 
 /**
  * job_class_get_name:
@@ -1500,3 +1561,655 @@
 
 	return 0;
 }
+
+
+/**
+ * job_class_serialise:
+ * @class: job class to serialise.
+ *
+ * Convert @class into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised JobClass object, or NULL on error.
+ **/
+json_object *
+job_class_serialise (const JobClass *class)
+{
+	json_object      *json;
+	json_object      *json_export;
+	json_object      *json_emits;
+	json_object      *json_processes;
+	json_object      *json_normalexit;
+	json_object      *json_limits;
+	json_object      *json_jobs;
+	nih_local char   *start_on = NULL;
+	nih_local char   *stop_on = NULL;
+	int               session_index;
+
+	nih_assert (class);
+	nih_assert (job_classes);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	session_index = session_get_index (class->session);
+	if (session_index < 0)
+		goto error;
+
+	if (! state_set_json_int_var (json, "session", session_index))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, name))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, path))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, instance))
+		goto error;
+
+	json_jobs = job_serialise_all (class->instances);
+
+	if (! json_jobs)
+		goto error;
+
+	json_object_object_add (json, "jobs", json_jobs);
+
+	if (! state_set_json_string_var_from_obj (json, class, description))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, author))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, version))
+		goto error;
+
+	if (! state_set_json_str_array_from_obj (json, class, env))
+		goto error;
+
+	json_export = class->export
+		? state_serialise_str_array (class->export)
+		: json_object_new_array ();
+
+	if (! json_export)
+		goto error;
+	json_object_object_add (json, "export", json_export);
+
+	if (class->start_on)
+	{
+		start_on = event_operator_collapse (class->start_on);
+		if (! start_on)
+			goto error;
+
+		if (! state_set_json_string_var (json, "start_on", start_on))
+			goto error;
+	}
+
+	if (class->stop_on)
+	{
+		stop_on = event_operator_collapse (class->stop_on);
+		if (! stop_on)
+			goto error;
+
+		if (! state_set_json_string_var (json, "stop_on", stop_on))
+			goto error;
+	}
+
+	json_emits = class->emits
+		? state_serialise_str_array (class->emits)
+		: json_object_new_array ();
+
+	if (! json_emits)
+		goto error;
+	json_object_object_add (json, "emits", json_emits);
+
+	json_processes = process_serialise_all (
+			(const Process const * const * const)class->process);
+	if (! json_processes)
+		goto error;
+	json_object_object_add (json, "process", json_processes);
+
+	if (! state_set_json_enum_var (json,
+				job_class_expect_type_enum_to_str,
+				"expect", class->expect))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, task))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, kill_timeout))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, kill_signal))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, respawn))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, respawn_limit))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, respawn_interval))
+		goto error;
+
+	json_normalexit = state_serialise_int_array (int, class->normalexit,
+					     class->normalexit_len);
+	if (! json_normalexit)
+		goto error;
+
+	json_object_object_add (json, "normalexit", json_normalexit);
+
+	if (! state_set_json_enum_var (json,
+				job_class_console_type_enum_to_str,
+				"console", class->console))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, umask))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, nice))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, oom_score_adj))
+		goto error;
+
+	json_limits = state_rlimit_serialise_all (class->limits);
+	if (! json_limits)
+		goto error;
+	json_object_object_add (json, "limits", json_limits);
+
+	if (! state_set_json_string_var_from_obj (json, class, chroot))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, chdir))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, setuid))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, setgid))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, deleted))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, class, debug))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, class, usage))
+		goto error;
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * job_class_serialise_all:
+ *
+ * Convert existing JobClass objects to JSON representation.
+ *
+ * Returns: JSON object containing array of JobClass objects,
+ * or NULL on error.
+ **/
+json_object *
+job_class_serialise_all (void)
+{
+	json_object *json;
+
+	job_class_init ();
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		json_object  *json_class;
+		JobClass     *class = (JobClass *)iter;
+
+		json_class = job_class_serialise (class);
+
+		/* No object returned means the class doesn't need to be
+		 * serialised.  Even if this is a real failure, it's always
+		 * better to serialise as much of the state as possible.
+		 */
+		if (! json_class)
+			continue;
+
+		json_object_array_add (json, json_class);
+	}
+
+	return json;
+}
+
+/**
+ * job_class_deserialise:
+ * @json: JSON-serialised JobClass object to deserialise.
+ *
+ * Create JobClass from provided JSON and add to the
+ * job classes table.
+ *
+ * Returns: JobClass object, or NULL on error.
+ **/
+JobClass *
+job_class_deserialise (json_object *json)
+{
+	json_object    *json_normalexit;
+	JobClass       *class = NULL;
+	int             session_index = -1;
+	int             ret;
+	nih_local char *name = NULL;
+	nih_local char *path = NULL;
+
+	nih_assert (json);
+	nih_assert (job_classes);
+
+	if (! state_check_json_type (json, object))
+		goto error;
+
+	if (! state_get_json_int_var (json, "session", session_index))
+		goto error;
+
+	if (session_index < 0)
+		goto error;
+
+	if (! state_get_json_string_var_strict (json, "name", NULL, name))
+		goto error;
+
+	class = NIH_MUST (job_class_new (NULL, name,
+	                                 session_from_index (session_index)));
+	if (! class)
+		goto error;
+
+	if (class->session != NULL) {
+		nih_warn ("XXX: WARNING (%s:%d): deserialisation of "
+				"user jobs and chroot sessions not currently supported",
+				__func__, __LINE__);
+		goto error;
+	}
+
+	/* job_class_new() sets path */
+	if (! state_get_json_string_var_strict (json, "path", NULL, path))
+		goto error;
+
+	nih_assert (! strcmp (class->path, path));
+
+	/* Discard default instance as we're about to be handed a fresh
+	 * string from the JSON.
+	 */
+	nih_free (class->instance);
+
+	if (! state_get_json_string_var_to_obj (json, class, instance))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, description))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, author))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, version))
+		goto error;
+
+	if (! state_get_json_env_array_to_obj (json, class, env))
+		goto error;
+
+	if (! state_get_json_env_array_to_obj (json, class, export))
+		goto error;
+
+	/* start and stop conditions are optional */
+	if (json_object_object_get (json, "start_on")) {
+		nih_local char *start_on = NULL;
+
+		if (! state_get_json_string_var_strict (json, "start_on", NULL, start_on))
+			goto error;
+
+		if (*start_on) {
+			class->start_on = parse_on_simple (class, "start", start_on);
+			if (! class->start_on) {
+				NihError *err;
+
+				err = nih_error_get ();
+
+				nih_error ("%s %s: %s",
+						_("BUG"),
+						_("'start on' parse error"),
+						err->message);
+
+				nih_free (err);
+
+				goto error;
+			}
+		}
+	}
+
+	if (json_object_object_get (json, "stop_on")) {
+		nih_local char *stop_on = NULL;
+
+		if (! state_get_json_string_var_strict (json, "stop_on", NULL, stop_on))
+			goto error;
+
+		if (*stop_on) {
+			class->stop_on = parse_on_simple (class, "stop", stop_on);
+			if (! class->stop_on) {
+				NihError *err;
+
+				err = nih_error_get ();
+
+				nih_error ("%s %s: %s",
+						_("BUG"),
+						_("'stop on' parse error"),
+						err->message);
+
+				nih_free (err);
+
+				goto error;
+			}
+		}
+	}
+
+	if (! state_get_json_str_array_to_obj (json, class, emits))
+		goto error;
+
+	if (! state_get_json_enum_var (json,
+				job_class_expect_type_str_to_enum,
+				"expect", class->expect))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, task))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, kill_timeout))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, kill_signal))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, respawn))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, respawn_limit))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, respawn_interval))
+		goto error;
+
+	if (! state_get_json_enum_var (json,
+				job_class_console_type_str_to_enum,
+				"console", class->console))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, umask))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, nice))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, oom_score_adj))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, chroot))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, chdir))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, setuid))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, setgid))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, deleted))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, class, debug))
+		goto error;
+
+	if (! state_get_json_string_var_to_obj (json, class, usage))
+		goto error;
+
+	json_normalexit = json_object_object_get (json, "normalexit");
+	if (! json_normalexit)
+		goto error;
+
+	ret = state_deserialise_int_array (class, json_normalexit,
+			int, &class->normalexit, &class->normalexit_len);
+	if (ret < 0)
+		goto error;
+
+	if (state_rlimit_deserialise_all (json, class, &class->limits) < 0)
+		goto error;
+
+	if (process_deserialise_all (json, class->process, class->process) < 0)
+		goto error;
+
+	/* Force class to be known.
+	 *
+	 * We cannot use job_class_*consider() since the
+	 * JobClasses have no associated ConfFile.
+	 */
+	job_class_add_safe (class);
+
+	/* Any jobs must be added after the class is registered
+	 * (since you cannot add a job to a partially-created
+	 * class).
+	 */
+	if (job_deserialise_all (class, json) < 0)
+		goto error;
+
+	return class;
+
+error:
+	nih_free (class);
+	return NULL;
+}
+
+/**
+ * job_class_deserialise_all:
+ *
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of JobClasses back into JobClass objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+job_class_deserialise_all (json_object *json)
+{
+	JobClass     *class = NULL;
+
+	nih_assert (json);
+
+	job_class_init ();
+
+	json_classes = json_object_object_get (json, "job_classes");
+
+	if (! json_classes)
+			goto error;
+
+	if (! state_check_json_type (json_classes, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_classes); i++) {
+		json_object         *json_class;
+
+		json_class = json_object_array_get_idx (json_classes, i);
+		if (! json_class)
+			goto error;
+
+		if (! state_check_json_type (json_class, object))
+			goto error;
+
+		class = job_class_deserialise (json_class);
+		if (! class)
+			goto error;
+
+		/* FIXME:
+		 *
+		 * If user sessions exist (ie 'initctl --session list'
+		 * has been run), we get this failure:
+		 *
+		 *             serialised path='/com/ubuntu/Upstart/jobs/1000/bang'
+		 * path set by job_class_new()='/com/ubuntu/Upstart/jobs/_/1000/bang'
+		 *
+		 */
+
+	}
+
+	return 0;
+
+error:
+	if (class)
+		nih_free (class);
+
+	return -1;
+}
+
+
+/**
+ * job_class_expect_type_enum_to_str:
+ *
+ * @expect: ExpectType.
+ *
+ * Convert ExpectType to a string representation.
+ *
+ * Returns: string representation of @expect, or NULL if not known.
+ **/
+const char *
+job_class_expect_type_enum_to_str (ExpectType expect)
+{
+	state_enum_to_str (EXPECT_NONE, expect);
+	state_enum_to_str (EXPECT_STOP, expect);
+	state_enum_to_str (EXPECT_DAEMON, expect);
+	state_enum_to_str (EXPECT_FORK, expect);
+
+	return NULL;
+}
+
+/**
+ * job_class_expect_type_str_to_enum:
+ *
+ * @expect: string ExpectType value.
+ *
+ * Convert @expect back into an enum value.
+ *
+ * Returns: ExpectType representing @expect, or -1 if not known.
+ **/
+ExpectType
+job_class_expect_type_str_to_enum (const char *expect)
+{
+	if (! expect)
+		goto error;
+
+	state_str_to_enum (EXPECT_NONE, expect);
+	state_str_to_enum (EXPECT_STOP, expect);
+	state_str_to_enum (EXPECT_DAEMON, expect);
+	state_str_to_enum (EXPECT_FORK, expect);
+
+error:
+	return -1;
+}
+
+/**
+ * job_class_console_type_enum_to_str:
+ *
+ * @console: ConsoleType.
+ *
+ * Convert ConsoleType to a string representation.
+ *
+ * Returns: string representation of @console, or NULL if not known.
+ **/
+const char *
+job_class_console_type_enum_to_str (ConsoleType console)
+{
+	state_enum_to_str (CONSOLE_NONE, console);
+	state_enum_to_str (CONSOLE_OUTPUT, console);
+	state_enum_to_str (CONSOLE_OWNER, console);
+	state_enum_to_str (CONSOLE_LOG, console);
+
+	return NULL;
+}
+
+/**
+ * job_class_console_type_str_to_enum:
+ *
+ * @console: string ConsoleType value.
+ *
+ * Convert @console back into enum value.
+ *
+ * Returns: ExpectType representing @console, or -1 if not known.
+ **/
+ConsoleType
+job_class_console_type_str_to_enum (const char *console)
+{
+	if (! console)
+		goto error;
+
+	state_str_to_enum (CONSOLE_NONE, console);
+	state_str_to_enum (CONSOLE_OUTPUT, console);
+	state_str_to_enum (CONSOLE_OWNER, console);
+	state_str_to_enum (CONSOLE_LOG, console);
+
+error:
+	return -1;
+}
+
+/**
+ * job_class_prepare_reexec:
+ *
+ * Prepare for a re-exec by clearing the CLOEXEC bit on all log object
+ * file descriptors associated with their parent jobs.
+ **/
+void
+job_class_prepare_reexec (void)
+{
+	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;
+
+			nih_assert (job->log);
+
+			for (int process = 0; process < PROCESS_LAST; process++) {
+				int  fd;
+				Log *log;
+
+				log = job->log[process];
+
+				/* No associated job process or logger has detected
+				 * remote end of pty has closed.
+				 */
+				if (! log || ! log->io)
+					continue;
+
+				nih_assert (log->io->watch);
+
+				fd = log->io->watch->fd;
+				if (fd < 0)
+					continue;
+
+				if (state_toggle_cloexec (fd, FALSE) < 0)
+					goto error;
+
+				fd = log->fd;
+				if (fd < 0)
+					continue;
+
+				if (state_toggle_cloexec (fd, FALSE) < 0)
+					goto error;
+			}
+		}
+	}
+
+	return;
+
+error:
+	nih_warn (_("unable to clear CLOEXEC bit on log fd"));
+}

=== modified file 'init/job_class.h'
--- init/job_class.h	2012-02-16 15:45:41 +0000
+++ init/job_class.h	2012-11-07 15:22:20 +0000
@@ -196,7 +196,7 @@
 	int             task;
 
 	time_t          kill_timeout;
-	int		kill_signal;
+	int             kill_signal;
 
 	int             respawn;
 	int             respawn_limit;
@@ -238,6 +238,8 @@
 int         job_class_consider             (JobClass *class);
 int         job_class_reconsider           (JobClass *class);
 
+void        job_class_add_safe             (JobClass *class);
+
 void        job_class_register             (JobClass *class,
 					    DBusConnection *conn, int signal);
 void        job_class_unregister           (JobClass *class,
@@ -306,9 +308,42 @@
 					    NihDBusMessage *message,
 					    char **usage);
 
+const char *
+job_class_console_type_enum_to_str (ConsoleType console)
+	__attribute__ ((warn_unused_result));
+
+ConsoleType
+job_class_console_type_str_to_enum (const char *name)
+	__attribute__ ((warn_unused_result));
+
+const char *
+job_class_expect_type_enum_to_str (ExpectType expect)
+	__attribute__ ((warn_unused_result));
+
+ExpectType
+job_class_expect_type_str_to_enum (const char *name)
+	__attribute__ ((warn_unused_result));
+
 ConsoleType job_class_console_type         (const char *console)
 	__attribute__ ((warn_unused_result));
 
+json_object *job_class_serialise (const JobClass *class)
+	__attribute__ ((warn_unused_result, malloc));
+
+JobClass *job_class_deserialise (json_object *json)
+	__attribute__ ((malloc, warn_unused_result));
+
+json_object * job_class_serialise_all (void)
+	__attribute__ ((warn_unused_result, malloc));
+
+int job_class_deserialise_all (json_object *json)
+	__attribute__ ((warn_unused_result));
+
+JobClass * job_class_get (const char *name, Session *session)
+	__attribute__ ((warn_unused_result));
+
+void job_class_prepare_reexec (void);
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_CLASS_H */

=== modified file 'init/job_process.c'
--- init/job_process.c	2012-08-02 08:57:20 +0000
+++ init/job_process.c	2012-11-07 15:22:20 +0000
@@ -211,7 +211,7 @@
 		while (p && (*p == '\n'))
 			p++;
 
-		if ((! nl) || (! *p)) {
+		if ((! nl) || (p && ! *p)) {
 			/* Strip off the newline(s) */
 			if (nl)
 				*nl = '\0';
@@ -1226,7 +1226,7 @@
 	nih_assert (job != NULL);
 	nih_assert (job->pid[process] > 0);
 	nih_assert (job->kill_timer == NULL);
-	nih_assert (job->kill_process = -1);
+	nih_assert (job->kill_process == PROCESS_INVALID);
 
 	nih_info (_("Sending %s signal to %s %s process (%d)"),
 		  nih_signal_to_name (job->class->kill_signal),
@@ -1246,13 +1246,50 @@
 		return;
 	}
 
+	job_process_set_kill_timer (job, process, job->class->kill_timeout);
+}
+
+/**
+ * job_process_set_kill_timer:
+ * @job: job to set kill timer for,
+ * @process: process to be killed,
+ * @timeout: timeout to apply for timer.
+ *
+ * Set kill timer for specified @job @process with timeout @timeout.
+ **/
+void
+job_process_set_kill_timer (Job          *job,
+		  	    ProcessType   process,
+			    time_t        timeout)
+{
+	nih_assert (job);
+	nih_assert (timeout);
+
 	job->kill_process = process;
 	job->kill_timer = NIH_MUST (nih_timer_add_timeout (
-			  job, job->class->kill_timeout,
+			  job, timeout,
 			  (NihTimerCb)job_process_kill_timer, job));
 }
 
 /**
+ * job_process_adj_kill_timer:
+ *
+ * @job: job whose kill timer is to be modified,
+ * @due: new due time to set for job kill timer.
+ *
+ * Adjust due time for @job's kill timer to @due.
+ **/
+void
+job_process_adj_kill_timer (Job *job, time_t due)
+{
+	nih_assert (job);
+	nih_assert (job->kill_timer);
+	nih_assert (due);
+
+	job->kill_timer->due = due;
+}
+
+/**
  * job_process_kill_timer:
  * @job: job to kill process of,
  * @timer: timer that caused us to be called.
@@ -1270,13 +1307,13 @@
 	nih_assert (job != NULL);
 	nih_assert (timer != NULL);
 	nih_assert (job->kill_timer == timer);
-	nih_assert (job->kill_process != (ProcessType)-1);
+	nih_assert (job->kill_process != PROCESS_INVALID);
 
 	process = job->kill_process;
 	nih_assert (job->pid[process] > 0);
 
 	job->kill_timer = NULL;
-	job->kill_process = -1;
+	job->kill_process = PROCESS_INVALID;
 
 	nih_info (_("Sending %s signal to %s %s process (%d)"),
 		  "KILL",
@@ -1547,7 +1584,7 @@
 						  job_name (job));
 
 					failed = FALSE;
-					job_failed (job, -1, 0);
+					job_failed (job, PROCESS_INVALID, 0);
 				} else {
 					nih_warn (_("%s %s process ended, respawning"),
 						  job_name (job),
@@ -1631,7 +1668,7 @@
 	if (job->kill_timer) {
 		nih_unref (job->kill_timer, job);
 		job->kill_timer = NULL;
-		job->kill_process = -1;
+		job->kill_process = PROCESS_INVALID;
 	}
 
 	if (job->class->console == CONSOLE_LOG && job->log[process]) {

=== modified file 'init/job_process.h'
--- init/job_process.h	2012-08-02 08:57:20 +0000
+++ init/job_process.h	2012-11-07 15:22:20 +0000
@@ -143,6 +143,12 @@
 char  *job_process_log_path (Job *job, int user_job)
 	__attribute__ ((malloc, warn_unused_result));
 
+void   job_process_set_kill_timer (Job          *job,
+		  	    ProcessType   process,
+			    time_t        timeout);
+
+void   job_process_adj_kill_timer  (Job *job, time_t due);
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_PROCESS_H */

=== modified file 'init/log.c'
--- init/log.c	2012-03-16 21:06:11 +0000
+++ init/log.c	2012-11-07 15:22:20 +0000
@@ -393,7 +393,7 @@
  *
  * Opens log file associated with @log if not already open.
  *
- * Returns 0 on success, -1 on failure.
+ * Returns: 0 on success, -1 on failure.
  **/
 static int
 log_file_open (Log *log)
@@ -505,7 +505,7 @@
  *   a corrupted log file should space later become
  *   available.
  *
- * Returns 0 on success, -1 on failure.
+ * Returns: 0 on success, -1 on failure.
  **/
 static int
 log_file_write (Log *log, const char *buf, size_t len)
@@ -638,6 +638,8 @@
 		if (nih_io_buffer_resize (io->recv_buf, LOG_READ_SIZE) < 0)
 			break;
 
+		errno = 0;
+
 		/* Append to buffer */
 		len = read (io->watch->fd,
 				io->recv_buf->buf + io->recv_buf->len,
@@ -680,22 +682,23 @@
 		 * causes the loop to be exited.
 		 */
 		if (len <= 0) {
+			/* Job process has ended and we've drained all the data the job
+			 * produced, so remote end must have closed.
+			 *
+			 * This cannot be handled entirely by log_io_error_handler()
+			 * since the job may produce some output prior to disks being
+			 * writeable, then end without producing further output.
+			 * In this scenario the error handler is never called.
+			 *
+			 */
+			if (saved && saved != EAGAIN && saved != EWOULDBLOCK)
+				log->remote_closed = 1;
+
 			close (log->fd);
 			log->fd = -1;
 			break;
 		}
 	}
-
-	/* Job process has ended and we've drained all the data the job
-	 * produced, so remote end must have closed.
-	 *
-	 * This cannot be handled entirely by log_io_error_handler()
-	 * since the job may produce some output prior to disks being
-	 * writeable, then end without producing further output.
-	 * In this scenario the error handler is never called.
-	 *
-	 */
-	log->remote_closed = 1;
 }
 
 /**
@@ -810,3 +813,189 @@
 
 	return 0;
 }
+
+/**
+ * log_serialise:
+ * @log: log to serialise.
+ *
+ * Convert @log into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised Log object, or NULL on error.
+ **/
+json_object *
+log_serialise (Log *log)
+{
+	json_object     *json;
+	nih_local char  *unflushed_hex = NULL;
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! log || (! log->io && log->unflushed && ! log->unflushed->len)) {
+		/* Create a "placeholder" log object for non-existent
+		 * log objects and for those that are no longer usable.
+		 */
+		if (! state_set_json_string_var (json, "path", NULL))
+			goto error;
+		return json;
+	}
+
+	/* Attempt to flush any cached data */
+	if (log->unflushed->len) {
+		/* Don't check return values since if this fails and
+		 * unflushed data remains, we encode it below.
+		 */
+		if (log->fd < 0)
+			(void)log_file_open (log);
+		if (log->fd != -1)
+			(void)log_file_write (log, NULL, 0);
+	}
+
+	nih_assert (log->io);
+
+	if (! state_set_json_int_var_from_obj (json, log, fd))
+		goto error;
+
+	nih_assert (log->io->watch);
+
+	if (! state_set_json_int_var (json, "io_watch_fd", log->io->watch->fd))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, log, path))
+		goto error;
+
+	/* log->io itself is not encoded */
+
+	if (! state_set_json_int_var_from_obj (json, log, uid))
+		goto error;
+
+	/* Encode unflushed data as hex to ensure any embedded
+	 * nulls are handled.
+	 */
+	if (log->unflushed->len) {
+		unflushed_hex = state_data_to_hex (NULL,
+				log->unflushed->buf,
+				log->unflushed->len);
+
+		if (! unflushed_hex)
+			goto error;
+
+		if (! state_set_json_string_var (json, "unflushed", unflushed_hex))
+			goto error;
+	}
+
+	if (! state_set_json_int_var_from_obj (json, log, detached))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, log, remote_closed))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, log, open_errno))
+		goto error;
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * log_deserialise:
+ * @json: JSON-serialised Log object to deserialise.
+ *
+ * Convert @json into a Log object.
+ *
+ * Returns: Log object, or NULL on error.
+ **/
+Log *
+log_deserialise (const void *parent,
+		 json_object *json)
+{
+	Log             *log;
+	nih_local char  *unflushed_hex = NULL;
+	nih_local char  *unflushed = NULL;
+	int              ret;
+	size_t           len;
+	json_object     *json_unflushed;
+	nih_local char  *path = NULL;
+	int              io_watch_fd = -1;
+	uid_t            uid = (uid_t)-1;
+
+	nih_assert (json);
+
+	log_unflushed_init ();
+
+	if (! state_check_json_type (json, object))
+		return NULL;
+
+	if (! state_get_json_string_var (json, "path", NULL, path))
+		return NULL;
+
+	if (! path) {
+		/* placeholder log object */
+		return NULL;
+	}
+
+	if (! state_get_json_int_var (json, "io_watch_fd", io_watch_fd))
+		return NULL;
+
+	nih_assert (io_watch_fd != -1);
+
+	/* re-apply CLOEXEC flag to stop job fd being leaked to children */
+	if (state_toggle_cloexec (io_watch_fd, TRUE) < 0)
+		return NULL;
+
+	if (! state_get_json_int_var (json, "uid", uid))
+		return NULL;
+
+	log = log_new (parent, path, io_watch_fd, uid);
+	if (! log)
+		return NULL;
+
+	if (! state_get_json_int_var_to_obj (json, log, fd))
+		goto error;
+
+	/* re-apply CLOEXEC flag to stop log file fd being leaked to children */
+	if (log->fd != -1 && state_toggle_cloexec (log->fd, TRUE) < 0)
+		return NULL;
+
+	log->unflushed = nih_io_buffer_new (log);
+	if (! log->unflushed)
+		goto error;
+
+	json_unflushed = json_object_object_get (json, "unflushed");
+	if (json_unflushed) {
+		if (! state_get_json_string_var_strict (json, "unflushed", NULL, unflushed_hex))
+			goto error;
+
+		ret = state_hex_to_data (NULL,
+				unflushed_hex,
+				strlen (unflushed_hex),
+				&unflushed,
+				&len);
+
+		if (ret < 0)
+			goto error;
+
+		if (nih_io_buffer_push (log->unflushed, unflushed, len) < 0)
+			goto error;
+	}
+
+	if (! state_get_json_int_var_to_obj (json, log, detached))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, log, remote_closed))
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, log, open_errno))
+		goto error;
+
+	return log;
+
+error:
+	nih_free (log);
+	return NULL;
+}

=== modified file 'init/log.h'
--- init/log.h	2012-02-14 16:47:34 +0000
+++ init/log.h	2012-11-07 15:22:20 +0000
@@ -29,6 +29,8 @@
 #include <nih/logging.h>
 #include <nih/error.h>
 
+#include "state.h"
+
 /** LOG_DEFAULT_UMASK:
  *
  * The default file creation mask for log files.
@@ -55,7 +57,7 @@
  * @io: NihIo associated with jobs stdout and stderr,
  * @uid: User ID of caller,
  * @unflushed: Unflushed data,
- * @detached: TRUE if log is no longer associated with a parent,(job),
+ * @detached: TRUE if log is no longer associated with a parent (job),
  * @remote_closed: TRUE if remote end of pty has been closed,
  * @open_errno: value of errno immediately after last attempt to open @path.
  **/
@@ -79,11 +81,17 @@
 	__attribute__ ((warn_unused_result, malloc));
 void  log_io_reader          (Log *log, NihIo *io, const char *buf, size_t len);
 void  log_io_error_handler   (Log *log, NihIo *io);
-int   log_destroy            (Log *log);
-int   log_handle_unflushed   (void *parent, Log *log);
-int   log_clear_unflushed    (void);
+int   log_destroy            (Log *log)
+	__attribute__ ((warn_unused_result));
+int   log_handle_unflushed   (void *parent, Log *log)
+	__attribute__ ((warn_unused_result));
+int   log_clear_unflushed    (void)
+	__attribute__ ((warn_unused_result));
 void  log_unflushed_init     (void);
-
+json_object * log_serialise (Log *log)
+	__attribute__ ((warn_unused_result, malloc));
+Log * log_deserialise (const void *parent, json_object *json)
+	__attribute__ ((warn_unused_result, malloc));
 
 NIH_END_EXTERN
 

=== modified file 'init/main.c'
--- init/main.c	2012-08-07 16:39:00 +0000
+++ init/main.c	2012-11-07 15:22:20 +0000
@@ -60,12 +60,16 @@
 #include "event.h"
 #include "conf.h"
 #include "control.h"
+#include "state.h"
 
 
 /* Prototypes for static functions */
 #ifndef DEBUG
 static int  logger_kmsg     (NihLogLevel priority, const char *message);
 static void crash_handler   (int signum);
+#endif /* DEBUG */
+static void term_handler    (void *data, NihSignal *signal);
+#ifndef DEBUG
 static void cad_handler     (void *data, NihSignal *signal);
 static void kbd_handler     (void *data, NihSignal *signal);
 static void pwr_handler     (void *data, NihSignal *signal);
@@ -79,20 +83,12 @@
 
 
 /**
- * argv0:
- *
- * Path to program executed, used for re-executing the init binary from the
- * same location we were executed from.
- **/
-static const char *argv0 = NULL;
-
-/**
- * restart:
- *
- * This is set to TRUE if we're being re-exec'd by an existing init
- * process.
- **/
-static int restart = FALSE;
+ * state_fd:
+ *
+ * File descriptor to read serialised state from when performing
+ * stateful re-exec. If value is not -1, attempt stateful re-exec.
+ **/
+static int state_fd = -1;
 
 /**
  * conf_dir:
@@ -147,7 +143,13 @@
 	{ 0, "no-startup-event", N_("do not emit any startup event (for testing)"),
 		NULL, NULL, &disable_startup_event, NULL },
 
-	{ 0, "restart", NULL, NULL, NULL, &restart, NULL },
+	/* Must be specified for both stateful and stateless re-exec */
+	{ 0, "restart", N_("flag a re-exec has occurred"),
+		NULL, NULL, &restart, NULL },
+
+	/* Required for stateful re-exec */
+	{ 0, "state-fd", N_("specify file descriptor to read serialisation data from"),
+		NULL, "FD", &state_fd, nih_option_int },
 
 	{ 0, "session", N_("use D-Bus session bus rather than system bus (for testing)"),
 		NULL, NULL, &use_session_bus, NULL },
@@ -166,11 +168,12 @@
 main (int   argc,
       char *argv[])
 {
-	char **args;
+	char **args = NULL;
 	int    ret;
 
-	argv0 = argv[0];
-	nih_main_init (argv0);
+	args_copy = NIH_MUST (nih_str_array_copy (NULL, NULL, argv));
+
+	nih_main_init (args_copy[0]);
 
 	nih_option_set_synopsis (_("Process management daemon."));
 	nih_option_set_help (
@@ -295,8 +298,9 @@
 		 */
 		if (system_setup_console (CONSOLE_OUTPUT, (! restart)) < 0) {
 			NihError *err;
-	
+
 			err = nih_error_get ();
+
 			nih_warn ("%s: %s", _("Unable to initialize console, will try /dev/null"),
 				  err->message);
 			nih_free (err);
@@ -411,7 +415,16 @@
 		/* 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.
+	 */
+	nih_signal_set_handler (SIGTERM, nih_signal_handler);
+	NIH_MUST (nih_signal_add_handler (NULL, SIGTERM, term_handler, NULL));
+
 #endif /* DEBUG */
 
 
@@ -456,6 +469,48 @@
 	}
 
 
+	if (restart) {
+		if (state_fd == -1) {
+			nih_warn ("%s",
+				_("Stateful re-exec supported but stateless re-exec requested"));
+		} else if (state_read (state_fd) < 0) {
+			nih_local char *arg = NULL;
+
+			/* Stateful re-exec has failed so try once more by
+			 * degrading to stateless re-exec, which even in
+			 * the case of low-memory scenarios will work.
+			 */
+
+			/* Inform the child we've given up on stateful
+			 * re-exec.
+			 */
+			close (state_fd);
+
+			nih_error ("%s - %s",
+				_("Failed to read serialisation data"),
+				_("reverting to stateless re-exec"));
+
+			/* Remove any existing (but now stale) state fd
+			 * args which will effectively disable stateful
+			 * re-exec.
+			 */
+			clean_args (&args_copy);
+
+			/* Attempt stateless re-exec */
+			perform_reexec ();
+
+			nih_error ("%s",
+				_("Both stateful and stateless re-execs failed"));
+
+			/* Out of options */
+			nih_assert_not_reached ();
+		} else {
+			close (state_fd);
+
+			nih_info ("Stateful re-exec completed");
+		}
+	}
+
 	/* Read configuration */
 	NIH_MUST (conf_source_new (NULL, CONFFILE, CONF_FILE));
 	NIH_MUST (conf_source_new (NULL, conf_dir, CONF_JOB_DIR));
@@ -479,7 +534,8 @@
 	}
 
 	/* Open connection to the appropriate D-Bus bus; we normally expect this to
-	 * fail and will try again later - don't let ENOMEM stop us though.
+	 * fail (since dbus-daemon probably isn't running yet) and will try again
+	 * later - don't let ENOMEM stop us though.
 	 */
 	while (control_bus_open () < 0) {
 		NihError *err;
@@ -529,9 +585,17 @@
 		}
 
 	} else {
-		sigset_t mask;
-
-		/* We're ok to receive signals again */
+		sigset_t        mask;
+
+		/* We have been re-exec'd. Don't emit an initial event
+		 * as only Upstart is restarting - we don't want to restart
+		 * the system (another reason being that we don't yet support
+		 * upstart-in-initramfs to upstart-in-root-filesystem
+		 * state-passing transitions).
+		 */
+
+		/* We're ok to receive signals again so restore signals
+		 * disabled by the term_handler */
 		sigemptyset (&mask);
 		sigprocmask (SIG_SETMASK, &mask, NULL);
 	}
@@ -631,7 +695,7 @@
 {
 	pid_t pid;
 
-	nih_assert (argv0 != NULL);
+	nih_assert (args_copy[0] != NULL);
 
 	pid = fork ();
 	if (pid == 0) {
@@ -685,7 +749,30 @@
 	/* Goodbye, cruel world. */
 	exit (signum);
 }
-
+#endif
+
+/**
+ * term_handler:
+ * @data: unused,
+ * @signal: signal caught.
+ *
+ * This is called when we receive the TERM signal, which instructs us
+ * to reexec ourselves.
+ **/
+static void
+term_handler (void      *data,
+	      NihSignal *signal)
+{
+	nih_assert (args_copy[0] != NULL);
+	nih_assert (signal != NULL);
+
+	nih_warn (_("Re-executing %s"), args_copy[0]);
+
+	stateful_reexec ();
+}
+
+
+#ifndef DEBUG
 /**
  * cad_handler:
  * @data: unused,
@@ -835,7 +922,7 @@
  * NihOption setter function to handle selection of default console
  * type.
  *
- * Returns 0 on success, -1 on invalid console type.
+ * Returns: 0 on success, -1 on invalid console type.
  **/
 static int
 console_type_setter (NihOption *option, const char *arg)
@@ -851,3 +938,4 @@
 
 	 return 0;
 }
+

=== modified file 'init/parse_job.c'
--- init/parse_job.c	2012-10-22 13:29:45 +0000
+++ init/parse_job.c	2012-11-07 15:22:20 +0000
@@ -37,7 +37,6 @@
 #include <nih/string.h>
 #include <nih/list.h>
 #include <nih/signal.h>
-#include <nih/config.h>
 #include <nih/logging.h>
 #include <nih/error.h>
 
@@ -625,6 +624,48 @@
 }
 
 /**
+ * parse_on_simple:
+ * @class: job class being parsed,
+ * @stanza_name: name of stanza type to parse ("start" or "stop"),
+ * @string: string to parse.
+ *
+ * Parse either a "start" or "stop" condition from @string (which must
+ * start with the first byte beyond either "start on" or "stop on".
+ *
+ * Returns: EventOperator at root of expression tree on success, NULL
+ * on raised error.
+ **/
+EventOperator *
+parse_on_simple (JobClass *class, const char *stanza_name, const char *string)
+{
+	EventOperator    *root = NULL;
+	NihConfigStanza  *stanza = NULL;
+	size_t            pos = 0;
+	size_t            lineno = 0;
+	size_t            len;
+
+	nih_assert (class);
+	nih_assert (stanza_name);
+	nih_assert (string);
+
+	/* Find the appropriate config stanza */
+	for (NihConfigStanza *s = stanzas; s->name; s++) {
+		if (! strcmp (stanza_name, s->name)) {
+			stanza = s;
+			break;
+		}
+	}
+
+	nih_assert (stanza);
+
+	len = strlen (string);
+
+	root = parse_on (class, stanza, string, len, &pos, &lineno);
+
+	return root;
+}
+
+/**
  * parse_on_operator:
  * @class: job class being parsed,
  * @stanza: stanza found,

=== modified file 'init/parse_job.h'
--- init/parse_job.h	2011-06-06 12:52:08 +0000
+++ init/parse_job.h	2012-11-07 15:22:20 +0000
@@ -21,6 +21,7 @@
 #define INIT_PARSE_JOB_H
 
 #include <nih/macros.h>
+#include <nih/config.h>
 
 #include "session.h"
 #include "job_class.h"
@@ -34,6 +35,10 @@
 		     size_t *pos, size_t *lineno)
 	__attribute__ ((warn_unused_result, malloc));
 
+EventOperator *
+parse_on_simple (JobClass *class, const char *stanza_name,
+		 const char *string)
+	__attribute__ ((warn_unused_result, malloc));
 NIH_END_EXTERN
 
 #endif /* INIT_PARSE_JOB_H */

=== modified file 'init/process.c'
--- init/process.c	2009-06-23 09:29:35 +0000
+++ init/process.c	2012-11-07 15:22:20 +0000
@@ -29,8 +29,10 @@
 #include <nih/macros.h>
 #include <nih/alloc.h>
 #include <nih/logging.h>
+#include <nih/string.h>
 
 #include "process.h"
+#include "state.h"
 
 
 /**
@@ -116,3 +118,226 @@
 		return -1;
 	}
 }
+
+/**
+ * process_serialise:
+ * @process: process to serialise.
+ *
+ * Convert @process into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised Process object, or NULL on error.
+ **/
+json_object *
+process_serialise (const Process *process)
+{
+	json_object  *json;
+
+	nih_assert (process);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! state_set_json_int_var_from_obj (json, process, script))
+		goto error;
+
+	if (! state_set_json_string_var_from_obj (json, process, command))
+		goto error;
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+
+}
+
+/**
+ * process_serialise_all:
+ *
+ * @processes: array of Processes.
+ *
+ * Convert array of Process objects to JSON representation.
+ *
+ * Returns: JSON object containing array of Processes, or NULL on error.
+ */
+json_object *
+process_serialise_all (const Process * const * const processes)
+{
+	json_object *json;
+	json_object *json_process;
+	Process      dummy = { 0, NULL };
+
+	nih_assert (processes);
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	for (int i = 0; i < PROCESS_LAST; i++) {
+		/* We must encode a blank entry for missing array elements
+		 * to ensure correct deserialisation.
+		 */
+		json_process = process_serialise (processes[i]
+				? processes[i]
+				: &dummy);
+
+		if (! json_process)
+			goto error;
+
+		if (json_object_array_add (json, json_process) < 0)
+			goto error;
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * process_deserialise:
+ * @json: JSON-serialised Process object to deserialise.
+ *
+ * Convert @json into a Process object.
+ *
+ * Returns: Process object, or NULL on error.
+ **/
+Process *
+process_deserialise (json_object *json, const void *parent)
+{
+	Process  *process = NULL;
+
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		goto error;
+
+	process = NIH_MUST (process_new (parent));
+
+	if (! state_get_json_int_var_to_obj (json, process, script))
+			goto error;
+
+	if (! state_get_json_string_var_to_obj (json, process, command))
+		goto error;
+
+	/* All Process slots have to be serialised in the JSON to
+	 * guarantee ordering on deserialisation.
+	 *
+	 * However, here we've found a Process that was merely
+	 * an ordering placeholder - no command has been defined,
+	 * so ignore it.
+	 */
+	if (! process->command)
+		goto error;
+
+	return process;
+
+error:
+	nih_free (process);
+	return NULL;
+}
+
+/**
+ * process_deserialise_all:
+ *
+ * @json: root of JSON-serialised state,
+ * @parent: parent of @processes,
+ * @processes: newly-allocated array of Process objects.
+ *
+ * Convert JSON representation of processes back into
+ * an array of Process objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+process_deserialise_all (json_object *json, const void *parent,
+			 Process **processes)
+{
+	json_object        *json_processes;
+	int                 i;
+
+	nih_assert (json);
+	nih_assert (parent);
+	nih_assert (processes);
+
+	json_processes = json_object_object_get (json, "process");
+
+	if (! json_processes)
+		goto error;
+
+	if (! state_check_json_type (json_processes, array))
+		goto error;
+
+	for (i = 0; i < json_object_array_length (json_processes); i++) {
+		json_object *json_process;
+
+		nih_assert (i <= PROCESS_LAST);
+
+		json_process = json_object_array_get_idx (json_processes, i);
+		if (! json_process)
+			goto error;
+
+		if (! state_check_json_type (json_process, object))
+			goto error;
+
+		processes[i] = process_deserialise (json_process, parent);
+
+	}
+
+	return 0;
+
+error:
+	return -1;
+}
+
+/**
+ * process_type_enum_to_str:
+ *
+ * @type: ProcessType.
+ *
+ * Convert ProcessType to a string representation.
+ *
+ * Returns: string representation of @type, or NULL if not known.
+ **/
+const char *
+process_type_enum_to_str (ProcessType type)
+{
+	state_enum_to_str (PROCESS_INVALID, type);
+	state_enum_to_str (PROCESS_MAIN, type);
+	state_enum_to_str (PROCESS_PRE_START, type);
+	state_enum_to_str (PROCESS_POST_START, type);
+	state_enum_to_str (PROCESS_PRE_STOP, type);
+	state_enum_to_str (PROCESS_POST_STOP, type);
+
+	return NULL;
+}
+
+/**
+ * process_type_str_to_enum:
+ *
+ * @type: string ProcessType.
+ *
+ * Convert @type back into enum value.
+ *
+ * Returns: ProcessType representation of @type, or -1 if not known.
+ **/
+ProcessType
+process_type_str_to_enum (const char *type)
+{
+	if (! type)
+		goto error;
+
+	state_str_to_enum (PROCESS_INVALID, type);
+	state_str_to_enum (PROCESS_MAIN, type);
+	state_str_to_enum (PROCESS_PRE_START, type);
+	state_str_to_enum (PROCESS_POST_START, type);
+	state_str_to_enum (PROCESS_PRE_STOP, type);
+	state_str_to_enum (PROCESS_POST_STOP, type);
+
+error:
+	return -1;
+}
+

=== modified file 'init/process.h'
--- init/process.h	2009-06-23 09:29:35 +0000
+++ init/process.h	2012-11-07 15:22:20 +0000
@@ -22,20 +22,30 @@
 
 #include <nih/macros.h>
 
+#include <json.h>
 
 /**
  * ProcessType:
  *
  * This is used to enumerate the array of process definitions attached to
  * a job class, and the array of pids attached to a job instance.
+ *
+ * Note that PROCESS_INVALID would ideally be -1 but that isn't possible
+ * since process_type_str_to_enum() would then not be able to distinguish
+ * between an invalid ProcessType and the default value assigned to a
+ * ProcessType. It also cannot be zero since that would upset iterating
+ * through the (non-invalid) entries.
  **/
 typedef enum process_type {
-	PROCESS_MAIN,
+	/* initial value denoting no process */
+	PROCESS_INVALID = -2,
+
+	PROCESS_MAIN = 0,
 	PROCESS_PRE_START,
 	PROCESS_POST_START,
 	PROCESS_PRE_STOP,
 	PROCESS_POST_STOP,
-	PROCESS_LAST
+	PROCESS_LAST,
 } ProcessType;
 
 
@@ -65,7 +75,32 @@
 
 const char *process_name      (ProcessType process)
 	__attribute__ ((const));
-ProcessType process_from_name (const char *process);
+
+json_object *process_serialise (const Process *process)
+	__attribute__ ((malloc, warn_unused_result));
+
+Process *process_deserialise (json_object *json, const void *parent)
+	__attribute__ ((malloc, warn_unused_result));
+
+json_object *
+process_serialise_all (const Process * const * const processes)
+	__attribute__ ((malloc, warn_unused_result));
+
+ProcessType process_from_name (const char *process)
+	__attribute__ ((warn_unused_result));
+
+int
+process_deserialise_all (json_object *json, const void *parent,
+			 Process **processes)
+	__attribute__ ((warn_unused_result));
+
+const char *
+process_type_enum_to_str (ProcessType type)
+	__attribute__ ((warn_unused_result));
+
+ProcessType
+process_type_str_to_enum (const char *type)
+	__attribute__ ((warn_unused_result));
 
 NIH_END_EXTERN
 

=== modified file 'init/session.c'
--- init/session.c	2011-12-09 14:07:11 +0000
+++ init/session.c	2012-11-07 15:22:20 +0000
@@ -47,6 +47,15 @@
 #include "conf.h"
 #include "paths.h"
 
+extern json_object *json_sessions;
+
+/* Prototypes for static functions */
+static json_object  *session_serialise   (const Session *session)
+	__attribute__ ((malloc, warn_unused_result));
+
+static Session *session_deserialise (json_object *json)
+	__attribute__ ((malloc, warn_unused_result));
+
 
 /**
  * sessions:
@@ -66,8 +75,7 @@
 
 
 /* Prototypes for static functions */
-static void session_create_conf_source (Session *sesson);
-
+static void session_create_conf_source (Session *sesson, int deserialised);
 
 /**
  * session_init:
@@ -90,7 +98,7 @@
  *
  * Create a new session.
  *
- * Return new Session, or NULL on error.
+ * Returns: new Session, or NULL on error.
  **/
 Session *
 session_new (const void *parent,
@@ -137,7 +145,7 @@
  *
  * Create a new session, based on the specified D-Bus message.
  *
- * Return new Session, or NULL on error.
+ * Returns: new Session, or NULL on error.
  **/
 Session *
 session_from_dbus (const void     *parent,
@@ -248,7 +256,7 @@
 			continue;
 
 		/* Found a user with the same uid but different
-		 * conf_dir to the existing session user. Either the
+		 * conf_path to the existing session user. Either the
 		 * original user has been deleted and a new user created
 		 * with the same uid, or the original users home
 		 * directory has changed since they first started
@@ -273,7 +281,7 @@
 		}
 
 		if (! session->conf_path)
-			session_create_conf_source (session);
+			session_create_conf_source (session, FALSE);
 
 		return session;
 	}
@@ -282,52 +290,63 @@
 	/* Didn't find one, make a new one */
 	session = NIH_MUST (session_new (parent, unix_process_id ? root : NULL,
 					 unix_user));
-	session_create_conf_source (session);
+	session_create_conf_source (session, FALSE);
 
 	return session;
 }
 
 /**
  * session_create_conf_source:
- * @session: Session.
+ * @session: Session,
+ * @deserialised: TRUE if ConfSource is to be created from a deserialised
+ * session object.
  *
- * Create a new ConfSouce object and associate the specified session
+ * Create a new ConfSource object and associate the specified Session
  * with it.
  **/
 static void
-session_create_conf_source (Session *session)
+session_create_conf_source (Session *session, int deserialised)
 {
 	ConfSource *source;
 
 	nih_assert (session != NULL);
-	nih_assert (session->conf_path == NULL);
-
-	if (session->chroot)
-		session->conf_path = NIH_MUST (nih_strdup (NULL, session->chroot));
-	if (session->user) {
-		struct passwd *pwd;
-
-		pwd = getpwuid (session->user);
-		if (! pwd) {
-			nih_error ("%d: %s: %s", session->user,
-				   _("Unable to lookup home directory"),
-				   strerror (errno));
-
-			nih_free (session->conf_path);
-			session->conf_path = NULL;
-			return;
+	nih_assert (deserialised
+			? session->conf_path != NULL
+			: session->conf_path == NULL);
+
+	session_init ();
+
+	if (! deserialised) {
+		if (session->chroot)
+			session->conf_path = NIH_MUST (nih_strdup (NULL, session->chroot));
+		if (session->user) {
+			struct passwd *pwd;
+
+			pwd = getpwuid (session->user);
+			if (! pwd) {
+				nih_error ("%d: %s: %s", session->user,
+						_("Unable to lookup home directory"),
+						strerror (errno));
+
+				nih_free (session->conf_path);
+				session->conf_path = NULL;
+				return;
+			}
+
+			NIH_MUST (nih_strcat_sprintf (&session->conf_path, NULL, "%s/%s",
+						pwd->pw_dir, USERCONFDIR));
+		} else {
+			NIH_MUST (nih_strcat (&session->conf_path, NULL, CONFDIR));
 		}
-
-		NIH_MUST (nih_strcat_sprintf (&session->conf_path, NULL, "%s/%s",
-					      pwd->pw_dir, USERCONFDIR));
-	} else {
-		NIH_MUST (nih_strcat (&session->conf_path, NULL, CONFDIR));
 	}
 
 	source = NIH_MUST (conf_source_new (session, session->conf_path,
 					    CONF_JOB_DIR));
 	source->session = session;
 
+	if (getenv ("UPSTART_TESTS"))
+		return;
+
 	if (conf_source_reload (source) < 0) {
 		NihError *err;
 
@@ -339,8 +358,257 @@
 		nih_free (err);
 
 		nih_free (source);
-		nih_free (session->conf_path);
-		session->conf_path = NULL;
 		return;
 	}
 }
+
+/**
+ * session_serialise:
+ * @session: session to serialise.
+ *
+ * Convert @session into a JSON representation for serialisation.
+ *
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised Session object, or NULL on error.
+ **/
+static json_object *
+session_serialise (const Session *session)
+{
+	json_object  *json;
+	json_object  *conf_path = NULL;
+	json_object  *chroot = NULL;
+	json_object  *user;
+
+	nih_assert (session);
+
+	session_init ();
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (session->chroot) {
+		chroot = json_object_new_string (session->chroot);
+		if (! chroot)
+			goto error;
+	}
+
+	json_object_object_add (json, "chroot", chroot);
+
+	user = state_new_json_int (session->user);
+	if (! user)
+		goto error;
+
+	json_object_object_add (json, "user", user);
+
+	if (session->conf_path) {
+		conf_path = json_object_new_string (session->conf_path);
+		if (! conf_path)
+			goto error;
+	}
+
+	json_object_object_add (json, "conf_path", conf_path);
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+
+}
+
+/**
+ * session_serialise_all:
+ *
+ * Convert existing Session objects to JSON representation.
+ *
+ * Returns: JSON object containing array of Sessions, or NULL on error.
+ **/
+json_object *
+session_serialise_all (void)
+{
+	json_object  *json;
+	json_object  *json_session;
+
+	session_init ();
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_LIST_FOREACH (sessions, iter) {
+		Session      *session = (Session *)iter;
+
+		json_session = session_serialise (session);
+
+		if (! json_session)
+			goto error;
+
+		if (json_object_array_add (json, json_session) < 0)
+			goto error;
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * session_deserialise:
+ * @json: JSON-serialised Session object to deserialise.
+ *
+ * Convert @json into a Session object.
+ *
+ * Returns: Session object, or NULL on error.
+ **/
+static Session *
+session_deserialise (json_object *json)
+{
+	Session              *session = NULL;
+	nih_local const char *chroot = NULL;
+	uid_t                 user = (uid_t)-1;
+
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		return NULL;
+
+	/* Note no check on value returned since chroot may be NULL */
+	if (! state_get_json_string_var (json, "chroot", NULL, chroot))
+		return NULL;
+
+	if (! state_get_json_int_var (json, "user", user))
+		return NULL;
+
+	/* Create a new session */
+	session = NIH_MUST (session_new (NULL, chroot, user));
+
+	if (! state_get_json_string_var_to_obj (json, session, conf_path))
+		goto error;
+
+	return session;
+
+error:
+	nih_free (session);
+	return NULL;
+}
+
+/**
+ * session_deserialise_all:
+ *
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of sessions back into Session objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+session_deserialise_all (json_object *json)
+{
+	Session  *session;
+
+	nih_assert (json);
+
+	session_init ();
+
+	nih_assert (NIH_LIST_EMPTY (sessions));
+
+	json_sessions = json_object_object_get (json, "sessions");
+
+	if (! json_sessions)
+		goto error;
+
+	if (! state_check_json_type (json_sessions, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_sessions); i++) {
+		json_object   *json_session;
+
+		json_session = json_object_array_get_idx (json_sessions, i);
+		if (! json_session)
+			goto error;
+
+		if (! state_check_json_type (json_session, object))
+			goto error;
+
+		session = session_deserialise (json_session);
+		if (! session)
+			goto error;
+
+		session_create_conf_source (session, TRUE);
+	}
+
+	return 0;
+
+error:
+	return -1;
+}
+
+/**
+ * session_get_index:
+ *
+ * @session: session.
+ *
+ * Determine JSON-serialised array index for specified @session.
+ *
+ * Returns: zero-based array index for @session, or -1 on error.
+ **/
+int
+session_get_index (const Session *session)
+{
+	int i;
+
+	/* Handle NULL session (which is not encoded) */
+	if (! session)
+		return 0;
+
+	/* Sessions are serialised in order, so just return the list
+	 * index.
+	 */
+	i = 1;
+	NIH_LIST_FOREACH (sessions, iter) {
+		Session *s = (Session *)iter;
+
+		if (s == session)
+			return i;
+
+		++i;
+	}
+
+	return -1;
+}
+
+/**
+ * session_from_index:
+ *
+ * @idx: zero-based index.
+ *
+ * Lookup session by index number.
+ *
+ * Returns: Session (which may be the NULL session).
+ **/
+Session *
+session_from_index (int idx)
+{
+	int       i;
+	Session  *session;
+
+	nih_assert (idx >= 0);
+
+	/* NULL session */
+	if (! idx)
+		return NULL;
+
+	i = 1;
+	NIH_LIST_FOREACH (sessions, iter) {
+		session = (Session *)iter;
+
+		if (i == idx)
+			return session;
+	}
+
+	nih_assert_not_reached ();
+}

=== modified file 'init/session.h'
--- init/session.h	2011-07-25 14:28:33 +0000
+++ init/session.h	2012-11-07 15:22:20 +0000
@@ -27,6 +27,7 @@
 
 #include <nih-dbus/dbus_message.h>
 
+#include <json.h>
 
 /**
  * Session:
@@ -77,12 +78,24 @@
 
 extern NihList *sessions;
 
-void     session_init      (void);
-
-Session *session_new       (const void *parent, const char *chroot, uid_t user)
-	__attribute__ ((malloc, warn_unused_result));
-
-Session *session_from_dbus (const void *parent, NihDBusMessage *message);
+void           session_init        (void);
+
+Session      * session_new         (const void *parent, const char *chroot, uid_t user)
+	__attribute__ ((malloc, warn_unused_result));
+
+Session      * session_from_dbus   (const void *parent, NihDBusMessage *message);
+
+json_object  * session_serialise_all   (void)
+	__attribute__ ((malloc, warn_unused_result));
+
+int            session_deserialise_all (json_object *json)
+	__attribute__ ((warn_unused_result));
+
+int            session_get_index (const Session *session)
+	__attribute__ ((warn_unused_result));
+
+Session *      session_from_index (int idx)
+	__attribute__ ((warn_unused_result));
 
 NIH_END_EXTERN
 

=== added file 'init/state.c'
--- init/state.c	1970-01-01 00:00:00 +0000
+++ init/state.c	2012-11-07 15:22:20 +0000
@@ -0,0 +1,2008 @@
+/* upstart
+ *
+ * state.c - serialisation and deserialisation support.
+ *
+ * Copyright © 2012 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.
+ */    
+
+#include <string.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/select.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <nih/macros.h>
+#include <nih/logging.h>
+#include <nih/string.h>
+#include <nih/io.h>
+
+#include "paths.h"
+#include "state.h"
+#include "session.h"
+#include "event.h"
+#include "job_class.h"
+#include "job.h"
+#include "environ.h"
+#include "blocked.h"
+#include "conf.h"
+#include "control.h"
+
+json_object *json_sessions = NULL;
+json_object *json_events = NULL;
+json_object *json_classes = NULL;
+
+extern int use_session_bus;
+
+/**
+ * args_copy:
+ *
+ * Copy of original argv used when re-executing to ensure same
+ * command-line is used. Required since we clear the actual args for
+ * ps(1) et al.
+ */
+char **args_copy = NULL;
+
+/**
+ * restart:
+ *
+ * This is set to TRUE if we're being re-exec'd by an existing init
+ * process.
+ **/
+int restart = FALSE;
+
+/* Prototypes for static functions */
+static json_object *
+state_serialise_blocked (const Blocked *blocked)
+	__attribute__ ((malloc, warn_unused_result));
+
+static Blocked *
+state_deserialise_blocked (void *parent, json_object *json, NihList *list)
+	__attribute__ ((malloc, warn_unused_result));
+
+static JobClass *
+state_index_to_job_class (int job_class_index)
+	__attribute__ ((warn_unused_result));
+
+static Job *
+state_get_job (const char *job_class, const char *job_name)
+	__attribute__ ((warn_unused_result));
+
+/**
+ * state_read:
+ *
+ * @fd: Open file descriptor to read JSON from.
+ *
+ * Read JSON-encoded state from specified file descriptor and recreate
+ * all internal objects based on JSON representation. The read will
+ * timeout, resulting in a failure after STATE_WAIT_SECS seconds
+ * indicating a problem with the child.
+ *
+ * Returns: 0 on success, or -1 on error.
+ **/
+int
+state_read (int fd)
+{
+	int             nfds;
+	int             ret;
+	fd_set          readfds;
+	struct timeval  timeout;
+
+	nih_assert (fd != -1);
+
+	state_get_timeout (timeout.tv_sec);
+	timeout.tv_usec = 0;
+
+	nfds = 1 + fd;
+
+	while (TRUE) {
+		FD_ZERO (&readfds);
+		FD_SET (fd, &readfds);
+
+		ret = select (nfds, &readfds, NULL, NULL,
+				timeout.tv_sec < 0 ? NULL : &timeout);
+
+		if (ret < 0 && (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK))
+			return -1;
+
+		if (FD_ISSET (fd, &readfds))
+			break;
+	}
+
+	nih_assert (ret == 1);
+
+	/* Now, read the data */
+	if (state_read_objects (fd) < 0)
+		return -1;
+
+	return 0;
+}
+
+/**
+ * state_write:
+ *
+ * @fd: Open file descriptor to write JSON to,
+ * @state_data: JSON string representing internal object state,
+ * @len: length of @state_data.
+ *
+ * Write internal state to specified file descriptor in JSON format.
+ *
+ * Signals are assumed to be blocked when this call is made.
+ *
+ * Note the timeout - it is possible that the new PID 1 instance may be
+ * unable to read from its end of the file descriptor, either due to
+ * some error scenario or more likely due to it not supporting stateful
+ * re-exec. Hence, we must have a way to detect this and abort the
+ * child.
+ *
+ * Returns: 0 on success, or -1 on error.
+ **/
+int
+state_write (int fd, const char *state_data, size_t len)
+{
+	int             nfds;
+	int             ret;
+	fd_set          writefds;
+	struct timeval  timeout;
+
+	nih_assert (fd != -1);
+	nih_assert (state_data);
+	nih_assert (len);
+
+	/* must be called from child process */
+	nih_assert (getpid () != (pid_t)1);
+
+	state_get_timeout (timeout.tv_sec);
+	timeout.tv_usec = 0;
+
+	nfds = 1 + fd;
+
+	while (TRUE) {
+		FD_ZERO (&writefds);
+		FD_SET (fd, &writefds);
+
+		ret = select (nfds, NULL, &writefds, NULL,
+				timeout.tv_sec < 0 ? NULL : &timeout);
+
+		if (ret < 0 && (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK))
+			return -1;
+
+		if (FD_ISSET (fd, &writefds))
+			break;
+	}
+
+	nih_assert (ret == 1);
+
+	if (state_write_objects (fd, state_data, len) < 0)
+		return -1;
+
+	return 0;
+}
+
+
+/**
+ * state_read_objects:
+ *
+ * @fd: file descriptor to read serialisation data from.
+ *
+ * Read serialisation data from specified file descriptor.
+ * @fd is assumed to be open and readable.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+state_read_objects (int fd)
+{
+	ssize_t                  ret;
+	int                      initial_size = 4096;
+	nih_local NihIoBuffer   *buffer = NULL;
+	nih_local char          *buf = NULL;
+
+	nih_assert (fd != -1);
+
+	buffer = nih_io_buffer_new (NULL);
+
+	buf = nih_alloc (NULL, initial_size);
+	if (! buf)
+		goto error;
+
+	/* Read the JSON data into the buffer */
+	do {
+		if (nih_io_buffer_resize (buffer, initial_size) < 0)
+			goto error;
+
+		ret = read (fd, buf, sizeof (buf));
+		if (ret < 0) {
+			if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
+				goto error;
+			continue;
+		} else if (! ret)
+			break;
+
+		if (nih_io_buffer_push (buffer, buf, ret) < 0)
+			goto error;
+	} while (TRUE);
+
+	/* Recreate internal state from JSON */
+	if (state_from_string (buffer->buf) < 0)
+		goto error;
+
+	return 0;
+
+error:
+	return -1;
+}
+
+/**
+ * state_write_objects:
+ *
+ * @fd: file descriptor to write serialisation data on,
+ * @state_data: JSON string representing internal object state,
+ * @len: length of @state_data.
+ *
+ * Write serialisation data to specified file descriptor.
+ * @fd is assumed to be open and valid to write to.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+state_write_objects (int fd, const char *state_data, size_t len)
+{
+	ssize_t   ret;
+
+	nih_assert (fd != -1);
+	nih_assert (state_data);
+	nih_assert (len);
+
+	ret = write (fd, state_data, len);
+
+	return (ret < 0 ? -1 : 0);
+}
+
+/**
+ * state_to_string:
+ *
+ * @json_string; newly-allocated string,
+ * @len: length of @json_string.
+ *
+ * Serialise internal data structures to a JSON string.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+state_to_string (char **json_string, size_t *len)
+{
+	json_object        *json;
+	const char         *value;
+
+	nih_assert (json_string);
+	nih_assert (len);
+
+	json = json_object_new_object ();
+
+	if (! json)
+		return -1;
+
+	json_sessions = session_serialise_all ();
+	if (! json_sessions)
+		goto error;
+
+	json_object_object_add (json, "sessions", json_sessions);