Mir

Merge lp:mir/0.19 into lp:mir/ubuntu

0.19
Merge into ubuntu

Proposed by kevin gunn on 2016-02-02

Status:	Merged
Approved by:	kevin gunn on 2016-02-05
Approved revision:	3289
Merged at revision:	1257
Proposed branch:	lp:mir/0.19
Merge into:	lp:mir/ubuntu
Diff against target:	659 lines (+245/-160) 11 files modified CMakeLists.txt (+1/-1) debian/changelog (+88/-34) src/client/probing_client_platform_factory.cpp (+24/-23) src/common/sharedlibrary/CMakeLists.txt (+1/-1) src/common/sharedlibrary/shared_library_prober.cpp (+20/-5) src/common/symbols.map (+8/-1) src/include/common/mir/shared_library_prober.h (+8/-0) src/server/compositor/multi_threaded_compositor.cpp (+80/-79) src/server/input/default_input_manager.cpp (+12/-4) tests/acceptance-tests/test_prompt_session_client_api.cpp (+1/-1) tests/unit-tests/compositor/test_multi_threaded_compositor.cpp (+2/-11)
To merge this branch:	bzr merge lp:mir/0.19
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
PS Jenkins bot	continuous-integration		Approve on 2016-02-05
Mir development team		2016-02-02	Pending
Review via email: mp+284772@code.launchpad.net

Commit Message

Mir 0.19.1 - reliability and debugging update

Description of the Change

PS Jenkins bot (ps-jenkins) wrote on 2016-02-02:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ubuntu-ci/126/rebuild

review: Needs Fixing (continuous-integration)

Daniel van Vugt (vanvugt) wrote on 2016-02-03:

I've added a critical fix from trunk. Although it required a questionable new symbols.map stanza. Needs sanity-checking.

lp:mir/0.19 updated on 2016-02-03

3287. By Daniel van Vugt on 2016-02-03: Typo

PS Jenkins bot (ps-jenkins) wrote on 2016-02-03:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ubuntu-ci/127/rebuild

review: Approve (continuous-integration)

lp:mir/0.19 updated on 2016-02-04

3288. By Daniel van Vugt on 2016-02-04: debian/changelog: s/loggging/loggging/

PS Jenkins bot (ps-jenkins) wrote on 2016-02-04:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ubuntu-ci/129/rebuild

review: Approve (continuous-integration)

lp:mir/0.19 updated on 2016-02-04

3289. By kevin gunn on 2016-02-04: disable tests/acceptance-tests/test_prompt_session_client_api.cpp due to bug 1540731

PS Jenkins bot (ps-jenkins) wrote on 2016-02-05:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-ubuntu-ci/130/rebuild

review: Approve (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Mir development team

 === modified file 'CMakeLists.txt'
 --- CMakeLists.txt	2016-01-26 06:52:31 +0000
 +++ CMakeLists.txt	2016-02-04 21:06:45 +0000
@@ -28,7 +28,7 @@
  set(MIR_VERSION_MAJOR 0)
  set(MIR_VERSION_MINOR 19)
--set(MIR_VERSION_PATCH 0)
++set(MIR_VERSION_PATCH 1)
  add_definitions(-DMIR_VERSION_MAJOR=${MIR_VERSION_MAJOR})
  add_definitions(-DMIR_VERSION_MINOR=${MIR_VERSION_MINOR})
 === modified file 'debian/changelog'
 --- debian/changelog	2016-01-28 12:19:47 +0000
 +++ debian/changelog	2016-02-04 21:06:45 +0000
@@ -1,42 +1,96 @@
++mir (0.19.1-0ubuntu1) UNRELEASED; urgency=medium
++
++  [ Kevin Gunn ]
++  * New upstream release 0.19.1 (https://launchpad.net/mir/+milestone/0.19.1)
++    - Improved reporting to assist in critical debug
++    - Improved on the fix for LP: #1527449 and LP: #1526658 in order to
++      avoid Unity8 crashing on upgraded xenial desktops.
++
++ -- Kevin Gunn <kevin.gunn@canonical.com>  Tue, 02 Feb 2016 11:59:26 -0600
++
  mir (0.19.0+16.04.20160128-0ubuntu1) xenial; urgency=medium
    [ Brandon Schaefer ]
--  * New upstream release 0.19.0
--    - API summary:
--      . mirclient abi unchanged at 9
--      . mirserver abi bumped to 37
--      . mircommon abi unchanged at 5
--      . mirplatform abi unchanged at 11
--      . mirprotobuf abi unchanged at 3
--      . mirplatformgraphics abi bumped to 7
--      . mirclientplatform abi bumped to 4
--      . mirinputplatform abi bumped to 5
--      . mircookie abi bumped to 2
--    - Bug fix:
--      . Mir servers crash on mouse input (LP: #1528438)
--      . Pinch to zoom not working reliably (LP: #1531517)
--      . Passing DisplayConfiguration scale property from
--        nested server to host appears to not work (LP: #1535780)
--      . Various TSan reports when running test suite
--        on a mir tsan enabled build (LP: #1523647)
--      . Buffer leak during repeated mirscreencasts
--        causes server to be killed (LP: #1523900)
--      . Cursor now displays correctly (LP: #1526779)
--      .ProgramOption::parse_file() reports problems to cerr (LP: #1190165)
--      . Nested servers can select wrong platform (LP: #1515558)
--      . There seems to be missing RTTI information
--         when linking with UBSan enabled (LP: #1521930)
++  * New upstream release 0.19.0 (https://launchpad.net/mir/+milestone/0.19.0)
++    - ABI summary:
++      . mirclient ABI unchanged at 9
++      . mirserver ABI bumped to 37
++      . mircommon ABI unchanged at 5
++      . mirplatform ABI unchanged at 11
++      . mirprotobuf ABI unchanged at 3
++      . mirplatformgraphics ABI bumped to 7
++      . mirclientplatform ABI bumped to 4
++      . mirinputplatform ABI bumped to 5
++      . mircookie ABI bumped to 2
++    - Enhancements:
++      . Improve compositor start logging
++      . Mir cookie support added for copy paste use
++    - Bugs fixed:
++      . [regression] Mir servers crash on mouse input -
++        std::exception::what: Client input channel write blocked : 11,
++        "Resource temporarily unavailable" (LP: #1528438)
++      . [regression] pinch to zoom not working reliably (LP: #1531517)
++      . Passing DisplayConfiguration scale property from nested server to host
++        appears to not work (LP: #1535780)
++      . [enhancement] Support copy-paste between X and Mir (LP: #1471998)
++      . Various TSan reports when running test suite on a mir tsan enabled
++        build (LP: #1523647)
++      . [testsfail] Intermittent failure in
++        TestClientInput.clients_receive_relative_pointer_events (LP: #1523872)
++      . Buffer leak during repeated mirscreencasts causes server to be killed
++        (LP: #1523900)
++      . Mir clients (including Unity8 itself) crash in XGetXCBConnection() if
++        multiple versions of mir-client-platform-mesa are installed.
++        (LP: #1526658)
++      . Cursor displayed incorrectly (looks like incorrect stride)
++        (LP: #1526779)
++      . [regression] Mir servers just segfault just after "Selected driver:"
++        instead of reporting exceptions (LP: #1528135)
++      . Setting a surface keymap crashes in xkbcommon:
++        xkb_keymap_new_from_names() (LP: #1530946)
++      . [enhancement] Implement support for QWindow::visibility set to
++        Automatic (LP: #1535397)
++      . ProgramOption::parse_file() reports problems to cerr (LP: #1190165)
++      . Dynamic double buffering fails to detect inertial dash scrolling as
++        slow; and stutters instead of scaling up to triple buffers.
++        (LP: #1476201)
++      . CI Failures: ClientLatency.throttled_input_rate_yields_lower_latency
++        (LP: #1509291)
++      . [regression] Nested servers can select wrong platform (LP: #1515558)
++      . "there seems to be missing RTTI information when linking with UBSan
++        enabled" (LP: #1521930)
        . Mir threadsanitizer build fails with GCC (LP: #1522581)
--      . After "make install" mir_demo_server cannot
--        find shared object file in /usr/local/lib (LP: #1522836)
--      . Fixed a test in TestClientInput (LP: #1523965)
--      . Mir servers choose graphics-dummy (or no driver at all)
++      . After "make install" mir_demo_server cannot find shared object file in
++        /usr/local/lib (LP: #1522836)
++      . [testfail] Intermittent failure in TestClientInput.clients_receive_
++        pointer_within_coordinate_system_of_window (LP: #1523965)
++      . [regression] [ FAILED ]
++        ClientSurfaceEvents.surface_receives_output_event_on_creation
++        (LP: #1524161)
++      . [ FAILED ] TestClientInput.scene_obscure_motion_events_by_stacking
++        (LP: #1524230)
++      . There's something racy in ServerDisconnect.is_detected_by_client
++        (LP: #1526248)
++      . Mir clients leak all driver modules including the unused ones, keeping
++        them resident (LP: #1527449)
++      . [regression] Mir servers choose graphics-dummy (or no driver at all)
          over mesa-kms on a desktop (LP: #1528082)
--      . Function mir_event_get_close_surface_event is never used (LP: #1447690)
--      . mir::input::Surface::consume(MirEvent const& event)
--        should not take a reference to an opaque type (LP: #1450797)
--      . lintian: E: mir-doc: privacy-breach-logo (LP: #1483471)
--
++      . Function 'mir_event_get_close_surface_event' is never used
++        (LP: #1447690)
++      . mir::input::Surface::consume(MirEvent const& event) should not take a
++        reference to an opaque type (LP: #1450797)
++      . lintian: E: mir-doc: privacy-breach-logo
++        usr/share/doc/mir-doc/html/cppguide/index.html
++        (http://www.google.com/favicon.ico) (LP: #1483471)
++      . lintian: W: mir-doc: embedded-javascript-library
++        usr/share/doc/mir-doc/html/jquery.js please use libjs-jquery
++        (LP: #1483472)
++      . lintian: E: mir-test-tools:
++        arch-dependent-file-not-in-arch-specific-directory (LP: #1483475)
++      . incorrect reporting in mf::SessionMediator::release_buffer_stream()
++        (LP: #1499777)
++      . [testsfail] Segmentation fault SystemCompositorWindowManager.
++        if_a_surface_posts_client_gets_focus (LP: #1522356)
    [ CI Train Bot ]
    * No-change rebuild.
 === modified file 'src/client/probing_client_platform_factory.cpp'
 --- src/client/probing_client_platform_factory.cpp	2016-01-20 23:59:18 +0000
 +++ src/client/probing_client_platform_factory.cpp	2016-02-04 21:06:45 +0000
@@ -31,6 +31,25 @@
      // than it takes to choose the right one. So this list is local:
      std::vector<std::shared_ptr<mir::SharedLibrary>> platform_modules;
++    auto const module_selector = [context, &platform_modules](std::shared_ptr<mir::SharedLibrary> const& module)
++    {
++        try
++        {
++            auto probe = module->load_function<ClientPlatformProbe>("is_appropriate_module", CLIENT_PLATFORM_VERSION);
++            if (probe(context))
++            {
++                platform_modules.push_back(module);
++                return Selection::quit;
++            }
++        }
++        catch (std::runtime_error const&)
++        {
++            // Assume we were handed a SharedLibrary that's not a client platform module of the correct vintage.
++        }
++
++        return Selection::persist;
++    };
++
      if (!platform_overrides.empty())
+     {
          // Even forcing a choice, platform is only loaded on demand. It's good
@@ -39,37 +58,19 @@
          // if you really wanted to.
          for (auto const& platform : platform_overrides)
--            platform_modules.push_back(
--                std::make_shared<mir::SharedLibrary>(platform));
++            module_selector(std::make_shared<mir::SharedLibrary>(platform));
+     }
      else
+     {
          for (auto const& path : platform_paths)
--        {
--            // This is sub-optimal. We shouldn't need to have all drivers
--            // loaded simultaneously, but we do for now due to this API:
--            auto modules = mir::libraries_for_path(path,
--                                               *shared_library_prober_report);
--            for (auto const& module : modules)
--                 platform_modules.push_back(module);
--        }
++            select_libraries_for_path(path, module_selector, *shared_library_prober_report);
+     }
      for (auto& module : platform_modules)
+     {
--        try
--        {
--            auto probe = module->load_function<mir::client::ClientPlatformProbe>("is_appropriate_module", CLIENT_PLATFORM_VERSION);
--            if (probe(context))
--            {
--                auto factory = module->load_function<mir::client::CreateClientPlatform>("create_client_platform", CLIENT_PLATFORM_VERSION);
--                return factory(context);
--            }
--        }
--        catch(std::runtime_error const&)
--        {
--            // We were handed a SharedLibrary that's not a client platform module?
--        }
++        auto factory = module->load_function<CreateClientPlatform>("create_client_platform", CLIENT_PLATFORM_VERSION);
++        return factory(context);
+     }
++
      BOOST_THROW_EXCEPTION(std::runtime_error{"No appropriate client platform module found"});
+ }
 === modified file 'src/common/sharedlibrary/CMakeLists.txt'
 --- src/common/sharedlibrary/CMakeLists.txt	2016-01-20 23:59:18 +0000
 +++ src/common/sharedlibrary/CMakeLists.txt	2016-02-04 21:06:45 +0000
@@ -17,7 +17,7 @@
  add_library(mirsharedsharedlibrary OBJECT
    module_deleter.cpp
    shared_library.cpp
--  shared_library_prober.cpp
++  shared_library_prober.cpp ${PROJECT_SOURCE_DIR}/src/include/common/mir/shared_library_prober.h
+ )
  list(APPEND MIR_COMMON_SOURCES
 === modified file 'src/common/sharedlibrary/shared_library_prober.cpp'
 --- src/common/sharedlibrary/shared_library_prober.cpp	2016-01-20 23:59:18 +0000
 +++ src/common/sharedlibrary/shared_library_prober.cpp	2016-02-04 21:06:45 +0000
@@ -63,8 +63,10 @@
+ }
+ }
--std::vector<std::shared_ptr<mir::SharedLibrary>>
--mir::libraries_for_path(std::string const& path, mir::SharedLibraryProberReport& report)
++void mir::select_libraries_for_path(
++    std::string const& path,
++    std::function<Selection(std::shared_ptr<mir::SharedLibrary> const&)> const& selector,
++    mir::SharedLibraryProberReport& report)
+ {
      report.probing_path(path);
      // We use the error_code overload because we want to throw a std::system_error
@@ -87,20 +89,33 @@
      std::sort(libraries.begin(), libraries.end(), &greater_soname_version);
--    std::vector<std::shared_ptr<mir::SharedLibrary>> result;
--
      for(auto& lib : libraries)
+     {
          try
+         {
              report.loading_library(lib);
--            result.emplace_back(std::make_shared<mir::SharedLibrary>(lib.string()));
++            auto const shared_lib = std::make_shared<mir::SharedLibrary>(lib.string());
++
++            if (selector(shared_lib) == Selection::quit)
++                return;
+         }
          catch (std::runtime_error const& err)
+         {
              report.loading_failed(lib, err);
+         }
+     }
++}
++
++std::vector<std::shared_ptr<mir::SharedLibrary>>
++mir::libraries_for_path(std::string const& path, mir::SharedLibraryProberReport& report)
++{
++    std::vector<std::shared_ptr<mir::SharedLibrary>> result;
++
++    select_libraries_for_path(
++        path,
++        [&](std::shared_ptr<mir::SharedLibrary> const& shared_lib)
++            { result.push_back(shared_lib); return Selection::persist; },
++        report);
      return result;
+ }
 === modified file 'src/common/symbols.map'
 --- src/common/symbols.map	2016-01-27 19:42:57 +0000
 +++ src/common/symbols.map	2016-02-04 21:06:45 +0000
@@ -201,7 +201,7 @@
    local: *;
  } MIR_COMMON_5;
--MIR_COMMON_5v19 { # New functions in Mir 0.19
++MIR_COMMON_5v19 { # New functions in Mir 0.19.0
    global:
      extern "C++" {
        typeinfo?for?mir::logging::SharedLibraryProberReport;
@@ -211,3 +211,10 @@
        mir::detail::libname_impl*;
      };
  } MIR_COMMON_5.1;
++
++MIR_COMMON_0.19.1 { # New functions in Mir 0.19.1
++  global:
++    extern "C++" {
++      mir::select_libraries_for_path*;
++    };
++} MIR_COMMON_5v19;  # <- Note Mir 0.19.0 used the wrong syntax
 === modified file 'src/include/common/mir/shared_library_prober.h'
 --- src/include/common/mir/shared_library_prober.h	2015-02-22 07:46:25 +0000
 +++ src/include/common/mir/shared_library_prober.h	2016-02-04 21:06:45 +0000
@@ -30,6 +30,14 @@
  class SharedLibrary;
  std::vector<std::shared_ptr<SharedLibrary>> libraries_for_path(std::string const& path, SharedLibraryProberReport& report);
++
++// The selector can tell select_libraries_for_path() to persist or quit after each library
++enum class Selection { persist, quit };
++
++void select_libraries_for_path(
++    std::string const& path,
++    std::function<Selection(std::shared_ptr<SharedLibrary> const&)> const& selector,
++    SharedLibraryProberReport& report);
+ }
 === modified file 'src/server/compositor/multi_threaded_compositor.cpp'
 --- src/server/compositor/multi_threaded_compositor.cpp	2016-01-20 23:59:18 +0000
 +++ src/server/compositor/multi_threaded_compositor.cpp	2016-02-04 21:06:45 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright © 2013-2015 Canonical Ltd.
++ * Copyright © 2013-2016 Canonical Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 3,
@@ -110,81 +110,82 @@
          started.set_value();
--        std::unique_lock<std::mutex> lock{run_mutex};
--        while (running)
++        try
+         {
--            /* Wait until compositing has been scheduled or we are stopped */
--            run_cv.wait(lock, [&]{ return (frames_scheduled > 0) || !running; });
--
--            /*
--             * Check if we are running before compositing, since we may have
--             * been stopped while waiting for the run_cv above.
--             */
--            if (running)
++            std::unique_lock<std::mutex> lock{run_mutex};
++            while (running)
+             {
--                /*
--                 * Each surface could have a number of frames ready in its buffer
--                 * queue. And we need to ensure that we render all of them so that
--                 * none linger in the queue indefinitely (seen as input lag).
--                 * frames_scheduled indicates the number of frames that are scheduled
--                 * to ensure all surfaces' queues are fully drained.
--                 */
--                frames_scheduled--;
--                lock.unlock();
--
--                for (auto& tuple : compositors)
--                {
--                    auto& compositor = std::get<1>(tuple);
--                    compositor->composite(scene->scene_elements_for(compositor.get()));
--                }
--                group.post();
--
--                /*
--                 * "Predictive bypass" optimization: If the last frame was
--                 * bypassed/overlayed or you simply have a fast GPU, it is
--                 * beneficial to sleep for most of the next frame. This reduces
--                 * the latency between snapshotting the scene and post()
--                 * completing by almost a whole frame.
--                 */
--                auto delay = force_sleep >= std::chrono::milliseconds::zero() ?
--                             force_sleep : group.recommended_sleep();
--                std::this_thread::sleep_for(delay);
--
--                lock.lock();
--
--                /*
--                 * Note the compositor may have chosen to ignore any number
--                 * of renderables and not consumed buffers from them. So it's
--                 * important to re-count number of frames pending, separately
--                 * to the initial scene_elements_for()...
--                 */
--                int pending = 0;
--                for (auto& compositor : compositors)
--                {
--                    auto const comp_id = std::get<1>(compositor).get();
--                    int pend = scene->frames_pending(comp_id);
--                    if (pend > pending)
--                        pending = pend;
--                }
--
--                if (pending > frames_scheduled)
--                    frames_scheduled = pending;
++                /* Wait until compositing has been scheduled or we are stopped */
++                run_cv.wait(lock, [&]{ return (frames_scheduled > 0) || !running; });
++
++                /*
++                 * Check if we are running before compositing, since we may have
++                 * been stopped while waiting for the run_cv above.
++                 */
++                if (running)
++                {
++                    /*
++                     * Each surface could have a number of frames ready in its buffer
++                     * queue. And we need to ensure that we render all of them so that
++                     * none linger in the queue indefinitely (seen as input lag).
++                     * frames_scheduled indicates the number of frames that are scheduled
++                     * to ensure all surfaces' queues are fully drained.
++                     */
++                    frames_scheduled--;
++                    lock.unlock();
++
++                    for (auto& tuple : compositors)
++                    {
++                        auto& compositor = std::get<1>(tuple);
++                        compositor->composite(scene->scene_elements_for(compositor.get()));
++                    }
++                    group.post();
++
++                    /*
++                     * "Predictive bypass" optimization: If the last frame was
++                     * bypassed/overlayed or you simply have a fast GPU, it is
++                     * beneficial to sleep for most of the next frame. This reduces
++                     * the latency between snapshotting the scene and post()
++                     * completing by almost a whole frame.
++                     */
++                    auto delay = force_sleep >= std::chrono::milliseconds::zero() ?
++                                 force_sleep : group.recommended_sleep();
++                    std::this_thread::sleep_for(delay);
++
++                    lock.lock();
++
++                    /*
++                     * Note the compositor may have chosen to ignore any number
++                     * of renderables and not consumed buffers from them. So it's
++                     * important to re-count number of frames pending, separately
++                     * to the initial scene_elements_for()...
++                     */
++                    int pending = 0;
++                    for (auto& compositor : compositors)
++                    {
++                        auto const comp_id = std::get<1>(compositor).get();
++                        int pend = scene->frames_pending(comp_id);
++                        if (pend > pending)
++                            pending = pend;
++                    }
++
++                    if (pending > frames_scheduled)
++                        frames_scheduled = pending;
++                }
+             }
+         }
++        catch (...)
++        {
++            mir::terminate_with_current_exception();
++        }
+     }
      catch(...)
+     {
--        try
--        {
--            //Move the promise so that the promise destructor occurs here rather than in the thread
--            //destroying CompositingFunctor, mostly to appease TSan
--            auto promise = std::move(started);
--            promise.set_exception(std::current_exception());
--        }
--        catch(...)
--        {
--        }
--        mir::terminate_with_current_exception();
++        started.set_exception(std::current_exception());
++
++        //Move the promise so that the promise destructor occurs here rather than in the thread
++        //destroying CompositingFunctor, mostly to appease TSan
++        auto promise = std::move(started);
+     }
      void schedule_compositing(int num_frames)
@@ -209,6 +210,8 @@
+     {
          if (started_future.wait_for(10s) != std::future_status::ready)
              BOOST_THROW_EXCEPTION(std::runtime_error("Compositor thread failed to start"));
++
++        started_future.get();
+     }
  private:
@@ -273,7 +276,7 @@
  void mc::MultiThreadedCompositor::start()
+ {
      auto stopped = CompositorState::stopped;
--
++
      if (!state.compare_exchange_strong(stopped, CompositorState::starting))
          return;
@@ -281,7 +284,7 @@
      /* To cleanup state if any code below throws */
      auto cleanup_if_unwinding = on_unwind(
--        [this]{ destroy_compositing_threads(); });
++        [this]{ destroy_compositing_threads(); state = CompositorState::stopped; });
      create_compositing_threads();
@@ -291,6 +294,8 @@
      /* Optional first render */
      if (compose_on_start)
          schedule_compositing(1);
++
++    state = CompositorState::started;
+ }
  void mc::MultiThreadedCompositor::stop()
@@ -300,8 +305,6 @@
      if (!state.compare_exchange_strong(started, CompositorState::stopping))
          return;
--    state = CompositorState::stopping;
--
      /* To cleanup state if any code below throws */
      auto cleanup_if_unwinding = on_unwind(
          [this]{ state = CompositorState::started; });
@@ -314,6 +317,10 @@
      // If the compositor is restarted we've likely got clients blocked
      // so we will need to schedule compositing immediately
      compose_on_start = true;
++
++    report->stopped();
++
++    state = CompositorState::stopped;
+ }
  void mc::MultiThreadedCompositor::create_compositing_threads()
@@ -333,8 +340,6 @@
      for (auto& functor : thread_functors)
          functor->wait_until_started();
--
--    state = CompositorState::started;
+ }
  void mc::MultiThreadedCompositor::destroy_compositing_threads()
@@ -347,8 +352,4 @@
      thread_functors.clear();
      futures.clear();
--
--    report->stopped();
--
--    state = CompositorState::stopped;
+ }
 === modified file 'src/server/input/default_input_manager.cpp'
 --- src/server/input/default_input_manager.cpp	2016-01-20 23:59:18 +0000
 +++ src/server/input/default_input_manager.cpp	2016-02-04 21:06:45 +0000
@@ -70,10 +70,14 @@
      if (!state.compare_exchange_strong(expected, State::starting))
          return;
--    auto reset_to_stopped_on_failure = on_unwind([this]{state = State::stopped;});
++    auto reset_to_stopped_on_failure = on_unwind([this]
++        {
++            auto expected = State::starting;
++            state.compare_exchange_strong(expected, State::stopped);
++        });
      multiplexer->add_watch(queue);
--    auto unregister_queue = on_unwind([this]{multiplexer->remove_watch(queue);});
++    auto unregister_queue = on_unwind([this]{ if (state == State::starting) multiplexer->remove_watch(queue);});
      auto started_promise = std::make_shared<std::promise<void>>();
@@ -114,7 +118,11 @@
      if (!state.compare_exchange_strong(expected, State::stopping))
          return;
--    auto reset_to_started_on_failure = on_unwind([this]{state = State::started;});
++    auto reset_to_started_on_failure = on_unwind([this]
++        {
++            auto expected = State::stopping;
++            state.compare_exchange_strong(expected, State::started);
++        });
      auto const stop_promise = std::make_shared<std::promise<void>>();
@@ -129,7 +137,7 @@
      auto restore_platforms = on_unwind(
          [this]
+         {
--            queue->enqueue([this](){ start_platforms(); });
++            if (state == State::stopping) queue->enqueue([this](){ start_platforms(); });
          });
      multiplexer->remove_watch(queue);
 === modified file 'tests/acceptance-tests/test_prompt_session_client_api.cpp'
 --- tests/acceptance-tests/test_prompt_session_client_api.cpp	2016-01-20 23:59:18 +0000
 +++ tests/acceptance-tests/test_prompt_session_client_api.cpp	2016-02-04 21:06:45 +0000
@@ -383,7 +383,7 @@
      mir_prompt_session_release_sync(prompt_session);
+ }
--TEST_F(PromptSessionClientAPI, client_pid_is_associated_with_session)
++TEST_F(PromptSessionClientAPI, DISABLED_client_pid_is_associated_with_session)
+ {
      connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
 === modified file 'tests/unit-tests/compositor/test_multi_threaded_compositor.cpp'
 --- tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2016-01-20 23:59:18 +0000
 +++ tests/unit-tests/compositor/test_multi_threaded_compositor.cpp	2016-02-04 21:06:45 +0000
@@ -889,7 +889,7 @@
      compositor.stop();
+ }
--TEST(MultiThreadedCompositor, does_not_block_in_start_when_compositor_thread_fails)
++TEST(MultiThreadedCompositor, when_compositor_thread_fails_start_reports_error)
+ {
      using namespace testing;
      unsigned int const nbuffers{3};
@@ -899,22 +899,13 @@
      auto db_compositor_factory = std::make_shared<mtd::NullDisplayBufferCompositorFactory>();
      auto mock_report = std::make_shared<testing::NiceMock<mtd::MockCompositorReport>>();
--    // Ignore SIGTERM. We must keep ignoring SIGTERM until the compositor is
--    // destroyed/stopped (hence sigterm_raii must be created before the compositor),
--    // since even after compositor.start() has returned because of an error the
--    // compositing threads may not have finished and could emit SIGTERM.
--    sighandler_t old_sigterm_handler = nullptr;
--    auto const sigterm_raii = mir::raii::paired_calls(
--        [&] { old_sigterm_handler = signal(SIGTERM, SIG_IGN); },
--        [&] { signal(SIGTERM, old_sigterm_handler); });
--
      mc::MultiThreadedCompositor compositor{
          display, stub_scene, db_compositor_factory, mock_display_listener, mock_report, default_delay, true};
      EXPECT_CALL(*mock_display_listener, add_display(_))
          .WillRepeatedly(Throw(std::runtime_error("Failed to add display")));
--    compositor.start();
++    EXPECT_THROW(compositor.start(), std::runtime_error);
+ }
  //LP: 1481418