Merge lp:~jamesodhunt/upstart/serialise-remaining-objects into lp:upstart

[James Hunt]

This monster MP includes fixes for two bugs:

= bug 1124384 =

This bug has seemingly existed for a long time and only came to light when users of cloud-init attempted to overcome the inotify limitations of overlayfs (see bug 882147) by invoking 'initctl reload-configuration' in early boot to make Upstart consider newly-created jobs.

The issue has nothing to do with early boot though - potentially, whenever 'initctl reload-configuration' gets called and events are "in flight", the bug could be seen. However, since most filesystems have sane inotify semantics (thus negating the need for ever calling 'initctl reload-configuration), it is unsurprising this problem has only come to light recently.

The fix involved deferring the destruction of the original ConfFile object coupled with code to allow the newly-created (post-reload) JobClass to reference any relevant events before the original ConfFile and JobClass are destroyed. This allows the event reference count to stay positive across a reload.

= bug 1103881 =

This is an issue with stateful re-exec: the original approach was to serialise the start/stop on conditions as a logically identical representation of the original string from the .conf file. However, this meant that required EventOperator data was not available on deserialisation. This resulted in the possibility that events would be destroyed too early since their reference counts could drop to zero as the EventOperator references to those evens would not be re-instated post-re-exec.

The new approach is to:

1) Serialise the start/stop on conditions as full EventOperator trees.
2) Serialise all objects, regardless of whether they are currently being referenced by running jobs.

New objects being serialised are:

- ConfSource
- ConfFile
- EventOperator

Since all objects are now being serialised, chroot sessions can now be supported. These changes would also support upstart-in-initramfs (although further work is required for that - see init/state.h).

[lp:~jamesodhunt/upstart/serialise-remaining-objects]

1481. By James Hunt on 2013-05-09

* Merge of lp:upstart.

1482. By James Hunt on 2013-05-10

Revert to not supporting deserialisation of JobClasses with associated
user/chroot sessions to avoid behavioural change for now.

* init/job_class.c:
  - job_class_deserialise(): Revert to failing if associated session is
    non-NULL.
  - job_class_deserialise_all(): Revert to ignoring failure to
    deserialise a JobClass iff it has a non-NULL associated session.
* init/state.c:
  - state_to_string(): Provide some diagnostics if serialisation fails.
  - state_from_string(): Provide some diagnostics if deserialisation fails.
  - state_deserialise_resolve_deps(): Ignore failure to lookup JobClass
    iff it has an associated user/chroot session.
  - state_deserialise_blocking(): Revert to ignoring failure to
    deserialise a Blocked object that is associated with a Job whose
    JobClass has a non-NULL session.
* init/tests/test_state.c: test_blocking(): Revert test to assert that
  blocked job with non-NULL session is ignored.

1483. By James Hunt on 2013-05-13

* init/state.c: stateful_reexec(): Specify all values for array
  initialiser.

[Stéphane Graber (stgraber)]

Something looks wrong with this branch, commit 1481 should probably have been a rebase instead of merging trunk into a branch that you then want to merge into trunk. BZR won't fail to merge this but the history will look a bit weird.

You appear to be using "iff" in quite a few places (including some other occurrences in current lp:upstart) are those actually meant as "if and only if" or are those typos (or a mix of the two)?

Besides those two small details, nothing jumped at me during a quick read through of the diff. However this is a massive change so I won't pretend to have done a careful review of it.
I mostly rechecked the concept based on the very detailed comments you left in the code and checked that the serialization/deserialization bits make sense and match.

[Steve Langasek (vorlon)]

After the merge of lp:~mdeslaur/upstart/apparmor-support, this no longer merges cleanly into trunk; and the conflicts in init/tests/test_state.c are non-trivial. James, can you please resolve these conflicts on your branch and resubmit?

review: Needs Fixing

[Steve Langasek (vorlon)]

On Mon, May 27, 2013 at 06:02:26PM -0000, Stéphane Graber wrote:
> Something looks wrong with this branch, commit 1481 should probably have
> been a rebase instead of merging trunk into a branch that you then want to
> merge into trunk. BZR won't fail to merge this but the history will look
> a bit weird.

No, merging trunk to the branch is the expected action here.

[lp:~jamesodhunt/upstart/serialise-remaining-objects]

1484. By James Hunt on 2013-05-29

* Sync with lp:upstart.
* init/tests/test_state.c: test_upstart_pre_security_upgrade(): Tweaks
  to work with new TestDataFile structure and requirement that no
  conf_sources exist just prior to deserialisation.

[James Hunt (jamesodhunt)]

Re-synced with lp:upstart.

review: Needs Resubmitting

[Steve Langasek (vorlon)]

--- init/event_operator.h 2013-02-27 11:46:04 +0000
+++ init/event_operator.h 2013-05-30 17:07:37 +0000
[...]
+event_operator_deserialise_all (void *parent, json_object *json)
+ __attribute__ ((warn_unused_result));
+
+NIH_END_EXTERN
+
 char *event_operator_collapse (EventOperator *condition)
- __attribute__ ((warn_unused_result));
-
-NIH_END_EXTERN
+ __attribute__ ((warn_unused_result, unused));

This moves the event_operator_collapse() definition outside the extern "C" {} block, which seems like a mistake?

--- init/job_class.c 2013-05-15 13:21:54 +0000
+++ init/job_class.c 2013-05-30 17:07:37 +0000
@@ -1910,17 +2015,17 @@

                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;
+ goto error;

                json_object_array_add (json, json_class);

I think the reasoning in that comment still holds (that it's better to serialize as much of the state as possible). But this is consistent with the behavior in the rest of the code, so I suppose that shouldn't be a blocker.

--- init/state.c 2013-02-28 16:40:36 +0000
+++ init/state.c 2013-05-30 17:07:37 +0000
[...]
+ /* Again, we cannot error here since older JSON state data did
+ * not encode ConfSource or ConfFile objects.
+ */
+ if (conf_source_deserialise_all (json) < 0)
+ nih_warn ("%s", _("No ConfSources present in state data"));

Wouldn't it make sense to have a check on the format version, and make this an error for new formats vs. a warning for the old format?

So given that there are version checks now in the deserializer, and there is another change to the serialization format landing upstream at the same time: how can we backport this change to raring in an SRU? Should we consider the format with apparmor_switch to be version 4, and treat the confsource serialization without apparmor_switch to be version 3, then include tests for each (i.e., change
test_upstart_pre_security_upgrade() to use v3)?

Finally, it appears that there is no test json for the *current* serialization format. This should definitely be included as its own test, and added to the tree now - not be left until the next time someone changes the serialization format (or accidentally changes the deserializer!).

Other than that, this looks very good. If you can fix up the above issues, I'll approve this.

[lp:~jamesodhunt/upstart/serialise-remaining-objects]

1485. By James Hunt on 2013-06-04

* init/event.c: event_deserialise(): Revert to checking JSON for
  blockers to avoid reliance on JSON serialisation data format version.
* init/event_operator.h: Fix misplacement of NIH_END_EXTERN.
* init/state.c: Remove serialisation version code since the autoconf
  approach of detecting the format of the JSON is safer.
* init/state.h: Remove STATE_VERSION.

1486. By James Hunt on 2013-06-05

* init/tests/data/upstart-1.8+apparmor.json: New test data file.
* init/tests/test_state.c:
  - test_upgrade(): Re-initialise lists and hashes as a convenience to
    the tests.
  - test_upstart_with_apparmor_upgrade(): New test to ensure Upstart can
    parse the current 1.8 format JSON with the addition of the AppArmor
    serialisation (but crucially *without* the full serialisation data
    (EventOperator, etc).
  - test_upstart_full_serialise_without_apparmor_upgrade(): New test to
    ensure Upstart can parse the current 1.8 format JSON with the
    addition of the full serialisation data (EventOperator, etc),
    but _without_ the AppArmor serialisation.

[James Hunt (jamesodhunt)]

The plan now is to remove the STATE_VERSION code and revert to the autoconf approach of detecting the format of the serialisation data by inspection (this also allows us to work around the backport issue without having to invent mythical format version numbers or other such games).

What we do need to do is add explicit tests for the serialisation formats shown below to allow full serialisation to be backported into Ubuntu _without_ the AppArmor branch (since the former is a fix whilst the latter is a new feature):

1) Current serialisation format with the addition of apparmor data, but without the full serialisation provided by this branch.
2) Current serialisation format with the addition of apparmor data, but without the full serialisation provided by this branch.

[lp:~jamesodhunt/upstart/serialise-remaining-objects]

1487. By James Hunt on 2013-06-05

* init/tests/data/upstart-1.8+full_serialisation+apparmor.json: New test
  data file.
* init/tests/test_state.c:
  - test_upstart_full_serialise_with_apparmor_upgrade(): New test to ensure
    Upstart can parse the current 1.8 format JSON with the addition of the full
    serialisation data (EventOperator, etc), and the AppArmor serialisation.

1488. By James Hunt on 2013-06-05

* init/state.c: state_from_string(): Check if ConfSources
  exist in the serialisation data to allow distinction between
  ConfSources not present and failing to deserialise them.

1489. By James Hunt on 2013-06-05

* Sync with lp:upstart.

=== modified file 'ChangeLog'
--- ChangeLog	2013-05-31 15:57:47 +0000
+++ ChangeLog	2013-06-05 16:21:24 +0000
@@ -1,3 +1,38 @@
[phone]  James Hunt  <[e-mail]>
+
+	* init/tests/data/upstart-1.8+apparmor.json: New test data file.
+	* init/tests/data/upstart-1.8+full_serialisation-apparmor.json:
+	  New test data file.
+	* init/tests/data/upstart-1.8+full_serialisation+apparmor.json:
+	  New test data file.
+	* init/tests/test_state.c:
+	  - test_upgrade(): Re-initialise lists and hashes as a convenience to
+	    the tests.
+	  - test_upstart_with_apparmor_upgrade(): New test to ensure Upstart can
+	    parse the current 1.8 format JSON with the addition of the AppArmor
+	    serialisation (but crucially *without* the full serialisation data
+	    (EventOperator, etc).
+	  - test_upstart_full_serialise_without_apparmor_upgrade(): New test to
+	    ensure Upstart can parse the current 1.8 format JSON with the
+	    addition of the full serialisation data (EventOperator, etc),
+	    but _without_ the AppArmor serialisation.
+	  - test_upstart_full_serialise_with_apparmor_upgrade(): New test to
+	    ensure Upstart can parse the current 1.8 format JSON with the
+	    addition of the full serialisation data (EventOperator, etc),
+	    and the AppArmor serialisation.
+	* init/state.c: state_from_string(): Check if ConfSources
+	  exist in the serialisation data to allow distinction between
+	  ConfSources not present and failing to deserialise them.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/event.c: event_deserialise(): Revert to checking JSON for
+	  blockers to avoid reliance on JSON serialisation data format version.
+	* init/event_operator.h: Fix misplacement of NIH_END_EXTERN.
+	* init/state.c: Remove serialisation version code since the autoconf
+	  approach of detecting the format of the JSON is safer.
+	* init/state.h: Remove STATE_VERSION.
+
 2013-05-31  James Hunt  <[e-mail]>
 
 	[ Eric S. Raymond <[e-mail]> ]
@@ -63,11 +98,250 @@
 	* init/tests/test_state.c: Test apparmor_switch and
 	  PROCESS_SECURITY.
 
[phone]  James Hunt  <[e-mail]>
+
+	* init/state.c: stateful_reexec(): Specify all values for array
+	  initialiser.
+
[phone]  James Hunt  <[e-mail]>
+
+	Revert to not supporting deserialisation of JobClasses with associated
+	user/chroot sessions to avoid behavioural change for now.
+	
+	* init/job_class.c: 
+	  - job_class_deserialise(): Revert to failing if associated session is
+	    non-NULL.
+	  - job_class_deserialise_all(): Revert to ignoring failure to
+	    deserialise a JobClass iff it has a non-NULL associated session.
+	* init/state.c: 
+	  - state_to_string(): Provide some diagnostics if serialisation fails.
+	  - state_from_string(): Provide some diagnostics if deserialisation fails.
+	  - state_deserialise_resolve_deps(): Ignore failure to lookup JobClass
+	    iff it has an associated user/chroot session.
+	  - state_deserialise_blocking(): Revert to ignoring failure to
+	    deserialise a Blocked object that is associated with a Job whose
+	    JobClass has a non-NULL session.
+	* init/tests/test_state.c: test_blocking(): Revert test to assert that
+	  blocked job with non-NULL session is ignored.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/job.c: job_serialise(): Corrected logic for handling 'stop on'
+	  condition.
+	* init/job_class.c: job_class_deserialise(): Only check type after JSON
+	  queried (thanks Coverity).
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/Makefile.am: Link test_util to test_event_operator.
+	* init/conf.c: conf_source_deserialise_all(): Assert conf_sources is
+	  empty.
+	* init/control.h: control_get_job(): Use job_class_get_registered()
+	  rather than redundant job_class_find().
+	* init/event_operator.c:
+	  - Typos and formatting.
+	  - event_operator_serialise(): Conditionally encode name and env.
+	  - event_operator_deserialise(): Treat env as a string array, not an
+	    environ array to ensure values are not discarded unless they contain '='.
+	* init/job.c:
+	  - job_deserialise(): Check JSON type for 'stop on' prior to attempting value extraction.
+	  - job_find():
+	    - Make job_class const.
+	    - Use job_class_get_registered() rather than job_class_find().
+	* init/job_class.c:
+	  - job_class_get_registered(): Rework.
+	  - job_class_add_safe(): Re-add since required to support old
+	    serialisation formats that do not encode ConfSource and ConfFile
+	    objects.
+	  - job_class_deserialise():
+	    - Take care to only associate ConfFile with JobClass if JSON encodes
+	      ConfFile objects.
+	    - Check JSON type for 'start/stop on' prior to attempting value extraction.
+	  - job_class_find(): Remove (redundant due to job_class_get_registered()).
+	* init/state.c:
+	  - Set serialisation_version to an invalid value to detect if it was
+	    never set (to handle old serialisation formats).
+	  - state_from_string():
+	    - Make failure to read header and ConfSources warnings only, to support old
+	      serialisation formats that do not encode this information.
+	  - state_deserialise_blocked(): Fix bug where event blocker was being
+	    incremented twice. Now, just assert it is set.
+	  - state_deserialise_blocking(): Failure to deserialise a Blocked object 
+	    is no longer ignored since sessions are supported.
+	* init/state.h: STATE_VERSION history and notes.
+	* init/tests/test_conf.c: Replace calls to job_class_find() with
+	  job_class_get_registered().
+	* init/tests/test_event_operator.c:
+	  - test_operator_serialisation(): Check both the original string
+	    serialisation format and the new full EventOperator serialisation.
+	    type.
+	* init/tests/test_job.c:
+	  - test_deserialise_ptrace():
+	    - Comments and more checks.
+	    - Create ConfSource, ConfFile and JobClass manually.
+	    - Call job_class_consider() as we now have a backing ConfFile.
+	    - Wait for childs child.
+	* init/tests/test_state.c:
+	  - Simplify TestDataFile.
+	  - Ensure files passed to conf_file_new() provide expected suffix.
+	  - job_class_diff(): Add event_operator_diff() call.
+	  - conf_source_diff(): New function.
+	  - conf_file_diff(): New function.
+	  - test_blocking():
+	    - Extra checks.
+	    - Expect ConfFiles to be recreated on re-exec.
+	  - test_upgrade(): Check environment is clean before running the next test.
+	  - test_upstart1_8_upgrade(): New Upstart-1.8 serialisation format test.
+	  - conf_source_from_path(): New utility function.
+	* init/tests/test_util.c:
+	  - event_operator_diff(): New function.
+	  - session_from_chroot(): New function.
+	* init/tests/data/upstart-1.8.json: New test file.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/conf.c:
+	  - conf_source_serialise_all(): Make failures fatal.
+	* init/event_operator.c: event_operator_collapse(): Unhide but mark as
+	  unused (it's still used by the tests).
+	* init/job.c:
+	  - job_serialise(): Remove unused variable.
+	  - job_deserialise(): Check the type of the start/stop on condition in
+	    the json, not the json passed to the function.
+	* init/job_class.c: job_class_deserialise(): Check the type of the
+	  start/stop on condition in the json, not the json passed to the
+	  function.
+	* init/state.c:
+	  - Comments.
+	  - state_read_header(): Extract header from JSON before checking for
+	    serialisation version.
+
 2013-05-07  James Hunt  <[e-mail]>
 
 	* util/man/shutdown.8: Specify default action is to bring system
 	  down to single-user mode (LP: #1065851).
 
[phone]  James Hunt  <[e-mail]>
+
+	* init/event.c: event_deserialise(): Only set blockers if EventOperators
+	  are serialised.
+	* init/event_operator.c: event_operator_collapse(): Now only needed for
+	  DEBUG.
+	* init/job.c:
+	  - job_deserialise(): Support old string format for 'stop_on'
+	    EventOperator as well as new array format.
+	* init/job_class.c:
+	* init/state.c: Create a meta-header containing a serialisation version
+	  number.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/conf.c:
+	  - New serialisation and support functions:
+	    - conf_source_serialise()
+	    - conf_source_serialise_all()
+	    - conf_source_deserialise()
+	    - conf_source_deserialise_all()
+	    - conf_source_type_enum_to_str()
+	    - conf_source_type_str_to_enum()
+	    - conf_file_serialise()
+	    - conf_file_deserialise()
+	    - conf_file_deserialise_all()
+	    - conf_source_get_index()
+	    - conf_file_find()
+	    - debug_show_event_operator()
+	    - debug_show_event_operators()
+	* init/event_operator.c:
+	  - event_deserialise():
+	    - Fix leaked env array.
+	    - Deserialise blockers count now EventOperators are also serialised.
+	  - event_operator_type_enum_to_str()
+	  - event_operator_type_str_to_enum()
+	  - event_operator_serialise()
+	  - event_operator_serialise_all()
+	  - event_operator_deserialise()
+	  - event_operator_deserialise_all()
+	* init/job_class.c:
+	  - job_class_add_safe(): Remove as no longer required.
+	  - job_class_get(): Must call job_class_init().
+	  - job_class_serialise():
+	    - Remove error case if chroot session specified now that ConfSources
+	      are serialised.
+	    - Serialise start/stop on fully (as EventOperators) rather than just the original
+	      string condition (LP: #1103881).
+	  - job_class_deserialise():
+	    - Remove error case if chroot session specified now that ConfSources
+	      are serialised.
+	    - Associate the JobClass with its ConfFile.
+	  - job_class_serialise_all():
+	    - Comments.
+	    - Failure to serialise a JobClass is now a hard error since we now
+	      serialise all JobClasses.
+	  - job_class_deserialise():
+	    - Deserialise start/stop on conditions as EventOperators rather than as a
+	      string condition.
+	    - Since ConfFiles are now serialised, call job_class_consider()
+	      rather than job_class_add_safe().
+	  - job_class_deserialise_all():
+	    - Failure to deserialise a JobClass is now a hard error since we now
+	      serialise all JobClasses.
+	  - job_class_get_index(): New function.
+	* init/state.c:
+	  - state_to_string(): Serialise ConfSources and ConfFiles.
+	  - state_from_string(): Deserialise ConfSources and ConfFiles.
+	  - state_deserialise_resolve_deps(): Allow chroot sessions to be
+	    handled now we serialise ConfSources and ConfFiles.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/job.c: job_serialise_all(): Really serialise all JobClasses,
+	* init/main.c: Add 'write-state-file' command-line option.
+	  regardless of whether they have associated Jobs.
+	* init/paths.h: Added STATE_FILE_ENV.
+	* init/state.c:
+	  - state_read_objects(): Write state file if 'write-state-file'
+	    specified or STATE_FILE_ENV set.
+	  - event_deserialise():
+	    - Preserve the pre-reexec blockers count until JobClasses
+	      are deserialised and reverse-dependencies resolved.
+	    - Fix incorrect calls for failed and blockers Event attributes.
+	* init/state.h: Comments.
+	* init/tests/test_state.c:
+	  - test_job_class_serialise(): Ensure that all JobClasses get
+	    serialised, regardless of whether they have any associated
+	    Jobs.
+	  - test_event_serialise(): New "with failed" test.
+	* init/event.c: event_deserialise(): Don't deserialise Event->blockers -
+	  there is no point until we serialise EventOperators.
+
[phone]  James Hunt  <[e-mail]>
+
+	* init/conf.c:
+	  - conf_reload(): Explanation of how reload works.
+	  - conf_reload_path(): Defer destruction of original ConfFile until
+	    newly-loaded .conf file has a chance to reference any events its
+	    'start on' condition requires (LP: 1124384).
+	  - debug_show_jobs(): Return if no instances.
+	  - debug_show_events(): New function.
+	* init/event.c: Comments.
+	* init/job.c: Comment.
+	* init/job_class.c:
+	  - job_class_get_registered(): New function resulting from refactor of
+	    job_class_consider() and job_class_reconsider().
+	  - job_class_consider():
+	    - Use job_class_get_registered().
+	    - Call job_class_event_block() to avoid premature event destruction.
+	  - job_class_reconsider(): Use job_class_get_registered().
+	  - job_class_event_block(): New function to increase reference count
+	    for events new JobClass specifies in its 'start on' condition that
+	    old JobClass has also referenced (second part of LP: #1124384).
+	* init/tests/test_conf.c:
+	  - test_source_reload(): New tests:
+	    - "ensure reload does not destroy a blocked event used by another job"
+	    - "ensure .conf reload causes waiting job to run when 'start on' matches"
+	* init/tests/test_conf.h: TEST_ENSURE_CLEAN_ENV(): Check
+	  nih_child_watches too.
+
 2013-04-22  James Hunt  <[e-mail]>
 
 	* Typo and doc changes.

=== modified file 'init/Makefile.am'
--- init/Makefile.am	2013-05-15 13:21:54 +0000
+++ init/Makefile.am	2013-06-05 16:21:24 +0000
@@ -280,7 +280,7 @@
 	$(JSON_LIBS) \
 	-lrt
 
-test_event_operator_SOURCES = tests/test_event_operator.c
+test_event_operator_SOURCES = tests/test_event_operator.c $(test_util_SOURCES)
 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 \

=== modified file 'init/conf.c'
--- init/conf.c	2013-02-27 11:46:04 +0000
+++ init/conf.c	2013-06-05 16:21:24 +0000
@@ -2,7 +2,7 @@
  *
  * conf.c - configuration management
  *
- * Copyright © 2009,2010,2011,2012,2013 Canonical Ltd.
+ * Copyright  2009,2010,2011,2012,2013 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -49,6 +49,7 @@
 #include "conf.h"
 #include "errors.h"
 #include "paths.h"
+#include "environ.h"
 
 /* Prototypes for static functions */
 static int  conf_source_reload_file    (ConfSource *source)
@@ -103,6 +104,7 @@
  **/
 NihList *conf_sources = NULL;
 
+extern json_object *json_conf_sources;
 
 /**
  * is_conf_file_std:
@@ -447,12 +449,24 @@
 /**
  * conf_reload:
  *
- * Reloads all configuration sources.
+ * Reloads configuration sources.
  *
  * Watches on new configuration sources are established so that future
  * changes will be automatically detected with inotify.  Then for both
  * new and existing sources, the current state is parsed.
  *
+ * All ConfFiles are recreated as part of the reload. If the JobClass
+ * associated with a ConfSource has no Job instances, the JobClass is
+ * recreated and added to the job_classes hash.
+ *
+ * However, if a JobClass has running instances at reload time, although
+ * a new ConfSource *and* a new JobClass are created, the new JobClass
+ * (called the "best") will *NOT* be added to the job_classes hash until
+ * the last running instance has finished. At this point, the "registered"
+ * JobClass will be removed from the hash (when job_class_reconsider()
+ * is called by job_change_state()) and replaced by the "best" (newest)
+ * JobClass.
+ *
  * Any errors are logged through the usual mechanism, and not returned,
  * since some configuration may have been parsed; and it's possible to
  * parse no configuration without error.
@@ -1039,6 +1053,7 @@
 		  const char *override_path)
 {
 	ConfFile       *file = NULL;
+	ConfFile       *orig = NULL;
 	nih_local char *buf = NULL;
 	nih_local char *name = NULL;
 	size_t          len, pos, lineno;
@@ -1051,25 +1066,67 @@
 	path_to_load = (override_path ? override_path : path);
 
 	/* If there is no corresponding override file, look up the old
-	 * conf file in memory, and then free it.  In cases of failure,
+	 * conf file in memory, and then free it. In cases of failure,
 	 * we discard it anyway, so there's no particular reason
 	 * to keep it around anymore.
 	 *
-	 * Note: if @override_path has been specified, do not
-	 * free the file if found, since we want to _update_ the
-	 * existing entry.
+	 * Notes:
+	 *
+	 * - If @override_path has been specified, do not free the file
+	 *   if found, since we want to _update_ the existing entry.
+	 * - Freeing a ConfFile does _not_ necessarily free its associated
+	 *   JobClass.
 	 */
-	file = (ConfFile *)nih_hash_lookup (source->files, path);
-	if (! override_path && file)
-		nih_unref (file, source);
+	orig = (ConfFile *)nih_hash_lookup (source->files, path);
+	if (! override_path && orig) {
+		/* Found an existing ConfFile. We will free this, but
+		 * just not yet since iff that ConfFiles associated JobClass
+		 * does not have any running instances, freeing the
+		 * ConfFile will cause the original JobClass associated
+		 * with this ConfFile to be destroyed. But if the JobClass
+		 * had referenced any events via it's 'start on' EventOperator tree, 
+		 * the JobClasses destruction could lead to the Events
+		 * being destroyed _before_ the about-to-be-created
+		 * replacement JobClass gets a chance to reference those
+		 * same events (assuming its 'start on' EventOperator tree
+		 * contains nodes specifying the same event names as
+		 * those in the original JobClasses).
+		 *
+		 * As such, we simply remove the ConfFile from its
+		 * parent ConfSources hash, create the new ConfFile and
+		 * JobClass, give the new JobClass a chance to be the
+		 * registered JobClass, and finally allow the original
+		 * ConfFile to be destroyed.
+		 *
+		 * If this is not done, reloading a configuration
+		 * mid-way through the boot sequence could lead to a
+		 * hung system as the new JobClasses will wait forever
+		 * for events to be emitted that have already been
+		 * destroyed.
+		 */
+		nih_list_remove (&orig->entry);
+	}
 
 	/* Read the file into memory for parsing, if this fails we don't
 	 * bother creating a new ConfFile structure for it and bail out
 	 * now.
 	 */
 	buf = nih_file_read (NULL, path_to_load, &len);
-	if (! buf)
+	if (! buf) {
+		if (! override_path && orig) {
+			/* Failed to reload the file from disk in all
+			 * likelihood because the configuration file was
+			 * deleted.
+			 *
+			 * Allow the ConfFile to be cleaned up taking
+			 * its JobClass (and possibly events that
+			 * JobClass was referencing) with it.
+			 */
+			nih_unref (orig, source);
+		}
+
 		return -1;
+	}
 
 	/* Create a new ConfFile structure (if no @override_path specified) */
 	file = (ConfFile *)nih_hash_lookup (source->files, path);
@@ -1112,6 +1169,10 @@
 		file->job = parse_job (NULL, source->session, file->job,
 				name, buf, len, &pos, &lineno);
 
+		/* Allow the original ConfFile which has now been replaced to be
+		 * destroyed which will also cause the original JobClass to be
+		 * freed.
+		 */
 		if (file->job) {
 			job_class_consider (file->job);
 		} else {
@@ -1123,6 +1184,12 @@
 		nih_assert_not_reached ();
 	}
 
+	/* Finally, allow the original ConfFile to be destroyed without
+	 * affecting the new JobClass.
+	 */
+	if (! override_path && orig)
+		nih_unref (orig, source);
+
 	/* Deal with any parsing errors that occurred; we don't consider
 	 * these to be hard failures, which means we can warn about them
 	 * here and give the path and line number along with the warning.
@@ -1253,8 +1320,568 @@
 	return NULL;
 }
 
+/**
+ * conf_source_serialise:
+ * @source: ConfSource to serialise.
+ *
+ * Convert @source into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised ConfSource object, or NULL on error.
+ **/
+json_object *
+conf_source_serialise (const ConfSource *source)
+{
+	json_object      *json;
+	json_object      *json_files;
+	int               session_index;
+
+	nih_assert (source);
+	nih_assert (conf_sources);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	json_files = json_object_new_array ();
+	if (! json_files)
+		goto error;
+
+	session_index = session_get_index (source->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, source, path))
+		goto error;
+
+	if (! state_set_json_enum_var (json,
+				conf_source_type_enum_to_str,
+				"type", source->type))
+		goto error;
+
+	/* 'watch' does not need to be serialised - it gets recreated
+	 * when conf_source_new() is called on deserialisation.
+	 */
+
+	if (! state_set_json_int_var_from_obj (json, source, flag))
+		goto error;
+
+	/* Add array of ConfFile names to represent the files hash */
+	NIH_HASH_FOREACH (source->files, file_iter) {
+		ConfFile *file = (ConfFile *)file_iter;
+		json_object *json_conf_file;
+
+		json_conf_file = conf_file_serialise (file);
+		if (! json_conf_file)
+			goto error;
+
+		json_object_array_add (json_files, json_conf_file);
+	}
+
+	json_object_object_add (json, "conf_files", json_files);
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * conf_source_serialise_all:
+ *
+ * Convert existing ConfSource objects to JSON representation.
+ *
+ * Returns: JSON object containing array of ConfSource objects,
+ * or NULL on error.
+ **/
+json_object *
+conf_source_serialise_all (void)
+{
+	json_object *json;
+
+	conf_init ();
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_LIST_FOREACH (conf_sources, iter) {
+		json_object  *json_source;
+		ConfSource   *source = (ConfSource *)iter;
+
+		json_source = conf_source_serialise (source);
+
+		if (! json_source)
+			goto error;
+
+		json_object_array_add (json, json_source);
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * conf_source_deserialise:
+ * @parent: parent,
+ * @json: JSON-serialised ConfSource object to deserialise.
+ *
+ * Create ConfSource from provided JSON and add to the
+ * conf sources list.
+ *
+ * Returns: ConfSource object, or NULL on error.
+ **/
+ConfSource *
+conf_source_deserialise (void *parent, json_object *json)
+{
+	ConfSource      *source = NULL;
+	ConfSourceType   type = -1;
+	Session         *session;
+	int              session_index = -1;
+	nih_local char  *path = NULL;
+
+	nih_assert (json);
+
+	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;
+
+	session = session_from_index (session_index);
+
+	if (! state_get_json_string_var_strict (json, "path", NULL, path))
+		goto error;
+
+	if (! state_get_json_enum_var (json,
+				conf_source_type_str_to_enum,
+				"type", type))
+		goto error;
+
+	source = conf_source_new (parent, path, type);
+	if (! source)
+		goto error;
+
+	source->session = session;
+
+	if (! state_get_json_int_var_to_obj (json, source, flag))
+		goto error;
+
+	if (conf_file_deserialise_all (source, json) < 0)
+		goto error;
+
+	return source;
+
+error:
+	if (source)
+		nih_free (source);
+
+	return NULL;
+}
+
+/**
+ * conf_source_deserialise_all:
+ *
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of ConfSources back into ConfSource objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+conf_source_deserialise_all (json_object *json)
+{
+	ConfSource *source = NULL;
+
+	nih_assert (json);
+
+	conf_init ();
+
+	nih_assert (NIH_LIST_EMPTY (conf_sources));
+
+	json_conf_sources = json_object_object_get (json, "conf_sources");
+
+	if (! json_conf_sources)
+			goto error;
+
+	if (! state_check_json_type (json_conf_sources, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_conf_sources); i++) {
+		json_object  *json_source;
+
+		json_source = json_object_array_get_idx (json_conf_sources, i);
+		if (! json_source)
+			goto error;
+
+		if (! state_check_json_type (json_source, object))
+			goto error;
+
+		source = conf_source_deserialise (NULL, json_source);
+
+		if (! source)
+			continue;
+	}
+
+	return 0;
+
+error:
+	if (source)
+		nih_free (source);
+
+	return -1;
+}
+
+/**
+ * conf_source_type_enum_to_str:
+ *
+ * @type: ConfSourceType.
+ *
+ * Convert ConfSourceType to a string representation.
+ *
+ * Returns: string representation of @type, or NULL if not known.
+ **/
+const char *
+conf_source_type_enum_to_str (ConfSourceType type)
+{
+	state_enum_to_str (CONF_FILE, type);
+	state_enum_to_str (CONF_DIR, type);
+	state_enum_to_str (CONF_JOB_DIR, type);
+
+	return NULL;
+}
+
+/**
+ * conf_source_type_str_to_enum:
+ *
+ * @type: string ConfSourceType value.
+ *
+ * Convert @expect back into an enum value.
+ *
+ * Returns: ConfSourceType representing @type, or -1 if not known.
+ **/
+ConfSourceType
+conf_source_type_str_to_enum (const char *type)
+{
+	nih_assert (type);
+
+	state_str_to_enum (CONF_FILE, type);
+	state_str_to_enum (CONF_DIR, type);
+	state_str_to_enum (CONF_JOB_DIR, type);
+
+	return -1;
+}
+
+/**
+ * conf_file_serialise:
+ * @file: ConfFile to serialise.
+ *
+ * Convert @file into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised ConfFile object, or NULL on error.
+ **/
+json_object *
+conf_file_serialise (const ConfFile *file)
+{
+	json_object  *json;
+	json_object  *json_job_class;
+	JobClass     *registered;
+	int           session_index;
+	ssize_t       conf_source_index;
+
+	nih_assert (file);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! state_set_json_string_var_from_obj (json, file, path))
+		goto error;
+
+	conf_source_index = conf_source_get_index (file->source);
+	if (conf_source_index < 0)
+		goto error;
+
+	if (! state_set_json_int_var (json, "conf_source", conf_source_index))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, file, flag))
+		goto error;
+
+	/*
+	 * Ignore the "best" JobClass associated with this ConfFile
+	 * (file->job) since it won't be serialised.
+	 *
+	 * Instead look up the currently registered JobClass and
+	 * reference that. This ensures that best == registered for the
+	 * re-exec. This may change though immediately after re-exec
+	 * when conf_reload() gets called.
+	 *
+	 * See job_class_serialise_all() for further details.
+	 */
+	registered = job_class_get_registered (file->job->name,
+			file->job->session);
+
+	if (! registered)
+		goto error;
+
+	/* Create a reference to the registered job class in the JSON by
+	 * encoding the name and session index. We do this rather than
+	 * simply encoding an index number for the JobClass since
+	 * job_classes is a hash and it is safer should a re-exec
+	 * result from an upgrade to NIH, say, where its hashing
+	 * algorithm changed meaning the index may be unreliable once
+	 * the job_classes hash was created post-re-exec.
+	 */
+	json_job_class = json_object_new_object ();
+	if (! json_job_class)
+		goto error;
+
+	if (! state_set_json_string_var (json_job_class,
+				"name",
+				registered->name))
+		goto error;
+
+	session_index = session_get_index (registered->session);
+	if (session_index < 0)
+		goto error;
+
+	if (! state_set_json_int_var (json_job_class,
+				"session",
+				session_index))
+		goto error;
+
+	json_object_object_add (json, "job_class", json_job_class);
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * conf_file_deserialise:
+ * @source: ConfSource,
+ * @json: JSON-serialised ConfFile object to deserialise.
+ *
+ * Create ConfFile from provided JSON and add to the
+ * conf sources list.
+ *
+ * Returns: ConfFile object, or NULL on error.
+ **/
+ConfFile *
+conf_file_deserialise (ConfSource *source, json_object *json)
+{
+	ConfFile        *file = NULL;
+	nih_local char  *path = NULL;
+
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		goto error;
+
+	if (! state_get_json_string_var_strict (json, "path", NULL, path))
+		goto error;
+
+	file = conf_file_new (source, path);
+	if (! file)
+		goto error;
+
+	/* Note that the associated JobClass is not handled at this
+	 * stage: it can't be the JobClasses haven't been deserialised
+	 * yet. As such, the ConfFile->JobClass link is dealt with by
+	 * job_class_deserialise_all().
+	 */
+	file->job = NULL;
+
+	if (! state_get_json_int_var_to_obj (json, file, flag))
+		goto error;
+
+	return file;
+
+error:
+	if (file)
+		nih_free (file);
+
+	return NULL;
+}
+
+/**
+ * conf_file_deserialise_all:
+ *
+ * @source: ConfSource,
+ * @json: root of JSON-serialised state.
+ *
+ * Convert JSON representation of ConfFiles back into ConfFile objects.
+ *
+ * Returns: 0 on success, -1 on error.
+ **/
+int
+conf_file_deserialise_all (ConfSource *source, json_object *json)
+{
+	json_object  *json_conf_files;
+	ConfFile     *file = NULL;
+
+	nih_assert (source);
+	nih_assert (json);
+
+	conf_init ();
+
+	json_conf_files = json_object_object_get (json, "conf_files");
+
+	if (! json_conf_files)
+			goto error;
+
+	if (! state_check_json_type (json_conf_files, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json_conf_files); i++) {
+		json_object  *json_file;
+
+		json_file = json_object_array_get_idx (json_conf_files, i);
+		if (! json_file)
+			goto error;
+
+		if (! state_check_json_type (json_file, object))
+			goto error;
+
+		file = conf_file_deserialise (source, json_file);
+
+		if (! file)
+			goto error;
+	}
+
+	return 0;
+
+error:
+	if (file)
+		nih_free (file);
+
+	return -1;
+}
+
+/**
+ * conf_source_get_index:
+ *
+ * @source: ConfSource to search for.
+ *
+ * Returns: index of @source in the conf sources list,
+ * or -1 if not found.
+ **/
+ssize_t
+conf_source_get_index (const ConfSource *source)
+{
+	ssize_t i = 0;
+
+	nih_assert (source);
+
+	conf_init ();
+
+	NIH_LIST_FOREACH (conf_sources, iter) {
+		ConfSource *s = (ConfSource *)iter;
+
+		if (! strcmp (source->path, s->path)
+				&& source->session == s->session)
+			return i;
+		i++;
+	}
+
+	return -1;
+}
+
+/**
+ * conf_file_find:
+ *
+ * @name: name of ConfFile (without dirname and extension),
+ * @session: session ConfFile belongs to.
+ *
+ * Find the ConfFile with name @name in session @session.
+ *
+ * Returns: ConfFile or NULL if not found.
+ **/
+ConfFile *
+conf_file_find (const char *name, const Session *session)
+{
+	nih_local char  *basename = NULL;
+
+	nih_assert (name);
+
+	conf_init ();
+
+	/* There can only be one ConfFile per session with the same
+	 * basename.
+	 */
+	basename = NIH_MUST (nih_sprintf (NULL, "/%s%s",
+				name, CONF_EXT_STD));
+
+	NIH_LIST_FOREACH (conf_sources, iter) {
+		ConfSource *source = (ConfSource *)iter;
+
+		if (source->session != session)
+			continue;
+
+		NIH_HASH_FOREACH (source->files, file_iter) {
+			ConfFile *file = (ConfFile *)file_iter;
+			char     *match;
+			char     *slash;
+
+			match = strstr (file->path, basename);
+			slash = strrchr (file->path, '/');
+
+			if (match && match == slash)
+				return file;
+		}
+	}
+
+	return NULL;
+}
+
 #ifdef DEBUG
 
+void
+debug_show_event_operator (EventOperator *oper)
+{
+	nih_local char *env = NULL;
+
+	nih_assert (oper);
+
+	if (oper->env) env = state_collapse_env ((const char **)oper->env);
+
+	nih_debug ("EventOperator %p: type='%s', value=%d, name='%s', event='%s', env='%s'",
+			oper,
+			oper->type == EVENT_MATCH ? "EVENT_MATCH"
+			: oper->type == EVENT_AND ? "EVENT_AND"
+			: "EVENT_OR",
+			oper->value,
+			oper->name,
+			oper->event ? oper->event->name : "",
+			env ? env : "");
+}
+
+void
+debug_show_event_operators (EventOperator *root)
+{
+	nih_assert (root);
+
+	NIH_TREE_FOREACH_POST (&root->node, iter) {
+		EventOperator *oper = (EventOperator *)iter;
+
+		debug_show_event_operator (oper);
+	}
+}
+
 size_t
 debug_count_list_entries (const NihList *list)
 {
@@ -1383,7 +2010,8 @@
 void
 debug_show_jobs (const NihHash *instances)
 {
-	nih_assert (instances);
+	if (! instances)
+		return;
 
 	nih_debug ("jobs:");
 
@@ -1405,6 +2033,18 @@
 }
 
 void
+debug_show_events (void)
+{
+	nih_assert (events);
+
+	NIH_LIST_FOREACH (events, iter) {
+		Event *event = (Event *)iter;
+
+		debug_show_event (event);
+	}
+}
+
+void
 debug_show_conf_file (const ConfFile *file)
 {
 	nih_assert (file);

=== modified file 'init/conf.h'
--- init/conf.h	2013-02-27 11:46:04 +0000
+++ init/conf.h	2013-06-05 16:21:24 +0000
@@ -1,6 +1,6 @@
 /* upstart
  *
- * Copyright © 2010,2011 Canonical Ltd.
+ * Copyright  2010,2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -128,6 +128,50 @@
 
 JobClass *  conf_select_job    (const char *name, const Session *session);
 
+const char *
+conf_source_type_enum_to_str (ConfSourceType type)
+	__attribute__ ((warn_unused_result));
+
+ConfSourceType
+conf_source_type_str_to_enum (const char *type)
+	__attribute__ ((warn_unused_result));
+
+json_object *
+conf_source_serialise (const ConfSource *source)
+	__attribute__ ((warn_unused_result));
+
+json_object *
+conf_source_serialise_all (void)
+	__attribute__ ((warn_unused_result));
+
+ConfSource *
+conf_source_deserialise (void *parent, json_object *json)
+	__attribute__ ((warn_unused_result));
+
+int
+conf_source_deserialise_all (json_object *json)
+	__attribute__ ((warn_unused_result));
+
+json_object *
+conf_file_serialise (const ConfFile *file)
+	__attribute__ ((warn_unused_result));
+
+ConfFile *
+conf_file_deserialise (ConfSource *source, json_object *json)
+	__attribute__ ((warn_unused_result));
+
+int
+conf_file_deserialise_all (ConfSource *source, json_object *json)
+	__attribute__ ((warn_unused_result));
+
+ssize_t
+conf_source_get_index (const ConfSource *source)
+	__attribute__ ((warn_unused_result));
+
+ConfFile *
+conf_file_find (const char *name, const Session *session)
+	__attribute__ ((warn_unused_result));
+
 #ifdef DEBUG
 
 /* used for debugging only */
@@ -160,6 +204,10 @@
 	__attribute__ ((unused));
 
 void
+debug_show_events (void)
+	__attribute__ ((unused));
+
+void
 debug_show_conf_file(const ConfFile *file)
 	__attribute__ ((unused));
 
@@ -171,6 +219,14 @@
 debug_show_conf_sources(void)
 	__attribute__ ((unused));
 
+void
+debug_show_event_operator (EventOperator *oper)
+	__attribute__ ((unused));
+
+void
+debug_show_event_operators (EventOperator *root)
+	__attribute__ ((unused));
+
 #endif
 
 NIH_END_EXTERN

=== modified file 'init/control.h'
--- init/control.h	2013-02-08 16:15:23 +0000
+++ init/control.h	2013-06-05 16:21:24 +0000
@@ -58,31 +58,31 @@
  *
  * Returns: -1 on raised error, or nothing on success.
  **/
-#define control_get_job(session, job, job_name, instance)            \
-{                                                                    \
-	if (job_name != NULL ) {                                     \
-		JobClass *class;                                     \
-                                                                     \
-		class = job_class_find (session, job_name);          \
-		if (! class) {                                       \
-			nih_dbus_error_raise_printf (                \
-				DBUS_INTERFACE_UPSTART               \
-				".Error.UnknownJob",                 \
-				_("Unknown job: %s"),                \
-				job_name);                           \
-			return -1;                                   \
-		}                                                    \
-                                                                     \
-		job = job_find (session, class, NULL, instance);     \
-		if (job == NULL) {                                   \
-			nih_dbus_error_raise_printf (                \
-				DBUS_INTERFACE_UPSTART               \
-				".Error.UnknownJobInstance",         \
-				_("Unknown instance: %s of job %s"), \
-				instance, job_name);                 \
-			return -1;                                   \
-		}                                                    \
-	}                                                            \
+#define control_get_job(session, job, job_name, instance)             \
+{                                                                     \
+	if (job_name != NULL ) {                                      \
+		JobClass *class;                                      \
+                                                                      \
+		class = job_class_get_registered (job_name, session); \
+		if (! class) {                                        \
+			nih_dbus_error_raise_printf (                 \
+				DBUS_INTERFACE_UPSTART                \
+				".Error.UnknownJob",                  \
+				_("Unknown job: %s"),                 \
+				job_name);                            \
+			return -1;                                    \
+		}                                                     \
+								      \
+		job = job_find (session, class, NULL, instance);      \
+		if (job == NULL) {                                    \
+			nih_dbus_error_raise_printf (                 \
+				DBUS_INTERFACE_UPSTART                \
+				".Error.UnknownJobInstance",          \
+				_("Unknown instance: %s of job %s"),  \
+				instance, job_name);                  \
+			return -1;                                    \
+		}                                                     \
+	}                                                             \
 }
 
 NIH_BEGIN_EXTERN

=== modified file 'init/event.c'
--- init/event.c	2012-12-14 23:47:51 +0000
+++ init/event.c	2013-06-05 16:21:24 +0000
@@ -315,8 +315,8 @@
 
 		/* We stop first so that if an event is listed both as a
 		 * stop and start event, it causes an active running process
-		 * to be killed, the stop script then the start script to be
-		 * run.  In any other state, it has no special effect.
+		 * to be killed, and then stop script then the start script
+		 * to be run. In any other state, it has no special effect.
 		 *
 		 * (The other way around would be just strange, it'd cause
 		 * a process's start and stop scripts to be run without the
@@ -638,7 +638,7 @@
 	json_object        *json_env;
 	Event              *event = NULL;
 	nih_local char     *name = NULL;
-        char              **env = NULL;
+        nih_local char    **env = NULL;
 	int                 session_index = -1;
 
 	nih_assert (json);
@@ -675,9 +675,19 @@
 				"progress", event->progress))
 		goto error;
 
-	if (! state_set_json_int_var_from_obj (json, event, failed))
+	if (! state_get_json_int_var_to_obj (json, event, failed))
 		goto error;
 
+	/* We can only set the blockers count in the scenario that
+	 * EventOperators are serialised (since without this, it is not
+	 * possible to manually reconstruct the state of the
+	 * EventOperators post-re-exec.
+	 */
+	if (json_object_object_get (json, "blockers")) {
+		if (! state_get_json_int_var_to_obj (json, event, blockers))
+			goto error;
+	}
+
 	return event;
 
 error:

=== modified file 'init/event_operator.c'
--- init/event_operator.c	2013-02-15 14:07:05 +0000
+++ init/event_operator.c	2013-06-05 16:21:24 +0000
@@ -59,7 +59,7 @@
  * array of environment variables in KEY=VALUE form.  @env will be referenced
  * by the new event.  After calling this function, you should never use
  * nih_free() to free @env and instead use nih_unref() or nih_discard() if
- * you longer need to use it.
+ * you no longer need to use it.
  *
  * If @parent is not NULL, it should be a pointer to another object which
  * will be used as a parent for the returned operator.  When all parents
@@ -782,8 +782,7 @@
 							env ? env : ""));
 				nih_list_add_after (stack, &expr->entry);
 				break;
-			}
-			else {
+			} else {
 				/* We build the expression from visiting the logical
 				 * operators (and their children) only.
 				 */
@@ -864,3 +863,312 @@
 
 	return NIH_MUST (nih_strdup (NULL, latest->str));
 }
+
+/**
+ * event_operator_type_enum_to_str:
+ *
+ * @type: EventOperatorType.
+ *
+ * Convert EventOperatorType to a string representation.
+ *
+ * Returns: string representation of @type, or NULL if not known.
+ **/
+const char *
+event_operator_type_enum_to_str (EventOperatorType type)
+{
+	state_enum_to_str (EVENT_OR, type);
+	state_enum_to_str (EVENT_AND, type);
+	state_enum_to_str (EVENT_MATCH, type);
+
+	return NULL;
+}
+
+/**
+ * event_operator_type_str_to_enum:
+ *
+ * @type: string EventOperatorType value.
+ *
+ * Convert @expect back into an enum value.
+ *
+ * Returns: EventOperatorType representing @type, or -1 if not known.
+ **/
+EventOperatorType
+event_operator_type_str_to_enum (const char *type)
+{
+	nih_assert (type);
+
+	state_str_to_enum (EVENT_OR, type);
+	state_str_to_enum (EVENT_AND, type);
+	state_str_to_enum (EVENT_MATCH, type);
+
+	return -1;
+}
+
+/**
+ * event_operator_serialise:
+ * @oper: EventOperator to serialise.
+ *
+ * Convert @oper into a JSON representation for serialisation.
+ * Caller must free returned value using json_object_put().
+ *
+ * Returns: JSON-serialised EventOperator object, or NULL on error.
+ **/
+json_object *
+event_operator_serialise (const EventOperator *oper)
+{
+	json_object  *json;
+	int           event_index;
+
+	nih_assert (oper);
+
+	json = json_object_new_object ();
+	if (! json)
+		return NULL;
+
+	if (! state_set_json_enum_var (json,
+				event_operator_type_enum_to_str,
+				"type", oper->type))
+		goto error;
+
+	if (! state_set_json_int_var_from_obj (json, oper, value))
+		goto error;
+
+	if (oper->name) {
+		if (! state_set_json_string_var_from_obj (json, oper, name))
+			goto error;
+	}
+
+	if (oper->env) {
+		if (! state_set_json_str_array_from_obj (json, oper, env))
+			goto error;
+	}
+
+	if (oper->event) {
+		event_index = event_to_index (oper->event);
+		if (event_index < 0)
+			goto error;
+
+		if (! state_set_json_int_var (json, "event", event_index))
+			goto error;
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+
+}
+
+/**
+ * event_operator_serialise_all:
+ *
+ * @root: operator tree to serialise,
+ *
+ * Convert EventOperator tree to JSON representation.
+ *
+ * Returns: JSON object containing array of EventOperator nodes in post-order,
+ * or NULL on error.
+ */
+json_object *
+event_operator_serialise_all (EventOperator *root)
+{
+	json_object *json;
+	json_object *json_node;
+
+	nih_assert (root);
+
+	json = json_object_new_array ();
+	if (! json)
+		return NULL;
+
+	NIH_TREE_FOREACH_POST (&root->node, iter) {
+		EventOperator *oper = (EventOperator *)iter;
+
+		json_node = event_operator_serialise (oper);
+		if (! json_node)
+			goto error;
+
+		if (json_object_array_add (json, json_node) < 0)
+			goto error;
+	}
+
+	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
+}
+
+/**
+ * event_operator_deserialise:
+ * @parent: parent,
+ * @json: JSON-serialised EventOperator object to deserialise.
+ *
+ * Create EventOperator from provided JSON.
+ *
+ * Returns: EventOperator object, or NULL on error.
+ **/
+EventOperator *
+event_operator_deserialise (void *parent, json_object *json)
+{
+	EventOperator      *oper = NULL;
+	EventOperatorType   type = -1;
+	nih_local char     *name = NULL;
+	nih_local char    **env = NULL;
+
+	nih_assert (json);
+
+	if (! state_check_json_type (json, object))
+		goto error;
+
+	if (json_object_object_get (json, "name")) {
+		if (! state_get_json_string_var_strict (json, "name", NULL, name))
+			goto error;
+	}
+
+	if (! state_get_json_enum_var (json,
+				event_operator_type_str_to_enum,
+				"type", type))
+		goto error;
+
+	if (json_object_object_get (json, "env")) {
+		json_object  *json_env;
+		if (! state_get_json_var_full (json, "env", array, json_env))
+			goto error;
+
+		/* XXX: note that we have to treat the environment array
+		 * as a plain string array (rather than an environ
+		 * array) at this point since the values are not
+		 * expanded (do not necessarily contain '='), and hence
+		 * would be discarded by the environ-handling routines.
+		 */
+		if (! state_deserialise_str_array (NULL, json_env, &env))
+			goto error;
+	}
+
+	oper = event_operator_new (parent, type, name, env);
+	if (! oper)
+		goto error;
+
+	if (! state_get_json_int_var_to_obj (json, oper, value))
+		goto error;
+
+	if (json_object_object_get (json, "event")) {
+		int event_index;
+
+		if (! state_get_json_int_var (json, "event", event_index))
+			goto error;
+
+		oper->event = event_from_index (event_index);
+		if (! oper->event)
+			goto error;
+	}
+
+	return oper;
+
+error:
+	if (oper)
+		nih_free (oper);
+
+	return NULL;
+}
+
+/**
+ * event_operator_deserialise_all:
+ *
+ * @parent: parent,
+ * @json: root of JSON-serialised state.
+ *
+ * Convert EventOperator tree to JSON representation.
+ *
+ * Returns: EventOperator tree root node on success, or NULL on error.
+ */
+EventOperator *
+event_operator_deserialise_all (void *parent, json_object *json)
+{
+	EventOperator      *oper = NULL;
+	EventOperator      *left_oper = NULL;
+	EventOperator      *right_oper = NULL;
+	nih_local NihList  *stack = NULL;
+	NihListEntry       *item;
+
+	nih_assert (json);
+
+	stack = NIH_MUST (nih_list_new (NULL));
+
+	if (! state_check_json_type (json, array))
+		goto error;
+
+	for (int i = 0; i < json_object_array_length (json); i++) {
+		json_object        *json_event_operator;
+		nih_local NihList  *left = NULL;
+		nih_local NihList  *right = NULL;
+
+		json_event_operator = json_object_array_get_idx (json, i);
+		if (! json_event_operator)
+			goto error;
+
+		if (! state_check_json_type (json_event_operator, object))
+			goto error;
+
+		oper = event_operator_deserialise (parent, json_event_operator);
+		if (! oper)
+			goto error;
+
+		item = nih_list_entry_new (stack);
+		if (! item)
+			goto error;
+
+		switch (oper->type) {
+		case EVENT_AND:
+		case EVENT_OR:
+			left = NIH_MUST (nih_list_new (NULL));
+			right = NIH_MUST (nih_list_new (NULL));
+
+			/* pop the top two stack elements */
+			nih_assert (! NIH_LIST_EMPTY (stack));
+			right = nih_list_add (right, stack->next);
+
+			nih_assert (! NIH_LIST_EMPTY (stack));
+			left = nih_list_add (left, stack->next);
+
+			left_oper = (EventOperator *)((NihListEntry *)left)->data;
+			right_oper = (EventOperator *)((NihListEntry *)right)->data;
+
+			nih_assert (left_oper);
+			nih_assert (right_oper);
+
+			/* Attach them as children of the new operator */
+			nih_tree_add (&oper->node, &left_oper->node, NIH_TREE_LEFT);
+			nih_tree_add (&oper->node, &right_oper->node, NIH_TREE_RIGHT);
+
+			/* FALL THROUGH:
+			 *
+			 * This will re-add the operator to the stack.
+			 */
+
+		case EVENT_MATCH:
+			item->data = oper;
+			nih_list_add_after (stack, &item->entry);
+			break;
+		default:
+			nih_assert_not_reached ();
+		}
+	}
+
+	nih_assert (! NIH_LIST_EMPTY (stack));
+
+	oper = ((NihListEntry *)stack->next)->data;
+
+	nih_list_remove (stack->next);
+	nih_assert (NIH_LIST_EMPTY (stack));
+
+	return oper;
+
+error:
+	if (oper)
+		nih_free (oper);
+
+	return NULL;
+}

=== modified file 'init/event_operator.h'
--- init/event_operator.h	2013-02-27 11:46:04 +0000
+++ init/event_operator.h	2013-06-05 16:21:24 +0000
@@ -108,8 +108,33 @@
 
 void           event_operator_reset       (EventOperator *root);
 
+const char *
+event_operator_type_enum_to_str (EventOperatorType type)
+	__attribute__ ((warn_unused_result));
+
+EventOperatorType
+event_operator_type_str_to_enum (const char *type)
+	__attribute__ ((warn_unused_result));
+
+json_object *
+event_operator_serialise (const EventOperator *oper)
+	__attribute__ ((warn_unused_result));
+
+json_object *
+event_operator_serialise_all (EventOperator *root)
+	__attribute__ ((warn_unused_result));
+
+EventOperator *
+event_operator_deserialise (void *parent, json_object *json)
+	__attribute__ ((warn_unused_result));
+
+EventOperator *
+event_operator_deserialise_all (void *parent, json_object *json)
+	__attribute__ ((warn_unused_result));
+
+
 char *event_operator_collapse (EventOperator *condition)
-	__attribute__ ((warn_unused_result));
+	__attribute__ ((warn_unused_result, unused));
 
 NIH_END_EXTERN
 

=== modified file 'init/job.c'
--- init/job.c	2013-05-27 14:29:22 +0000
+++ init/job.c	2013-06-05 16:21:24 +0000
@@ -570,6 +570,7 @@
 							  job->path));
 				}
 
+				/* Destroy the instance */
 				nih_free (job);
 			}
 
@@ -1577,7 +1578,6 @@
 	json_object      *json_pid;
 	json_object      *json_fds;
 	json_object      *json_logs;
-	nih_local char   *stop_on = NULL;
 
 	nih_assert (job);
 
@@ -1611,12 +1611,13 @@
 		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_object *json_stop_on;
+
+		json_stop_on = event_operator_serialise_all (job->stop_on);
+		if (! json_stop_on)
+			goto error;
+
+		json_object_object_add (json, "stop_on", json_stop_on);
 	}
 
 	json_fds = state_serialise_int_array (int, job->fds, job->num_fds);
@@ -1739,7 +1740,6 @@
 json_object *
 job_serialise_all (const NihHash *jobs)
 {
-	int          count = 0;
 	json_object *json;
 
 	nih_assert (jobs);
@@ -1752,7 +1752,6 @@
 		json_object  *json_job;
 		Job *job = (Job *)iter;
 
-		count++;
 		json_job = job_serialise (job);
 
 		if (! json_job)
@@ -1761,12 +1760,6 @@
 		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:
@@ -1794,6 +1787,7 @@
 	json_object    *json_fds;
 	json_object    *json_pid;
 	json_object    *json_logs;
+	json_object    *json_stop_on = NULL;
 	size_t          len;
 	int             ret;
 
@@ -1833,37 +1827,53 @@
 	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 (json_object_object_get_ex (json, "stop_on", &json_stop_on)) {
+
+		if (state_check_json_type (json_stop_on, array)) {
+
+			job->stop_on = event_operator_deserialise_all (job, json_stop_on);
 			if (! job->stop_on)
 				goto error;
+		} else {
+			nih_local char *stop_on = NULL;
+
+			/* Old format (string)
+			 *
+			 * Note that we re-search for the JSON key here
+			 * (json, rather than json_stop_on) to allow
+			 * the use of the convenience macro. This is
+			 * of course slower, but its a legacy scenario.
+			 */
+
+			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;
+			}
 		}
 	}
 
@@ -2284,7 +2294,7 @@
 Job *
 job_find (const Session  *session,
 	  JobClass       *class,
-	  char           *job_class,
+	  const char     *job_class,
 	  const char     *job_name)
 {
 	Job       *job;
@@ -2293,7 +2303,7 @@
 	nih_assert (job_classes);
 
 	if (! class)
-		class = job_class_find (session, job_class);
+		class = job_class_get_registered (job_class, session);
 
 	if (! class)
 		goto error;

=== modified file 'init/job.h'
--- init/job.h	2013-05-15 13:21:54 +0000
+++ init/job.h	2013-06-05 16:21:24 +0000
@@ -222,8 +222,8 @@
 
 Job *       job_find            (const Session *session,
 				 JobClass       *class,
-				 char  *job_class,
-				 const char *job_name)
+				 const char     *job_class,
+				 const char     *job_name)
 	__attribute__ ((warn_unused_result));
 
 NIH_END_EXTERN

=== modified file 'init/job_class.c'
--- init/job_class.c	2013-05-15 13:21:54 +0000
+++ init/job_class.c	2013-06-05 16:21:24 +0000
@@ -2,7 +2,7 @@
  *
  * job_class.c - job class definition handling
  *
- * Copyright © 2011 Canonical Ltd.
+ * Copyright  2011 Canonical Ltd.
  * Author: Scott James Remnant <[e-mail]>.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -371,6 +371,35 @@
 	return NULL;
 }
 
+/**
+ * job_class_get_registered:
+ *
+ * @name: name of JobClass to search for,
+ * @session: Session of @class.
+ *
+ * Determine the currently registered JobClass with name @name for
+ * session @session.
+ *
+ * Returns: JobClass or NULL if no JobClass with name @name and
+ * session @session is registered.
+ **/
+JobClass *
+job_class_get_registered (const char *name, const Session *session)
+{
+	JobClass *registered = NULL;
+
+	nih_assert (name);
+
+	job_class_init ();
+
+	/* If we found an entry, ensure we only consider the appropriate session */
+	do {
+		registered = (JobClass *)nih_hash_search (job_classes,
+				name, registered ? &registered->entry : NULL);
+	} while (registered && registered->session != session);
+
+	return registered;
+}
 
 /**
  * job_class_consider:
@@ -385,7 +414,8 @@
 int
 job_class_consider (JobClass *class)
 {
-	JobClass *registered = NULL, *best = NULL;
+	JobClass           *registered = NULL;
+	JobClass           *best = NULL;
 
 	nih_assert (class != NULL);
 
@@ -395,16 +425,19 @@
 	nih_assert (best != NULL);
 	nih_assert (best->session == class->session);
 
-	registered = (JobClass *)nih_hash_search (job_classes, class->name, NULL);
-
-	/* If we found an entry, ensure we only consider the appropriate session */
-	while (registered && registered->session != class->session)
-		registered = (JobClass *)nih_hash_search (job_classes, class->name, &registered->entry);
+	registered = job_class_get_registered (class->name, class->session);
 
 	if (registered != best) {
-		if (registered)
-			if (! job_class_remove (registered, class->session))
+		if (registered) {
+			job_class_event_block (NULL, registered, best);
+
+			if (! job_class_remove (registered, class->session)) {
+				/* Couldn't deregister, so undo */
+				if (best->start_on)
+					event_operator_reset (best->start_on);
 				return FALSE;
+			}
+		}
 
 		job_class_add (best);
 	}
@@ -428,7 +461,8 @@
 int
 job_class_reconsider (JobClass *class)
 {
-	JobClass *registered = NULL, *best = NULL;
+	JobClass           *registered = NULL;
+	JobClass           *best = NULL;
 
 	nih_assert (class != NULL);
 
@@ -436,11 +470,7 @@
 
 	best = conf_select_job (class->name, class->session);
 
-	registered = (JobClass *)nih_hash_search (job_classes, class->name, NULL);
-
-	/* If we found an entry, ensure we only consider the appropriate session */
-	while (registered && registered->session != class->session)
-		registered = (JobClass *)nih_hash_search (job_classes, class->name, &registered->entry);
+	registered = job_class_get_registered (class->name, class->session);
 
 	if (registered == class) {
 		if (class != best) {
@@ -459,6 +489,80 @@
 }
 
 /**
+ * job_class_event_block:
+ *
+ * @parent: parent object for list,
+ * @old: original JobClass currently registered in job_classes,
+ * @new: new "best" JobClass that is not yet present in job_classes.
+ *
+ * Compare @old and @new start on EventOperator trees looking for
+ * matching events that occur in both (_and_ which implicitly still exist
+ * in the global events list). Events that satisfy these criteria will have
+ * their reference count elevated to allow @new to replace @old in job_classes
+ * without the destruction of @old freeing the events in question.
+ *
+ * Note that the reference count never needs to be decremented back
+ * again since this function effectively passes "ownership" of the event
+ * block from @old to @new, since @old will be replaced by @new but @new
+ * should replicate the EventOperator state of @old.
+ **/
+void
+job_class_event_block (void *parent, JobClass *old, JobClass *new)
+{
+	EventOperator  *old_root;
+	EventOperator  *new_root;
+
+	if (! old || ! new)
+		return;
+
+	old_root = old->start_on;
+	new_root = new->start_on;
+
+	/* If either @old or @new are NULL, or have no start_on
+	 * condition, there is no need to modify any events.
+	 */
+	if (! old_root || ! new_root)
+		return;
+
+	/* The old JobClass has associated instances meaning it 
+	 * will not be possible for job_class_remove() to replace it, so
+	 * we don't need to manipulate any event reference counts.
+	 */
+	NIH_HASH_FOREACH (old->instances, iter)
+		return;
+
+	NIH_TREE_FOREACH_POST (&old_root->node, iter) {
+		EventOperator  *old_oper = (EventOperator *)iter;
+		Event          *event;
+
+		if (old_oper->type != EVENT_MATCH)
+			continue;
+
+		/* Ignore nodes that are not blocking events */
+		if (! old_oper->event)
+			continue;
+
+		/* Since the JobClass is blocking an event,
+		 * that event must be valid.
+		 */
+		event = old_oper->event;
+
+		NIH_TREE_FOREACH_POST (&new_root->node, niter) {
+			EventOperator *new_oper = (EventOperator *)niter;
+
+			if (new_oper->type != EVENT_MATCH)
+				continue;
+
+			/* ignore the return - we just want to ensure
+			 * that any events in @new that match those in
+			 * @old have identical nodes.
+			 */
+			(void)event_operator_handle (new_oper, event, NULL);
+		}
+	}
+}
+
+/**
  * job_class_add:
  * @class: new class to select.
  *
@@ -493,24 +597,21 @@
 void
 job_class_add_safe (JobClass *class)
 {
-	JobClass *existing = NULL;
+	JobClass *registered = NULL;
 
 	nih_assert (class);
 	nih_assert (class->name);
 
 	control_init ();
 
-	/* Ensure no existing class exists for the same session */
-	do {
-		existing = (JobClass *)nih_hash_search (job_classes,
-				class->name, existing ? &existing->entry : NULL);
-	} while (existing && existing->session != class->session);
+	registered = job_class_get_registered (class->name, class->session);
 
-	nih_assert (! existing);
+	nih_assert (! registered);
 
 	job_class_add (class);
 }
 
+
 /**
  * job_class_remove:
  * @class: class to remove,
@@ -1286,6 +1387,8 @@
 
 	nih_assert (name);
 
+	job_class_init ();
+
 	do {
 		class = (JobClass *)nih_hash_search (job_classes, name, prev);
 		if (! class)
@@ -1710,8 +1813,8 @@
 	json_object      *json_normalexit;
 	json_object      *json_limits;
 	json_object      *json_jobs;
-	nih_local char   *start_on = NULL;
-	nih_local char   *stop_on = NULL;
+	json_object      *json_start_on;
+	json_object      *json_stop_on;
 	int               session_index;
 
 	nih_assert (class);
@@ -1721,15 +1824,6 @@
 	if (! json)
 		return NULL;
 	
-	/* XXX: chroot jobs are not currently supported
-	 * due to ConfSources not currently being serialised.
-	 */
-	if (class->session) {
-		nih_info ("WARNING: serialisation of chroot "
-				"sessions not currently supported");
-		goto error;
-	}
-
 	session_index = session_get_index (class->session);
 	if (session_index < 0)
 		goto error;
@@ -1774,21 +1868,19 @@
 	json_object_object_add (json, "export", json_export);
 
 	if (class->start_on) {
-		start_on = event_operator_collapse (class->start_on);
-		if (! start_on)
+		json_start_on = event_operator_serialise_all (class->start_on);
+		if (! json_start_on)
 			goto error;
 
-		if (! state_set_json_string_var (json, "start_on", start_on))
-			goto error;
+		json_object_object_add (json, "start_on", json_start_on);
 	}
 
 	if (class->stop_on) {
-		stop_on = event_operator_collapse (class->stop_on);
-		if (! stop_on)
+		json_stop_on = event_operator_serialise_all (class->stop_on);
+		if (! json_stop_on)
 			goto error;
 
-		if (! state_set_json_string_var (json, "stop_on", stop_on))
-			goto error;
+		json_object_object_add (json, "stop_on", json_stop_on);
 	}
 
 	json_emits = class->emits
@@ -1888,7 +1980,20 @@
 /**
  * job_class_serialise_all:
  *
- * Convert existing JobClass objects to JSON representation.
+ * Convert existing JobClass objects in job classes hash to JSON
+ * representation.
+ *
+ * NOTE: despite its name, this function does not _necessarily_
+ * serialise all JobClasses - there may be "best" (ie newer) JobClasses
+ * associated with ConfFiles that have not yet replaced the existing
+ * entries in the job classes hash if the JobClass has running instances.
+ *
+ * However, this is academic since although such data is not serialised,
+ * after the re-exec conf_reload() is called to recreate these "best"
+ * JobClasses. This also has the nice side-effect of ensuring that
+ * should jobs get created in the window when Upstart is statefully
+ * re-exec'ing, it will always see the newest versions of on-disk files
+ * (which is what the user expects).
  *
  * Returns: JSON object containing array of JobClass objects,
  * or NULL on error.
@@ -1910,17 +2015,17 @@
 
 		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;
+			goto error;
 
 		json_object_array_add (json, json_class);
 	}
 
 	return json;
+
+error:
+	json_object_put (json);
+	return NULL;
 }
 
 /**
@@ -1937,11 +2042,14 @@
 {
 	json_object    *json_normalexit;
 	JobClass       *class = NULL;
+	ConfFile       *file = NULL;
 	Session        *session;
 	int             session_index = -1;
 	int             ret;
 	nih_local char *name = NULL;
 	nih_local char *path = NULL;
+	json_object    *json_start_on = NULL;
+	json_object    *json_stop_on = NULL;
 
 	nih_assert (json);
 	nih_assert (job_classes);
@@ -1957,11 +2065,9 @@
 
 	session = session_from_index (session_index);
 
-	/* XXX: chroot jobs are not currently supported
-	 * due to ConfSources not currently being serialised.
-	 */
+	/* XXX: chroot and old user session jobs not currently supported */
 	if (session) {
-		nih_info ("WARNING: deserialisation of chroot "
+		nih_info ("WARNING: deserialisation of user/chroot "
 				"sessions not currently supported");
 		goto error;
 	}
@@ -1969,10 +2075,20 @@
 	if (! state_get_json_string_var_strict (json, "name", NULL, name))
 		goto error;
 
+	/* Create the class and associate it with the ConfFile */
 	class = job_class_new (NULL, name, session);
 	if (! class)
 		goto error;
 
+	/* Lookup the ConfFile associated with this class.
+	 *
+	 * Don't error if this fails since previous serialisation data
+	 * formats did not encode ConfSources and ConfFiles.
+	 */
+	file = conf_file_find (name, session);
+	if (file)
+		file->job = class;
+
 	/* job_class_new() sets path */
 	if (! state_get_json_string_var_strict (json, "path", NULL, path))
 		goto error;
@@ -2003,52 +2119,77 @@
 		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_ex (json, "start_on", &json_start_on)) {
+
+		if (state_check_json_type (json_start_on, array)) {
+
+			class->start_on = event_operator_deserialise_all (class, json_start_on);
+			if (! class->start_on)
+				goto error;
+		} else {
+			nih_local char *start_on = NULL;
+
+			/* Old format (string).
+			 *
+			 * Note that we re-search for the JSON key here
+			 * (json, rather than json_start_on) to allow
+			 * the use of the convenience macro. This is
+			 * of course slower, but its a legacy scenario.
+			 */
+			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 (json_object_object_get_ex (json, "stop_on", &json_stop_on)) {
+
+		if (state_check_json_type (json_stop_on, array)) {
+
+			class->stop_on = event_operator_deserialise_all (class, json_stop_on);
+			if (! class->stop_on)
+				goto error;
+		} else {
+			nih_local char *stop_on = NULL;
+
+			/* Old format (string) - re-search as above */
+
+			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;
+				}
 			}
 		}
 	}
@@ -2137,12 +2278,17 @@
 	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);
+	if (file) {
+		/* Add the class to the job_classes hash if ConfFiles were
+		 * available in the serialisation data.
+		 */
+		job_class_consider (class);
+	} else {
+		/* No ConfSources and ConfFiles were available in the
+		 * serialisation data, so special-case the insertion.
+		 */
+		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
@@ -2187,7 +2333,7 @@
 		goto error;
 
 	for (int i = 0; i < json_object_array_length (json_classes); i++) {
-		json_object         *json_class;
+		json_object  *json_class;
 
 		json_class = json_object_array_get_idx (json_classes, i);
 		if (! json_class)
@@ -2198,11 +2344,23 @@
 
 		class = job_class_deserialise (json_class);
 
-		/* For parity with the serialisation code, don't treat
-		 * errors as fatal for the entire deserialisation.
+		/* Either memory is low or -- more likely -- a JobClass
+		 * with a session was encountered, so keep going.
 		 */
-		if (! class)
-			continue;
+		if (! class) {
+			int session_index = -1;
+
+			if (state_get_json_int_var (json_class, "session", session_index)
+					&& session_index > 0) {
+				/* Although ConfSources are now serialised, ignore
+				 * JobClasses with associated user/chroot sessions to avoid
+				 * behavioural changes for the time being.
+				 */
+				continue;
+			} else {
+				goto error;
+			}
+		}
 	}
 
 	return 0;
@@ -2358,33 +2516,6 @@
 }
 
 /**
- * job_class_find:
- *
- * @session: session,
- * @name: name of JobClass.
- *
- * Lookup a JobClass by session and name.
- *
- * Returns: JobClass associated with @session, or NULL if not found.
- */
-JobClass *
-job_class_find (const Session *session,
-		const char *name)
-{
-	JobClass *class = NULL;
-
-	nih_assert (name);
-	nih_assert (job_classes);
-
-	do {
-		class = (JobClass *)nih_hash_search (job_classes,
-				name, class ? &class->entry : NULL);
-	} while (class && class->session != session);
-
-	return class;
-}
-
-/**
  * job_class_max_kill_timeout:
  *
  * Determine maximum kill timeout for all running jobs.
@@ -2413,3 +2544,29 @@
 
 	return kill_timeout;
 }
+
+/**
+ * job_class_get_index:
+ * @class: JobClass to search for.
+ *
+ * Returns: index of @class in the job classes hash,
+ * or -1 if not found.
+ **/
+ssize_t
+job_class_get_index (const JobClass *class)
+{
+	ssize_t i = 0;
+
+	nih_assert (class);
+
+	NIH_HASH_FOREACH (job_classes, iter) {
+		JobClass *c = (JobClass *)iter;
+
+		if (! strcmp (c->name, class->name)
+				&& c->session == class->session)
+			return i;
+		i++;
+	}
+
+	return -1;
+}

=== modified file 'init/job_class.h'
--- init/job_class.h	2013-05-15 13:21:54 +0000
+++ init/job_class.h	2013-06-05 16:21:24 +0000
@@ -359,12 +359,18 @@
 
 void job_class_prepare_reexec (void);
 
-JobClass * job_class_find (const Session *session, const char *name)
-	__attribute__ ((warn_unused_result));
-
 time_t     job_class_max_kill_timeout (void)
 	__attribute__ ((warn_unused_result));
 
+JobClass  *job_class_get_registered (const char *name, const Session *session)
+	__attribute__ ((warn_unused_result));
+
+void       job_class_event_block (void *parent, JobClass *old, JobClass *new);
+
+ssize_t
+job_class_get_index (const JobClass *class)
+	__attribute__ ((warn_unused_result));
+
 NIH_END_EXTERN
 
 #endif /* INIT_JOB_CLASS_H */

=== modified file 'init/main.c'
--- init/main.c	2013-04-22 10:30:09 +0000
+++ init/main.c	2013-06-05 16:21:24 +0000
@@ -126,6 +126,7 @@
 extern int          disable_job_logging;
 extern int          use_session_bus;
 extern int          default_console;
+extern int          write_state_file;
 extern char        *log_dir;
 
 
@@ -173,6 +174,9 @@
 	{ 0, "user", N_("start in user mode (as used for user sessions)"),
 		NULL, NULL, &user_mode, NULL },
 
+	{ 0, "write-state-file", N_("attempt to write state file on every re-exec"),
+		NULL, NULL, &write_state_file, NULL },
+
 	/* Ignore invalid options */
 	{ '-', "--", NULL, NULL, NULL, NULL, NULL },
 

=== modified file 'init/paths.h'
--- init/paths.h	2013-01-25 10:08:19 +0000
+++ init/paths.h	2013-06-05 16:21:24 +0000
@@ -97,6 +97,15 @@
 #endif
 
 /**
+ * STATE_FILE_ENV:
+ *
+ * If set, write STATE_FILE on any re-exec.
+ **/
+#ifndef STATE_FILE_ENV
+#define STATE_FILE_ENV "UPSTART_WRITE_STATEFILE"
+#endif
+
+/**
  * INIT_XDG_SUBDIR:
  *
  * This is the name of the sub folder we will use when constructing

=== modified file 'init/state.c'
--- init/state.c	2013-02-28 16:40:36 +0000
+++ init/state.c	2013-06-05 16:21:24 +0000
@@ -47,6 +47,7 @@
 json_object *json_sessions = NULL;
 json_object *json_events = NULL;
 json_object *json_classes = NULL;
+json_object *json_conf_sources = NULL;
 
 extern char *log_dir;
 
@@ -67,6 +68,13 @@
  **/
 int restart = FALSE;
 
+/**
+ * write_state_file:
+ *
+ * If TRUE, write STATE_FILE on every re-exec.
+ **/
+int write_state_file = FALSE;
+
 /* Prototypes for static functions */
 static JobClass *
 state_index_to_job_class (int job_class_index)
@@ -233,6 +241,9 @@
 	if (state_from_string (buffer->buf) < 0)
 		goto error;
 
+	if (write_state_file || getenv (STATE_FILE_ENV))
+		state_write_file (buffer);
+
 	return 0;
 
 error:
@@ -327,8 +338,8 @@
 int
 state_to_string (char **json_string, size_t *len)
 {
-	json_object        *json;
-	const char         *value;
+	json_object  *json;
+	const char   *value;
 
 	nih_assert (json_string);
 	nih_assert (len);
@@ -339,24 +350,39 @@
 		return -1;
 
 	json_sessions = session_serialise_all ();
-	if (! json_sessions)
+	if (! json_sessions) {
+		nih_error ("%s Sessions", _("Failed to serialise"));
 		goto error;
+	}
 
 	json_object_object_add (json, "sessions", json_sessions);
 
 	json_events = event_serialise_all ();
-	if (! json_events)
+	if (! json_events) {
+		nih_error ("%s Events", _("Failed to serialise"));
 		goto error;
+	}
 
 	json_object_object_add (json, "events", json_events);
 
 	json_classes = job_class_serialise_all ();
 
-	if (! json_classes)
+	if (! json_classes) {
+		nih_error ("%s JobClasses", _("Failed to serialise"));
 		goto error;
+	}
 
 	json_object_object_add (json, "job_classes", json_classes);
 
+	json_conf_sources = conf_source_serialise_all ();
+
+	if (! json_conf_sources) {
+		nih_error ("%s ConfSources", _("Failed to serialise"));
+		goto error;
+	}
+
+	json_object_object_add (json, "conf_sources", json_conf_sources);
+
 	/* Note that the returned value is managed by json-c! */
 	value = json_object_to_json_string (json);
 	if (! value)
@@ -410,17 +436,37 @@
 	if (! state_check_json_type (json, object))
 		goto out;
 
-	if (session_deserialise_all (json) < 0)
-		goto out;
-
-	if (event_deserialise_all (json) < 0)
-		goto out;
-
-	if (job_class_deserialise_all (json) < 0)
-		goto out;
-
-	if (state_deserialise_resolve_deps (json) < 0)
-		goto out;
+	if (session_deserialise_all (json) < 0) {
+		nih_error ("%s Sessions", _("Failed to deserialise"));
+		goto out;
+	}
+
+	if (event_deserialise_all (json) < 0) {
+		nih_error ("%s Events", _("Failed to deserialise"));
+		goto out;
+	}
+
+	/* Again, we cannot error here since older JSON state data did
+	 * not encode ConfSource or ConfFile objects.
+	 */
+	if (json_object_object_get (json, "conf_sources")) {
+		if (conf_source_deserialise_all (json) < 0) {
+			nih_error ("%s ConfSources", _("Failed to deserialise"));
+			goto out;
+		}
+	} else {
+			nih_warn ("%s", _("No ConfSources present in state data"));
+	}
+
+	if (job_class_deserialise_all (json) < 0) {
+		nih_error ("%s JobClasses", _("Failed to deserialise"));
+		goto out;
+	}
+
+	if (state_deserialise_resolve_deps (json) < 0) {
+		nih_error (_("Failed to resolve deserialisation dependencies"));
+		goto out;
+	}
 
 	ret = 0;
 
@@ -1118,7 +1164,6 @@
 	return json_type_null;
 }
 
-
 /**
  * state_deserialise_resolve_deps:
  *
@@ -1135,8 +1180,9 @@
 {
 	nih_assert (json);
 
-	/* XXX: Events, JobClasses, Jobs and DBusConnections must have
-	 * previously been deserialised before invoking this function.
+	/* XXX: Sessions, Events, JobClasses, Jobs and DBusConnections
+	 * must have previously been deserialised before invoking
+	 * this function.
 	 */
 	nih_assert (json_sessions);
 	nih_assert (json_events);
@@ -1175,14 +1221,21 @@
 
 		/* lookup class associated with JSON class index */
 		class = state_index_to_job_class (i);
-		if (! class)
-			goto error;
-
-		/* XXX: user and chroot jobs are not currently supported
-		 * due to ConfSources not currently being serialised.
-		 */
-		if (class->session)
-			continue;
+		if (! class) {
+			int session_index = -1;
+
+			if (state_get_json_int_var (json_class, "session", session_index)
+					&& session_index > 0) {
+
+				/* Although ConfSources are now serialised, ignore
+				 * JobClasses with associated user/chroot sessions to avoid
+				 * behavioural changes for the time being.
+				 */
+				continue;
+			} else {
+				goto error;
+			}
+		}
 
 		if (! state_get_json_var_full (json_class, "jobs", array, json_jobs))
 			goto error;
@@ -1526,7 +1579,12 @@
 
 			blocked = NIH_MUST (blocked_new (parent, BLOCKED_EVENT, event));
 			nih_list_add (list, &blocked->entry);
-			event_block (blocked->event);
+			
+			/* Event must already exist and should have
+			 * blockers associated for it to have a blocked
+			 * object pointing at it.
+			 */
+			nih_assert (blocked->event->blockers);
 		}
 		break;
 
@@ -1655,7 +1713,6 @@
 		if (! json_blocked)
 			goto error;
 
-
 		/* Don't error in this scenario to allow for possibility
 		 * that version of Upstart that performed the
 		 * serialisation did not correctly handle user and
@@ -1894,7 +1951,7 @@
 void
 stateful_reexec (void)
 {
-	int             fds[2] = { -1 };
+	int             fds[2] = { -1, -1 };
 	pid_t           pid;
 	sigset_t        mask, oldmask;
 	nih_local char *state_data = NULL;

=== modified file 'init/state.h'
--- init/state.h	2013-02-27 11:46:04 +0000
+++ init/state.h	2013-06-05 16:21:24 +0000
@@ -4,7 +4,7 @@
  *
  * - XXX: Deferred work:
  *   - handling of Upstart-in-initramfs - for this to work, it would be
- *     necessary to serialise ConfSources along with the following:
+ *     necessary to serialise ConfSources (done) along with the following:
  *
  *     (1) inode number of source->path
  *     (2) inode number of '/'
@@ -27,12 +27,6 @@
  *     Note too that (2)+(3) are the only reliable method for Upstart to
  *     detect that is *has* changed filesystem context.
  *
- *   - Since ConfSources are NOT serialised, it is currently not possible
- *     to support chroot jobs (because the only ConfSource
- *     objects created are those at startup (for '/etc/init/'): any
- *     pre-existing ConfSources with non-NULL Session objects will
- *     be ignored).
- *
  *   - parent/child timeout handling: we won't support down-grading initially.
  *
  *   - dbus-connections: only be re-exec'ing post-boot so bridges won't
@@ -371,7 +365,7 @@
  *
  * Name of file that is written below the job log directory if the
  * newly re-exec'ed init instance failed to understand the JSON sent to
- * it by the old instance.
+ * it by the old instance (or if requested by STATE_FILE_ENV).
  *
  * This could happen for example if the old instance generated invalid
  * JSON, or JSON in an unexected format.
@@ -1226,6 +1220,9 @@
 struct rlimit *state_rlimit_deserialise (json_object *json)
 	__attribute__ ((warn_unused_result));
 
+int state_get_version (void)
+	__attribute__ ((warn_unused_result));
+
 extern char **args_copy;
 extern int restart;
 

=== added file 'init/tests/data/upstart-1.8+apparmor.json'
--- init/tests/data/upstart-1.8+apparmor.json	1970-01-01 00:00:00 +0000
+++ init/tests/data/upstart-1.8+apparmor.json	2013-06-05 16:21:24 +0000
@@ -0,0 +1,7962 @@
+{
+   "sessions" : [],
+   "job_classes" : [
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  669,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 2,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "stopping dbus",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "JOB=dbus",
+                  "INSTANCE=",
+                  "UPSTART_EVENTS=filesystem started"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/avahi_2ddaemon/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_DAEMON",
+         "stop_on" : "stopping dbus",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "avahi-daemon",
+         "instance" : "",
+         "description" : "mDNS/DNS-SD daemon",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 1,
+               "command" : "opts=\"-D\"\n[ -e \"/etc/eucalyptus/avahi-daemon.conf\" ] && opts=\"${opts} -f /etc/eucalyptus/avahi-daemon.conf\"\nexec avahi-daemon ${opts}\n"
+            },
+            {
+               "script" : 1,
+               "command" : "/lib/init/apparmor-profile-load usr.sbin.avahi-daemon\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/avahi_2ddaemon",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "(filesystem and started dbus)",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "UPSTART_EVENTS=virtual-filesystems"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/mountnfs_2dbootclean_2esh/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "mountnfs-bootclean.sh",
+         "instance" : "",
+         "description" : null,
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 0,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/mountnfs_2dbootclean_2esh",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "virtual-filesystems",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  659,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 1,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [06]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "UPSTART_EVENTS=filesystem"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/rsyslog/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_FORK",
+         "stop_on" : "runlevel [06]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "rsyslog",
+         "instance" : "",
+         "description" : "system logging daemon",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 1,
+               "command" : ". /etc/default/rsyslog\nexec rsyslogd $RSYSLOGD_OPTIONS\n"
+            },
+            {
+               "script" : 1,
+               "command" : "/lib/init/apparmor-profile-load usr.sbin.rsyslogd\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/rsyslog",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "filesystem",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  1023,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [!23]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "RUNLEVEL=2",
+                  "PREVLEVEL=N",
+                  "UPSTART_EVENTS=runlevel not-container"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/tty4/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "stop_on" : "runlevel [!23]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "tty4",
+         "instance" : "",
+         "description" : null,
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "/sbin/getty -8 38400 tty4"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/tty4",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "(runlevel [23] and ((not-container or container CONTAINER=lxc) or container CONTAINER=lxc-libvirt))",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  562,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 1,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [06]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "UPSTART_EVENTS=virtual-filesystems"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/udev/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_FORK",
+         "stop_on" : "runlevel [06]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "udev",
+         "instance" : "",
+         "description" : "device node and kernel event manager",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "/lib/systemd/systemd-udevd --daemon"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/udev",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "virtual-filesystems",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  545,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 2,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "stopped udev",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "JOB=udev",
+                  "INSTANCE=",
+                  "UPSTART_EVENTS=starting"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/upstart_2dudev_2dbridge/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [
+            "*-device-added",
+            "*-device-removed",
+            "*-device-changed",
+            "*-device-online",
+            "*-device-offline"
+         ],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_DAEMON",
+         "stop_on" : "stopped udev",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "upstart-udev-bridge",
+         "instance" : "",
+         "description" : "Bridge udev events into upstart",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "upstart-udev-bridge --daemon"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/upstart_2dudev_2dbridge",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "starting udev",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  1143,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 1,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [!2345]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "CRASH_DB_URL=https://daisy.ubuntu.com",
+                  "RUNLEVEL=2",
+                  "PREVLEVEL=N",
+                  "UPSTART_EVENTS=runlevel"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/whoopsie/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_FORK",
+         "stop_on" : "runlevel [!2345]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "whoopsie",
+         "instance" : "",
+         "description" : "crash report submission daemon",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "whoopsie"
+            },
+            {
+               "script" : 1,
+               "command" : "    [ -x /usr/bin/ubiquity-dm ] && { stop; exit 0; }\n\n    if ! grep report_crashes=true /etc/default/whoopsie -sqi; then\n        stop; exit 0\n    fi\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [
+            "CRASH_DB_URL=https://daisy.ubuntu.com"
+         ],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/whoopsie",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "runlevel [2345]",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [!2345]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "enabled=1",
+                  "RUNLEVEL=2",
+                  "PREVLEVEL=N",
+                  "UPSTART_EVENTS=runlevel"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/apport/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "stop_on" : "runlevel [!2345]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "apport",
+         "instance" : "",
+         "description" : "automatic crash report generation",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 1,
+               "command" : "    . /etc/default/apport\n    [ \"$enabled\" = \"1\" ] || [ \"$force_start\" = \"1\" ] || exit 0\n\n    mkdir -p -m 1777 /var/crash\n\n    # check for kernel crash dump, convert it to apport report\n    if [ -e /var/crash/vmcore ] || [ -n \"`ls /var/crash | egrep ^[0-9]{12}$`\" ]\n    then\n\t/usr/share/apport/kernel_crashdump || true\n    fi\n\n    # check for incomplete suspend/resume or hibernate\n    if [ -e /var/lib/pm-utils/status ]\n    then\n        /usr/share/apport/apportcheckresume || true\n        rm -f /var/lib/pm-utils/status\n        rm -f /var/lib/pm-utils/resume-hang.log\n    fi\n\n    echo \"|/usr/share/apport/apport %p %s %c\" > /proc/sys/kernel/core_pattern\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 1,
+               "command" : "    # Check for a hung resume.  If we find one try and grab everything\n    # we can to aid in its discovery\n    if [ -e /var/lib/pm-utils/status ]\n    then\n\tps -wwef > /var/lib/pm-utils/resume-hang.log\n    fi\n\n    if [ \"`dd if=/proc/sys/kernel/core_pattern count=1 bs=1 2>/dev/null`\" != \"|\" ]\n    then\n\texit 1\n    else\n\techo \"core\" > /proc/sys/kernel/core_pattern\n    fi\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 0,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [
+            "enabled=1"
+         ],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/apport",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "runlevel [2345]",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  628,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "remote_closed" : 0,
+                     "detached" : 0,
+                     "uid" : 0,
+                     "open_errno" : 9,
+                     "path" : "/var/log/upstart/systemd-logind.log",
+                     "io_watch_fd" : 17,
+                     "fd" : 15
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "stopping dbus",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "SYSTEMD_LOG_TARGET=syslog",
+                  "JOB=dbus",
+                  "INSTANCE=",
+                  "UPSTART_EVENTS=started"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/systemd_2dlogind/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "stop_on" : "stopping dbus",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "systemd-logind",
+         "instance" : "",
+         "description" : "SystemD login management service",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "/lib/systemd/systemd-logind"
+            },
+            {
+               "script" : 1,
+               "command" : "    # only start if PAM module is actually available, not if libpam-systemd is\n    # removed but not purged\n    [ -e /lib/*/security/pam_systemd.so ] || { stop; exit 0; }\n\n    # this is being done by systemd or mountall usually, but not during\n    # upgrades from earlier distro releases\n    if ! mountpoint -q /sys/fs/cgroup; then\n        mount -t tmpfs -o uid=0,gid=0,mode=0755,size=1024 none /sys/fs/cgroup\n    fi\n    mkdir -p /run/systemd\n    if ! mountpoint -q /sys/fs/cgroup/systemd; then\n        mkdir -p /sys/fs/cgroup/systemd\n        mount -t cgroup -o nosuid,noexec,nodev,none,name=systemd systemd /sys/fs/cgroup/systemd\n    fi\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 16384,
+               "rlim_max" : 16384
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [
+            "SYSTEMD_LOG_TARGET=syslog"
+         ],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/systemd_2dlogind",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "started dbus",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  1032,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "runlevel [!23]",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "RUNLEVEL=2",
+                  "PREVLEVEL=N",
+                  "UPSTART_EVENTS=runlevel not-container"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/tty5/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "stop_on" : "runlevel [!23]",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "tty5",
+         "instance" : "",
+         "description" : null,
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "/sbin/getty -8 38400 tty5"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/tty5",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "(runlevel [23] and not-container)",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  819,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "remote_closed" : 0,
+                     "detached" : 0,
+                     "uid" : 0,
+                     "open_errno" : 9,
+                     "path" : "/var/log/upstart/modemmanager.log",
+                     "io_watch_fd" : 21,
+                     "fd" : 14
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "stop_on" : "stopped network-manager",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "JOB=network-manager",
+                  "INSTANCE=",
+                  "UPSTART_EVENTS=starting"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/modemmanager/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "stop_on" : "stopped network-manager",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "modemmanager",
+         "instance" : "",
+         "description" : "modem connection manager",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : "/usr/sbin/modem-manager"
+            },
+            {
+               "script" : 1,
+               "command" : "[ -x /usr/sbin/modem-manager ] || stop\n"
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 1,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/modemmanager",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "starting network-manager",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 0,
+               "respawn_time" : 0,
+               "log" : [
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  },
+                  {
+                     "path" : null
+                  }
+               ],
+               "respawn_count" : 0,
+               "kill_process" : "PROCESS_INVALID",
+               "env" : [
+                  "PATH=/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin:/sbin:/bin",
+                  "TERM=linux",
+                  "UPSTART_EVENTS=local-filesystems"
+               ],
+               "name" : "",
+               "path" : "/com/ubuntu/Upstart/jobs/mountall_2esh/_",
+               "exit_status" : 0,
+               "goal" : "JOB_START",
+               "stop_env" : [],
+               "fds" : []
+            }
+         ],
+         "emits" : [],
+         "session" : 0,
+         "debug" : 0,
+         "export" : [],
+         "expect" : "EXPECT_NONE",
+         "chroot" : null,
+         "console" : "CONSOLE_LOG",
+         "kill_signal" : 15,
+         "name" : "mountall.sh",
+         "instance" : "",
+         "description" : "Signal sysvinit that local filesystems are mounted",
+         "respawn_interval" : 5,
+         "process" : [
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            },
+            {
+               "script" : 0,
+               "command" : null
+            }
+         ],
+         "apparmor_switch" : null,
+         "respawn_limit" : 10,
+         "author" : null,
+         "respawn" : 0,
+         "nice" : -21,
+         "limits" : [
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            },
+            {
+               "rlim_cur" : 0,
+               "rlim_max" : 0
+            }
+         ],
+         "oom_score_adj" : 0,
+         "normalexit" : [],
+         "kill_timeout" : 5,
+         "usage" : null,
+         "env" : [],
+         "version" : null,
+         "task" : 0,
+         "path" : "/com/ubuntu/Upstart/jobs/mountall_2esh",
+         "deleted" : 0,
+         "chdir" : null,
+         "start_on" : "local-filesystems",
+         "umask" : 18,
+         "setgid" : null
+      },
+      {
+         "setuid" : null,
+         "jobs" : [
+            {
+               "trace_state" : "TRACE_NONE",
+               "failed" : 0,
+               "state" : "JOB_RUNNING",
+               "failed_process" : "PROCESS_INVALID",
+               "pid" : [
+                  1136,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+               ],
+               "start_env" : [],
+               "trace_forks" : 1,
+               "respawn_time" : 0,