int _glfwPlatformInit(void) { int error; _glfw.mir.connection = mir_connect_sync(NULL, __PRETTY_FUNCTION__); if (!mir_connection_is_valid(_glfw.mir.connection)) { _glfwInputError(GLFW_PLATFORM_ERROR, "Mir: Unable to connect to Server"); return GL_FALSE; } _glfw.mir.display = mir_connection_get_egl_native_display(_glfw.mir.connection); if (!_glfwInitContextAPI()) return GL_FALSE; _glfwInitTimer(); _glfwInitJoysticks(); _glfw.mir.event_queue = calloc(1, sizeof(EventQueue)); _glfwInitEventQueue(_glfw.mir.event_queue); error = pthread_mutex_init(&_glfw.mir.event_mutex, NULL); if (error) { _glfwInputError(GLFW_PLATFORM_ERROR, "Mir: Failed to create Event Mutex Error: %i\n", error); return GL_FALSE; } return GL_TRUE; }
bool uamc::Instance::connect(std::string const& application_name) { auto mir_connection = mir_connect_sync(NULL, application_name.c_str()); // mir_connect_sync() always returns a connection object, even in case // of a failed connection. We need to release this object in all cases. con = ConnectionPtr(mir_connection, [](MirConnection *c) { mir_connection_release(c); }); return mir_connection_is_valid(mir_connection); }
MirDisplayConnection::MirDisplayConnection() : connection_(nullptr), output_id_(-1), vertical_resolution_(0), horizontal_resolution_(0) { auto xdg_runtime_dir = ::getenv("XDG_RUNTIME_DIR"); if (!xdg_runtime_dir) BOOST_THROW_EXCEPTION(std::runtime_error("Failed to find XDG_RUNTIME_DIR")); std::string socket_path = xdg_runtime_dir; socket_path += "/mir_socket"; connection_ = mir_connect_sync(socket_path.c_str(), "anbox"); if (!mir_connection_is_valid(connection_)) { std::string msg; msg += "Failed to connect with Mir server: "; msg += mir_connection_get_error_message(connection_); BOOST_THROW_EXCEPTION(std::runtime_error(msg.c_str())); } mir_connection_set_display_config_change_callback( connection_, [](MirConnection *connection, void *context) { auto thiz = reinterpret_cast<MirDisplayConnection *>(context); DEBUG(""); }, this); MirDisplayConfiguration *display_config = mir_connection_create_display_config(connection_); const MirDisplayOutput *output = find_active_output(display_config); if (!output) BOOST_THROW_EXCEPTION( std::runtime_error("Failed to find active output display")); DEBUG("Selecting output id %d", output->output_id); output_id_ = output->output_id; const MirDisplayMode *mode = &output->modes[output->current_mode]; vertical_resolution_ = mode->vertical_resolution; horizontal_resolution_ = mode->horizontal_resolution; mir_display_config_destroy(display_config); }
int _glfwPlatformInit(void) { int error; _glfw.mir.connection = mir_connect_sync(NULL, __PRETTY_FUNCTION__); if (!mir_connection_is_valid(_glfw.mir.connection)) { _glfwInputError(GLFW_PLATFORM_ERROR, "Mir: Unable to connect to server: %s", mir_connection_get_error_message(_glfw.mir.connection)); return GLFW_FALSE; } _glfw.mir.display = mir_connection_get_egl_native_display(_glfw.mir.connection); createKeyTables(); if (!_glfwInitThreadLocalStoragePOSIX()) return GLFW_FALSE; if (!_glfwInitJoysticksLinux()) return GLFW_FALSE; _glfwInitTimerPOSIX(); // Need the default conf for when we set a NULL cursor _glfw.mir.defaultConf = mir_cursor_configuration_from_name(mir_default_cursor_name); _glfw.mir.disabledConf = mir_cursor_configuration_from_name(mir_disabled_cursor_name); _glfw.mir.eventQueue = calloc(1, sizeof(EventQueue)); _glfwInitEventQueueMir(_glfw.mir.eventQueue); error = pthread_mutex_init(&_glfw.mir.eventMutex, NULL); if (error) { _glfwInputError(GLFW_PLATFORM_ERROR, "Mir: Failed to create event mutex: %s", strerror(error)); return GLFW_FALSE; } _glfwPollMonitorsMir(); return GLFW_TRUE; }
// Regression test for LP:#1340669 // Test is not deterministic since we are testing a race, but failure can be // reproduced easily with repeated runs. TEST_F(ClientWithCustomDisplayConfiguration, does_not_deadlock_server_with_existing_client_when_disconnecting) { auto second_connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__); auto second_surface = mtf::make_any_surface(connection); ASSERT_TRUE(mir_surface_is_valid(second_surface)); auto configuration = mir_connection_create_display_config(connection); mir_wait_for(mir_connection_apply_display_config(connection, configuration)); EXPECT_STREQ("", mir_connection_get_error_message(connection)); mir_display_config_destroy(configuration); mir_connection_release(second_connection); // Server (and therefore the test) will deadlock and won't be able to // shut down without the fix. It's not ideal to deadlock on test failure, // but it's the best check we have at the moment. }
GdkDisplay * _gdk_mir_display_open (const gchar *display_name) { MirConnection *connection; MirPixelFormat sw_pixel_format, hw_pixel_format; GdkMirDisplay *display; //g_printerr ("gdk_mir_display_open\n"); connection = mir_connect_sync (NULL, "GDK-Mir"); if (!connection) return NULL; if (!mir_connection_is_valid (connection)) { g_printerr ("Failed to connect to Mir: %s\n", mir_connection_get_error_message (connection)); mir_connection_release (connection); return NULL; } get_pixel_formats (connection, &sw_pixel_format, &hw_pixel_format); if (sw_pixel_format == mir_pixel_format_invalid || hw_pixel_format == mir_pixel_format_invalid) { g_printerr ("Mir display does not support required pixel formats\n"); mir_connection_release (connection); return NULL; } display = g_object_new (GDK_TYPE_MIR_DISPLAY, NULL); display->connection = connection; GDK_DISPLAY (display)->device_manager = _gdk_mir_device_manager_new (GDK_DISPLAY (display)); display->screen = _gdk_mir_screen_new (GDK_DISPLAY (display)); display->sw_pixel_format = sw_pixel_format; display->hw_pixel_format = hw_pixel_format; g_signal_emit_by_name (display, "opened"); return GDK_DISPLAY (display); }
bool NativeStateMir::init_display() { struct sigaction sa; sa.sa_handler = &NativeStateMir::quit_handler; sa.sa_flags = 0; sigemptyset(&sa.sa_mask); sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); mir_connection_ = mir_connect_sync(NULL, "glmark2"); if (!mir_connection_is_valid(mir_connection_)) { Log::error("Couldn't connect to the Mir display server\n"); return false; } return true; }
int _glfwPlatformInit(void) { _glfw.mir.connection = mir_connect_sync(NULL, __PRETTY_FUNCTION__); if (!mir_connection_is_valid(_glfw.mir.connection)) { _glfwInputError(GLFW_PLATFORM_ERROR, "Mir: Unable to connect to Server"); return GL_FALSE; } _glfw.mir.display = mir_connection_get_egl_native_display(_glfw.mir.connection); if (!_glfwInitContextAPI()) return GL_FALSE; _glfwInitTimer(); _glfwInitJoysticks(); return GL_TRUE; }
int Mir_VideoInit(_THIS, SDL_PixelFormat *vformat) { this->hidden->connection = mir_connect_sync(NULL, __PRETTY_FUNCTION__); if (!mir_connection_is_valid(this->hidden->connection)) { SDL_SetError("Failed to connect to the Mir Server: %s", mir_connection_get_error_message(this->hidden->connection)); mir_connection_release(this->hidden->connection); return -1; } MirPixelFormat formats[mir_pixel_formats]; Uint32 n_formats; mir_connection_get_available_surface_formats (this->hidden->connection, formats, mir_pixel_formats, &n_formats); if (n_formats == 0 || formats[0] == mir_pixel_format_invalid) { SDL_SetError("No valid pixel formats found"); mir_connection_release(this->hidden->connection); return -1; } this->hidden->pixel_format = formats[0]; vformat->BitsPerPixel = MIR_BYTES_PER_PIXEL(this->hidden->pixel_format) * 8; Mir_InitQueue(this->hidden->buffer_queue); Mir_ModeListUpdate(this); mir_connection_set_display_config_change_callback(this->hidden->connection, Mir_DisplayConfigChanged, this); this->info.wm_available = 1; return 0; }
void start_session(const char* server, const char* name, MirDemoState* mcd) { // Call mir_connect synchronously mcd->connection = mir_connect_sync(server, name); // We expect a connection handle; // we expect it to be valid; and, // we don't expect an error description assert(mcd->connection != NULL); assert(mir_connection_is_valid(mcd->connection)); assert(strcmp(mir_connection_get_error_message(mcd->connection), "") == 0); printf("%s: Connected\n", name); // We can query information about the platform we're running on { MirPlatformPackage platform_package; platform_package.data_items = -1; platform_package.fd_items = -1; mir_connection_get_platform(mcd->connection, &platform_package); assert(0 <= platform_package.data_items); assert(0 <= platform_package.fd_items); } }
TEST_F(UnresponsiveClient, does_not_hang_server) { mt::CrossProcessAction server_send_events; mt::CrossProcessAction client_connect; mt::CrossProcessAction client_release; mt::CrossProcessAction server_finish; SessionListener sessions; init_server([&] { server.override_the_session_listener([&] { return mt::fake_shared(sessions); }); }); run_in_server([&] { mt::AutoJoinThread t{ [&] { server_send_events.exec([&] { for (int i = 0; i < 1000; ++i) { sessions.for_each( [i] (std::shared_ptr<ms::Session> const& session) { session->default_surface()->resize({i + 1, i + 1}); }); } }); }}; server_finish.exec([]{}); }); auto const client_code = [&] { MirConnection* connection = nullptr; MirSurface* surface = nullptr; client_connect.exec([&] { connection = mir_connect_sync(mir_test_socket, __PRETTY_FUNCTION__); surface = mtf::make_any_surface(connection); }); client_release.exec([&] { // We would normally explicitly release the surface at this // point. However, because we have been filling the server // send socket buffer, releasing the surface may cause the // server to try to write to a full socket buffer when // responding, leading the server to believe that the client // is blocked, and causing a premature client disconnection. mir_connection_release(connection); }); }; auto client_process = new_client_process(client_code); if (is_test_process()) { client_connect(); kill(client_pid(), SIGSTOP); try { server_send_events(std::chrono::seconds{10}); } catch(...) { ADD_FAILURE() << "Server blocked while sending events"; } kill(client_pid(), SIGCONT); client_release(); server_finish(); auto const result = client_process->wait_for_termination(); EXPECT_THAT(result.exit_code, testing::Eq(EXIT_SUCCESS)); } }