Merge lp:~serge-hallyn/ubuntu/utopic/systemd-shim/shim-abandoncg into lp:ubuntu/utopic/systemd-shim

[Serge Hallyn]

This is the proposed fix for 1359439.

Note that if it is possible for upstart job pre-start and start scripts to have lingering tasks, and if KillUserProcesses=no, then such a race is still possible. So if that happens, then we will want to drop the RemoveOnEmpty in the Abandon case, and accept that some cgroups may never be removed, or set KilluserProcesses=yes, or make sure upstart kills the processes, or (finally) have upstart use different cgroups for each job state.

[James Hunt (jamesodhunt)]

This fix is also required for bug 1357252.

The code changes look fine to me (although I'm not very familiar with the codebase). Just a few queries:

- src/systemd-shim.c : There's a chunk of code that's #if-0'd out. Can this be removed?

- I was imagining when I heard that systemd-shim was now long-running that it would exit when the session exits but I now see that it starts on-demand and then stays running for the duration of the boot to allow it to service requests from multiple sessions. Now that it is maintaining state, what's the implication of it stopping on error and being restarted?

- Does the shim need an apparmor policy now it's long-running?

[James Hunt (jamesodhunt)]

I have tested this code in combination with the Upstart fix for bug 1357252 and cannot now make a cgroup upstart job fail to start.

[Serge Hallyn (serge-hallyn)]

Quoting James Hunt (<email address hidden>):
> This fix is also required for bug 1357252.
>
> The code changes look fine to me (although I'm not very familiar with the codebase). Just a few queries:
>
> - src/systemd-shim.c : There's a chunk of code that's #if-0'd out. Can this be removed?

It can, but I'd rather not. It's a reminder that we have got to either
find a way to make it short-lived again, or address any issues which
were ignored previously due to systemd-shim being short-lived. This
includes closing or at least re-opening on peer-closure of the cgmanager
socket and running systemd-shim under valgrind to check for memleaks.

> - I was imagining when I heard that systemd-shim was now long-running that it would exit when the session exits but I now see that it starts on-demand and then stays running for the duration of the boot to allow it to service requests from multiple sessions. Now that it is maintaining state, what's the implication of it stopping on error and being restarted?

StopUnit will continue to work, Abandon will be ignored. So on a default
Ubuntu desktop, cgroups for any active sessions will not be deleted.

> - Does the shim need an apparmor policy now it's long-running?

D'oh, that wouldn't hurt. shim really shouldn't need much access at all.

Unmerged revisions

18. By Serge Hallyn on 2014-09-03

fix signed/unsigned in sscanf

17. By Serge Hallyn on 2014-09-03

Implement StopUnit and Abandon to remove cgroups at logout, and stop
setting remove-on-empty flag on cgroups at login.
(LP: #1355966)

=== removed file '.pc/applied-patches'
=== modified file 'debian/changelog'
--- debian/changelog	2014-08-20 08:22:08 +0000
+++ debian/changelog	2014-09-03 22:02:47 +0000
@@ -1,3 +1,11 @@
+systemd-shim (7-1ubuntu1) utopic; urgency=medium
+
+  * Implement StopUnit and Abandon to remove cgroups at logout, and stop
+    setting remove-on-empty flag on cgroups at login.
+    (LP: #1355966)
+
+ -- Serge Hallyn <[e-mail]>  Wed, 03 Sep 2014 16:42:07 -0500
+
 systemd-shim (7-1) unstable; urgency=medium
 
   * New upstream release:

=== added directory 'debian/patches'
=== added file 'debian/patches/0001-Implement-Manager-StopUnit-and-Scope-Abandon.patch'
--- debian/patches/0001-Implement-Manager-StopUnit-and-Scope-Abandon.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0001-Implement-Manager-StopUnit-and-Scope-Abandon.patch	2014-09-03 22:02:47 +0000
@@ -0,0 +1,731 @@
+From 0a3ebe04689c7bbcfcd312f697aee08a54c66aef Mon Sep 17 00:00:00 2001
+From: Serge Hallyn <[e-mail]>
+Date: Tue, 2 Sep 2014 11:03:21 -0500
+Subject: [PATCH 1/1] Implement Manager:StopUnit and Scope:Abandon
+
+First, stop setting removeonempty at login.  This is in particular
+causing problems for upstart.  Upstart uses the same cgroup name
+for several possible job states.  Using removeonempty means that
+we have an unpredictable time at which the cgroup is removed.  So
+when pre-start is over, post-stop may kick in, create the cgroup
+(which exists), now autoremove kicks in, then post-stop fails to
+move its child task into the cgroup.
+
+StopUnit is called when /etc/systemd/logind.conf has
+	KillUserProcesses=yes
+It receives the scope (unique system-wide) to be stopped, and
+kills that scope.  That means killing any tasks in the cgroup
+or its subdirectories, and removing the directories themselves.
+We first set removeonempty, then recursively kill subdirectories,
+then killall tasks, then try to remove the directory.  Some kernels
+have a race which can cause a child cgroup to not yet be listed as
+removed by the time we get to removing the parent cgroup.  That
+should not matter for us since we've set removeonempty, and the
+cgroup will get removed eventually anyway.  However, in the case
+where the cgroup was already empty, removeonempty would do nothing
+until the next time the cgroup *becomes* empty, so we still need
+to try to remove the directory by hand.  One of the other should
+always succeed.
+
+Abandon is sent differently than StopUnit - it is sent over a
+session-specific path, to interface org.freedesktop.systemd1.Scope.
+So shim needs to register the session-specific object path when it
+starts.  This means that shim cannot exit until the session has
+stopped.
+
+If there is a way to tell the dbus system bus to start us back
+up when that path is accessed (which does not persist across reboot)
+then we could do that.  Or, we can tweak the exit-on-inactivity
+code to extend timeout so long as there are open sessions.  For now
+I simply commented it out.
+
+Something should definately be done, as the shim code has been written
+until now assuming it would not persist.  For instance the cgmanager
+socket is never closed.  If there isn't a way to avoid keeping the
+shim long-running, then we will need to address these matters.
+
+Signed-off-by: Serge Hallyn <[e-mail]>
+---
+ data/org.freedesktop.systemd1.conf |   4 +
+ src/cgmanager.c                    | 214 +++++++++++++++++++++++++++++++++++--
+ src/cgmanager.h                    |   2 +
+ src/cgroup-unit.c                  |  17 ++-
+ src/systemd-iface.h                |   7 ++
+ src/systemd-shim.c                 | 193 ++++++++++++++++++++++++++++++---
+ src/unit.c                         |  33 ++++++
+ src/unit.h                         |   3 +
+ 8 files changed, 448 insertions(+), 25 deletions(-)
+
+Index: systemd-shim/data/org.freedesktop.systemd1.conf
+===================================================================
+--- systemd-shim.orig/data/org.freedesktop.systemd1.conf
++++ systemd-shim/data/org.freedesktop.systemd1.conf
+@@ -86,6 +86,10 @@
+                        send_interface="org.freedesktop.systemd1.Manager"
+                        send_member="Dump"/>
+ 
++                <allow send_destination="org.freedesktop.systemd1"
++                       send_interface="org.freedesktop.systemd1.Scope"
++                       send_member="Abandon"/>
++
+                 <allow receive_sender="org.freedesktop.systemd1"/>
+         </policy>
+ 
+Index: systemd-shim/src/cgmanager.c
+===================================================================
+--- systemd-shim.orig/src/cgmanager.c
++++ systemd-shim/src/cgmanager.c
+@@ -24,6 +24,7 @@
+ 
+ #include "cgmanager.h"
+ 
++#include <stdbool.h>
+ #include <gio/gio.h>
+ 
+ #define CGM_DBUS_ADDRESS          "unix:path=/sys/fs/cgroup/cgmanager/sock"
+@@ -84,18 +85,16 @@ log_warning_on_error (GObject      *sour
+     g_variant_unref (reply);
+   else
+     {
+-      g_warning ("cgmanager method call failed: %s.  Use G_DBUS_DEBUG=message for more info.", error->message);
++      g_info ("cgmanager method call failed: %s.  Use G_DBUS_DEBUG=message for more info.", error->message);
+       g_error_free (error);
+     }
+ }
+ 
+-static void
+-cgmanager_call (const gchar        *method_name,
+-                GVariant           *parameters,
+-                const GVariantType *reply_type)
++static GDBusConnection *connection;
++static gboolean initialised;
++
++static void cgmanager_connect_wrapper(void)
+ {
+-  static GDBusConnection *connection;
+-  static gboolean initialised;
+ 
+   /* Use a separate bool to prevent repeated attempts to connect to a
+    * defunct cgmanager...
+@@ -114,6 +113,14 @@ cgmanager_call (const gchar        *meth
+ 
+       initialised = TRUE;
+     }
++}
++
++static void
++cgmanager_call (const gchar        *method_name,
++                GVariant           *parameters,
++                const GVariantType *reply_type)
++{
++  cgmanager_connect_wrapper();
+ 
+   if (!connection)
+     return;
+@@ -146,8 +153,6 @@ cgmanager_create (const gchar *path,
+ 
+   for (i = 0; i < n_pids; i++)
+     cgmanager_call ("MovePid", g_variant_new ("(ssi)", "all", path, pids[i]), G_VARIANT_TYPE_UNIT);
+-
+-  cgmanager_call ("RemoveOnEmpty", g_variant_new ("(ss)", "all", path), G_VARIANT_TYPE_UNIT);
+ }
+ 
+ void
+@@ -164,3 +169,194 @@ cgmanager_moveself (void)
+ {
+   cgmanager_call ("MovePidAbs", g_variant_new ("(ssi)", "all", "/", getpid()), G_VARIANT_TYPE_UNIT);
+ }
++
++static bool cg_exists(const gchar *path)
++{
++  cgmanager_connect_wrapper();
++  GVariant *reply;
++  GError *error = NULL;
++
++  if (!connection)
++    return false;
++
++  reply = g_dbus_connection_call_sync (connection, NULL, "/org/linuxcontainers/cgmanager",
++                          "org.linuxcontainers.cgmanager0_0", "GetTasks",
++                          g_variant_new("(ss)", "name=systemd", path),
++                          G_VARIANT_TYPE("(ai)"), G_DBUS_CALL_FLAGS_NONE,
++                          -1, NULL, &error);
++  if (!reply) {
++    // we expect error if path does not exist
++    g_error_free (error);
++    return false;
++  }
++  return true;
++}
++
++static gchar *get_cgpath_from_scope(const gchar *scope)
++{
++  GVariant *reply, *array;
++  GError *error = NULL;
++  const gchar *child;
++  int i, last;
++
++  cgmanager_connect_wrapper();
++  if (!connection)
++    return NULL;
++
++  reply = g_dbus_connection_call_sync (connection, NULL, "/org/linuxcontainers/cgmanager",
++                          "org.linuxcontainers.cgmanager0_0", "ListChildren",
++                          g_variant_new("(ss)", "name=systemd", "user.slice"),
++                          G_VARIANT_TYPE("(as)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
++
++  if (!reply) {
++    g_warning ("Error getting list of sessions from cgmanager: %s", error->message);
++    g_error_free (error);
++    return NULL;
++  }
++
++  if (g_variant_n_children(reply) < 1) {
++    g_variant_unref(reply);
++    return NULL;
++  }
++
++  array = g_variant_get_child_value(reply, 0);
++  if (!array) {
++    g_variant_unref(reply);
++    return NULL;
++  }
++
++  last = (int)g_variant_n_children(array);
++
++  for (i = 0; i < last; i++) {
++    g_variant_get_child (array, (gsize)i, "s", &child);
++    gchar *path = g_strdup_printf("user.slice/%s/%s", child, scope);
++    if (!path) {
++        g_variant_unref(reply);
++        g_variant_unref(array);
++        return NULL;
++    }
++    if (cg_exists(path)) {
++        g_variant_unref(array);
++        g_variant_unref(reply);
++        return path;
++    }
++  }
++  g_variant_unref(array);
++  g_variant_unref(reply);
++  return NULL;
++}
++
++static void cg_rm_recursive(const gchar *path, bool killtasks)
++{
++  GVariant *reply, *array;
++  GError *error = NULL;
++  const gchar *child;
++  int i, last;
++
++  cgmanager_connect_wrapper();
++  if (!connection)
++    return;
++
++  cgmanager_call ("RemoveOnEmpty", g_variant_new ("(ss)", "all", path), G_VARIANT_TYPE_UNIT);
++
++  /* first kill any subdirs recursively */
++  reply = g_dbus_connection_call_sync (connection, NULL, "/org/linuxcontainers/cgmanager",
++                          "org.linuxcontainers.cgmanager0_0", "ListChildren",
++                          g_variant_new("(ss)", "name=systemd", path),
++                          G_VARIANT_TYPE("(as)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
++
++  if (!reply) {
++    g_warning ("Error getting list of sessions from cgmanager: %s", error->message);
++    g_error_free (error);
++    return;
++  }
++
++  if (g_variant_n_children(reply) < 1) {
++    g_variant_unref(reply);
++    return;
++  }
++
++  array = g_variant_get_child_value(reply, 0);
++  if (!array) {
++    g_variant_unref(reply);
++    return;
++  }
++
++  last = (int)g_variant_n_children(array);
++
++  for (i = 0; i < last; i++) {
++    g_variant_get_child (array, (gsize)i, "s", &child);
++    gchar *rpath = g_strdup_printf("%s/%s", path, child);
++    if (!rpath)
++        continue;
++    cg_rm_recursive(rpath, killtasks);
++  }
++  g_variant_unref(array);
++  g_variant_unref(reply);
++
++  if (killtasks) {
++    // kill any tasks here
++    reply = g_dbus_connection_call_sync (connection, NULL, "/org/linuxcontainers/cgmanager",
++                            "org.linuxcontainers.cgmanager0_0", "GetTasks",
++                            g_variant_new("(ss)", "name=systemd", path),
++                            G_VARIANT_TYPE("(ai)"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
++
++    if (!reply) {
++      g_warning ("Error getting list of sessions from cgmanager: %s", error->message);
++      g_error_free (error);
++      return;
++    }
++
++    if (g_variant_n_children(reply) < 1) {
++      g_variant_unref(reply);
++      return;
++    }
++
++    array = g_variant_get_child_value(reply, 0);
++    if (!array) {
++      g_variant_unref(reply);
++      return;
++    }
++
++    last = (int)g_variant_n_children(array);
++
++    for (i = 0; i < last; i++) {
++      guint32 pid;
++      g_variant_get_child (array, (gsize)i, "i", &pid);
++      // XXX todo - should we be nicer here, do a sigterm and wait a bit?
++      kill(pid, SIGKILL);
++    }
++    g_variant_unref(array);
++    g_variant_unref(reply);
++  }
++
++  // and remove the directory
++  cgmanager_remove(path);
++  return;
++}
++
++void cgmanager_kill (const gchar *scope)
++{
++  gchar *cgpath;
++
++  cgpath = get_cgpath_from_scope(scope);
++  if (!cgpath)
++    return;
++
++  cg_rm_recursive (cgpath, true);
++  g_free(cgpath);
++}
++
++// Abandon means we don't want to kill the tasks, but we
++// do want to remove the cgroup if/when it is empty.
++void cgmanager_abandon (const gchar *scope)
++{
++  gchar *cgpath;
++
++  cgpath = get_cgpath_from_scope(scope);
++  if (!cgpath)
++    return;
++
++  cg_rm_recursive (cgpath, false);
++  g_free(cgpath);
++}
+Index: systemd-shim/src/cgmanager.h
+===================================================================
+--- systemd-shim.orig/src/cgmanager.h
++++ systemd-shim/src/cgmanager.h
+@@ -34,4 +34,6 @@ void cgmanager_remove (const gchar *path
+ 
+ void cgmanager_moveself (void);
+ 
++void cgmanager_kill (const gchar *scope);
++
+ #endif /* _cgmanager_h_ */
+Index: systemd-shim/src/cgroup-unit.c
+===================================================================
+--- systemd-shim.orig/src/cgroup-unit.c
++++ systemd-shim/src/cgroup-unit.c
+@@ -148,10 +148,24 @@ cgroup_unit_start (Unit *unit)
+   g_free (path);
+ }
+ 
++extern void remove_scopeinfo(const gchar *scope);
++
+ static void
+ cgroup_unit_stop (Unit *unit)
+ {
+-  /* for now, no-op */
++  CGroupUnit *cg = (CGroupUnit *)unit;
++
++  cgmanager_kill(cg->name);
++  remove_scopeinfo(cg->name);
++}
++
++static void
++cgroup_unit_abandon (Unit *unit)
++{
++  CGroupUnit *cg = (CGroupUnit *)unit;
++
++  cgmanager_abandon(cg->name);
++  remove_scopeinfo(cg->name);
+ }
+ 
+ static const gchar *
+@@ -183,5 +197,6 @@ cgroup_unit_class_init (UnitClass *class
+   class->start_transient = cgroup_unit_start_transient;
+   class->start = cgroup_unit_start;
+   class->stop = cgroup_unit_stop;
++  class->abandon = cgroup_unit_abandon;
+   class->get_state = cgroup_unit_get_state;
+ }
+Index: systemd-shim/src/systemd-iface.h
+===================================================================
+--- systemd-shim.orig/src/systemd-iface.h
++++ systemd-shim/src/systemd-iface.h
+@@ -43,4 +43,11 @@ const gchar *systemd_iface =
+    "</interface>"
+   "</node>";
+ 
++const gchar *scope_iface =
++  "<node>"
++   "<interface name='org.freedesktop.systemd1.Scope'>"
++    "<method name='Abandon'/>"
++   " </interface>"
++  "</node>";
++
+ #endif
+Index: systemd-shim/src/systemd-shim.c
+===================================================================
+--- systemd-shim.orig/src/systemd-shim.c
++++ systemd-shim/src/systemd-shim.c
+@@ -26,11 +26,37 @@
+ 
+ #include <stdlib.h>
+ 
++static int open_sessions, alloced_sessions;
++
++GDBusInterfaceInfo *manager_info = NULL;
++
++GDBusInterfaceVTable mngr_vtable;
++
++struct session_bus {
++  GDBusConnection *connection;
++  guint rid;
++  gchar *scope;
++};
++struct session_bus *sessions;
++
++#if 0
++/*
++ * we need to keep the shim up as long as a session is open.  We can
++ * reintroduce the exit-on-inactivity by looking at open_sessions, or
++ * if we can register the per-session paths with the system bus
++ */
++static void had_activity (void);
++
+ static gboolean
+ exit_on_inactivity (gpointer user_data)
+ {
+   extern gboolean in_shutdown;
+ 
++  if (open_sessions) {
++    had_activity();
++    return FALSE;
++  }
++
+   if (!in_shutdown)
+     {
+       GDBusConnection *system_bus;
+@@ -55,9 +81,60 @@ had_activity (void)
+ 
+   inactivity_timeout = g_timeout_add (10000, exit_on_inactivity, NULL);
+ }
++#else
++static inline void had_activity(void) { }
++#endif
++
++static void assign_new_scopeinfo(GDBusConnection *connection, const gchar *scope)
++{
++  GDBusNodeInfo *node;
++  GDBusInterfaceInfo *iface;
++  guint sessid;
++  gchar path[1024];
++
++  if (sscanf(scope, "session-%u", &sessid) != 1) {
++    g_info("Bad session scope: %s\n", scope);
++    return;
++  }
++  node = g_dbus_node_info_new_for_xml (scope_iface, NULL);
++  g_assert(node);
++  iface = g_dbus_node_info_lookup_interface (node, "org.freedesktop.systemd1.Scope");
++  g_assert(iface);
++  if (open_sessions >= alloced_sessions) {
++    sessions = realloc(sessions, (alloced_sessions+5) * sizeof(struct session_bus));
++    g_assert(sessions);
++    alloced_sessions += 5;
++  }
++  snprintf(path, 1024, "/org/freedesktop/systemd1/unit/session_2d%u_2escope", sessid);
++  sessions[open_sessions].connection = connection;
++  sessions[open_sessions].rid = g_dbus_connection_register_object(
++      connection, path, iface, &mngr_vtable, NULL, NULL, NULL);
++  if (!sessions[open_sessions].rid) {
++    g_critical("Error registering object %s\n", path);
++    exit(1);
++  }
++  sessions[open_sessions].scope = g_strdup(scope);
++  g_assert(sessions[open_sessions].scope);
++  open_sessions++;
++}
++
++void remove_scopeinfo(const gchar *scope)
++{
++  int i;
++  for (i = 0; i < open_sessions; i++) {
++    if (strcmp(scope, sessions[i].scope) == 0) {
++      int j;
++      g_dbus_connection_unregister_object(sessions[j].connection, sessions[j].rid);
++      for (j=i; j<open_sessions-1; j++)
++        sessions[j] = sessions[j+1];
++      open_sessions--;
++      return;
++    }
++  }
++}
+ 
+ static void
+-shim_method_call (GDBusConnection       *connection,
++mngr_method_call (GDBusConnection       *connection,
+                   const gchar           *sender,
+                   const gchar           *object_path,
+                   const gchar           *interface_name,
+@@ -162,23 +239,41 @@ shim_method_call (GDBusConnection
+                                          "org.freedesktop.systemd1.Manager", "JobRemoved",
+                                          g_variant_new ("(uoss)", 0, "/", unit_get_state(unit), "done"), NULL);
+           g_variant_unref (properties);
++
++          assign_new_scopeinfo(connection, unit_get_state(unit));
+           g_object_unref (unit);
+           goto success;
+       }
+   }
++  else if (g_str_equal (method_name, "Abandon"))
++    {
++      Unit *unit;
++
++      unit = fake_unit (object_path);
++
++      if (unit)
++        {
++          unit_abandon (unit);
++          g_dbus_method_invocation_return_value (invocation, NULL);
++          g_object_unref (unit);
++          goto success;
++        }
++  }
+ 
+   else
+     g_assert_not_reached ();
+ 
+-  g_dbus_method_invocation_return_gerror (invocation, error);
+-  g_error_free (error);
++  if (error) {
++    g_dbus_method_invocation_return_gerror (invocation, error);
++    g_error_free (error);
++  }
+ 
+ success:
+   had_activity ();
+ }
+ 
+ static GVariant *
+-shim_get_property (GDBusConnection  *connection,
++mngr_get_property (GDBusConnection  *connection,
+                    const gchar      *sender,
+                    const gchar      *object_path,
+                    const gchar      *interface_name,
+@@ -197,22 +292,81 @@ shim_get_property (GDBusConnection  *con
+   return g_variant_new ("s", id);
+ }
+ 
++GDBusInterfaceVTable mngr_vtable = {
++  mngr_method_call,
++  mngr_get_property,
++};
++
++static gchar **
++subtree_enumerate (GDBusConnection       *connection,
++                   const gchar           *sender,
++                   const gchar           *object_path,
++                   gpointer               user_data)
++{
++  gchar **nodes;
++  GPtrArray *p;
++
++  p = g_ptr_array_new ();
++  g_ptr_array_add (p, g_strdup ("Manager"));
++  g_ptr_array_add (p, g_strdup ("Scope"));
++  g_ptr_array_add (p, NULL);
++  nodes = (gchar **) g_ptr_array_free (p, FALSE);
++
++  return nodes;
++}
++
++static GDBusInterfaceInfo **
++subtree_introspect (GDBusConnection       *connection,
++                    const gchar           *sender,
++                    const gchar           *object_path,
++                    const gchar           *node,
++                    gpointer               user_data)
++{
++  GPtrArray *p;
++  int i;
++
++  p = g_ptr_array_new ();
++
++  g_ptr_array_add (p, g_dbus_interface_info_ref (manager_info));
++  g_ptr_array_add (p, NULL);
++
++  return (GDBusInterfaceInfo **) g_ptr_array_free (p, FALSE);
++}
++
++static const GDBusInterfaceVTable *
++subtree_dispatch (GDBusConnection             *connection,
++                  const gchar                 *sender,
++                  const gchar                 *object_path,
++                  const gchar                 *interface_name,
++                  const gchar                 *node,
++                  gpointer                    *out_user_data,
++                  gpointer                     user_data)
++{
++  return &mngr_vtable;
++}
++
++const GDBusSubtreeVTable subtree_vtable =
++{
++  subtree_enumerate,
++  subtree_introspect,
++  subtree_dispatch
++};
++
+ static void
+ shim_bus_acquired (GDBusConnection *connection,
+                    const gchar     *name,
+                    gpointer         user_data)
+ {
+-  GDBusInterfaceVTable vtable = {
+-    shim_method_call,
+-    shim_get_property,
+-  };
+-  GDBusInterfaceInfo *iface;
+-  GDBusNodeInfo *node;
++  guint rid;
+ 
+-  node = g_dbus_node_info_new_for_xml (systemd_iface, NULL);
+-  iface = g_dbus_node_info_lookup_interface (node, "org.freedesktop.systemd1.Manager");
+-  g_dbus_connection_register_object (connection, "/org/freedesktop/systemd1", iface, &vtable, NULL, NULL, NULL);
+-  g_dbus_node_info_unref (node);
++  rid = g_dbus_connection_register_subtree (connection,
++		  "/org/freedesktop/systemd1",
++		  &subtree_vtable,
++		  G_DBUS_SUBTREE_FLAGS_NONE,
++		  NULL,  /* user_data */
++		  NULL,  /* user_data_free_func */
++		  NULL); /* GError** */
++  g_assert (rid > 0);
+ }
+ 
+ static void
+@@ -227,6 +381,13 @@ shim_name_lost (GDBusConnection *connect
+ int
+ main (void)
+ {
++  GDBusNodeInfo *node;
++
++  node = g_dbus_node_info_new_for_xml (systemd_iface, NULL);
++  g_assert( node );
++  manager_info = g_dbus_node_info_lookup_interface (node, "org.freedesktop.systemd1.Manager");
++  g_assert( manager_info);
++
+   g_bus_own_name (G_BUS_TYPE_SYSTEM,
+                   "org.freedesktop.systemd1",
+                   G_BUS_NAME_OWNER_FLAGS_NONE,
+@@ -238,4 +399,6 @@ main (void)
+   cgmanager_moveself();
+   while (1)
+     g_main_context_iteration (NULL, TRUE);
++
++  g_dbus_node_info_unref (node);
+ }
+Index: systemd-shim/src/unit.c
+===================================================================
+--- systemd-shim.orig/src/unit.c
++++ systemd-shim/src/unit.c
+@@ -18,6 +18,7 @@
+  */
+ 
+ #include "unit.h"
++#include <string.h>
+ 
+ G_DEFINE_TYPE (Unit, unit, G_TYPE_OBJECT)
+ 
+@@ -31,6 +32,30 @@ unit_class_init (UnitClass *class)
+ {
+ }
+ 
++static gchar *
++cg_session_unstrip(const gchar *orig)
++{
++   guint sessid;
++   if (sscanf(orig, "session_2d%u", &sessid) != 1)
++     return NULL;
++   return g_strdup_printf("session-%u.scope", sessid);
++}
++
++Unit *
++fake_unit (const gchar *object_path)
++{
++  Unit *unit = NULL;
++  gchar *sessionpath = strrchr(object_path, '/');
++  if (!sessionpath)
++    return NULL;
++  gchar *path = cg_session_unstrip(sessionpath+1);
++  if (!path)
++    return NULL;
++  unit = cgroup_unit_new (path);
++  g_free(path);
++  return unit;
++}
++
+ Unit *
+ lookup_unit (GVariant  *parameters,
+              GError   **error)
+@@ -103,3 +128,11 @@ unit_stop (Unit *unit)
+ 
+   return UNIT_GET_CLASS (unit)->stop (unit);
+ }
++
++void
++unit_abandon (Unit *unit)
++{
++  g_return_if_fail (unit != NULL);
++
++  return UNIT_GET_CLASS (unit)->abandon (unit);
++}
+Index: systemd-shim/src/unit.h
+===================================================================
+--- systemd-shim.orig/src/unit.h
++++ systemd-shim/src/unit.h
+@@ -35,14 +35,17 @@ typedef struct
+   void (* start) (Unit *unit);
+   void (* start_transient) (Unit *unit, GVariant *properties);
+   void (* stop) (Unit *unit);
++  void (* abandon) (Unit *unit);
+ } UnitClass;
+ 
+ GType unit_get_type (void);
+ Unit *lookup_unit (GVariant *parameters, GError **error);
++Unit *fake_unit (const gchar *object_path);
+ const gchar *unit_get_state (Unit *unit);
+ void unit_start_transient (Unit *unit, GVariant *properties);
+ void unit_start (Unit *unit);
+ void unit_stop (Unit *unit);
++void unit_abandon (Unit *unit);
+ 
+ Unit *ntp_unit_get (void);
+ 

=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2014-09-03 22:02:47 +0000
@@ -0,0 +1,1 @@
+0001-Implement-Manager-StopUnit-and-Scope-Abandon.patch