From 3720982bd40ee482b694f73d611a7432aa26a259 Mon Sep 17 00:00:00 2001 From: Thomas Sachau Date: Sun, 28 Dec 2014 09:43:45 +0000 Subject: [PATCH] Add missing patch Package-Manager: portage-2.2.15/cvs/Linux x86_64 Manifest-Sign-Key: 0x35899067 --- dev-libs/efl/ChangeLog | 6 +- dev-libs/efl/Manifest | 13 +- ...2-lauch_via_logind_or_root_privilege.patch | 960 ++++++++++++++++++ 3 files changed, 972 insertions(+), 7 deletions(-) create mode 100644 dev-libs/efl/files/efl-1.12.2-lauch_via_logind_or_root_privilege.patch diff --git a/dev-libs/efl/ChangeLog b/dev-libs/efl/ChangeLog index 5b841c225bd3..737aa9cac632 100644 --- a/dev-libs/efl/ChangeLog +++ b/dev-libs/efl/ChangeLog @@ -1,6 +1,10 @@ # ChangeLog for dev-libs/efl # Copyright 1999-2014 Gentoo Foundation; Distributed under the GPL v2 -# $Header: /var/cvsroot/gentoo-x86/dev-libs/efl/ChangeLog,v 1.21 2014/12/27 19:40:03 tommy Exp $ +# $Header: /var/cvsroot/gentoo-x86/dev-libs/efl/ChangeLog,v 1.22 2014/12/28 09:43:36 tommy Exp $ + + 28 Dec 2014; Thomas Sachau (Tommy[D]) + +files/efl-1.12.2-lauch_via_logind_or_root_privilege.patch: + Add missing patch 27 Dec 2014; Thomas Sachau (Tommy[D]) efl-1.12.2.ebuild: Re-add missing ~arm keyword diff --git a/dev-libs/efl/Manifest b/dev-libs/efl/Manifest index 79cdeba74049..7d4535da38aa 100644 --- a/dev-libs/efl/Manifest +++ b/dev-libs/efl/Manifest @@ -1,6 +1,7 @@ -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 +AUX efl-1.12.2-lauch_via_logind_or_root_privilege.patch 27159 SHA256 601fffd6073eb09d7fe9173cb782f8b8f62a59f5f82b8be3a677728bf6df8b99 SHA512 30538186e6691131a5060337518db8704d8340e43d77e3392a863b70ff54446ea6edd0030298b887f109db204a3b1ec7ecf14d9c7f5ea3ca37fc2797aaa010b7 WHIRLPOOL 66293507e0645b828e54c169d0bb095c66a46128518e38add0cc09d4746c81b540eead451ed52b9a36514bc00481e33baa49cbbcd54acddacf60b125cf3cf3fd DIST efl-1.10.1.tar.bz2 38538939 SHA256 203e6455a98b89c36e5ad838ea7dab855d744b8253843f468b72a925a058499f SHA512 96da96af331d7acc96f18dacd21c5756455a059244438daba2c9d6aeb5c991cdca5013ef7e672bae0bbe69a755c20eee8bb2051dbb372495e77ce943b57c16df WHIRLPOOL 76448b1077a81b698586129dc3ba033f82c6b0551edb92202c4cbbfd816e890390075df2d64f5e2c5fb7834bd5610628f5e63644ef73174d5e6680a973afa1f7 DIST efl-1.11.2.tar.bz2 40950173 SHA256 b8646edbcfeb28da1447e072fa80b39546be18023903f7e5cf63c06784abc759 SHA512 4ffabe3b5ec704bcbff3d47c597fe8f27c03a6d6f43bd1f85add4667f1b946ac00d93a71cebdb31d46f5dbc6429d3100932d5011c8e7ef83ada73f19a24d1f04 WHIRLPOOL 69a858b29a1f4a7a0104fb167a738e9109cde78ba0107016814699f6f9a7757a7a931a5625db388a7550f5e0158c9765c3b23c47bb52c1e089814336310a7212 DIST efl-1.12.2.tar.bz2 46808743 SHA256 aa1a6b95de3d92dda819e1245254e3d9c0d68f77d27d89afb1ae3f2244c0bf0c SHA512 8d137a4cd7a11f102b949bfc7047b3be870df6d7ede72765b005914729bf291f59d1f70b69ab7fbbd3328975068aa5ded2f10e556a7d4f7c31aedfcd0d7340e9 WHIRLPOOL 531f81000dafbd88dacd24588a3832a7c2afccf466d070d78d86641b8c0e3e64854c4f9d8dfe46ab0fb84fd6890ac6eb3e8e63d02ef58bedf88c265412f3ddf7 @@ -15,14 +16,14 @@ EBUILD efl-1.8.5.ebuild 6334 SHA256 3cdfc4077f960364441316485b869114a5ef3e26fdcb EBUILD efl-1.8.6.ebuild 6336 SHA256 ba1bca73166be583857a868768bd3dae143c5302d6d0fafee0b37a6a32b70395 SHA512 7314e95d7b01e25c71caecb8b9815c8b15aa0ade1ef0d7b7e09e31f14faa2cd9167ec93fe866248b1e8bc9f7a473cb859ab75bfb99b7182feb345ecc12915f80 WHIRLPOOL 149f79007b2122f88026096e802ec56341c6b4f0d4e6bc5b8048ad27c236be905a597ac320d348b383e9f4dd88dc4ceea93e675a69b18f9708420ef4a5dbd5b4 EBUILD efl-1.9.4.ebuild 6482 SHA256 98acd2b86c2365d14b28f2530fa682d5660b095d123525906177d79e73bf49da SHA512 4700f46497e3da31553015977491706d8c42b2a096a00cd0401bce9e684f2753425f4b172dad2bf21c470d42bdd4d09528083581b69eae6a480b5d6085408654 WHIRLPOOL 1cc7bac952d53e1bf6a615141e95d39dbd1e4ccef4fea8079a86058954f9fe2006a717074379573482e9acc157d8ffec4667a174bd6f3b64a8b6879f47afe1c9 EBUILD efl-1.9.5.ebuild 6482 SHA256 9091681f607ed2582d5e70ac9b5970b42e5e97dc705cad5571ee70518810352d SHA512 3494f64f256349551c01ec45fc79fbc04bd1017a3daeb85c9dd87021df1a0db5fab1786cf7faeef09bf7ff95acfd17c4bffdcff4058b11ccf60e73acde8b5e1c WHIRLPOOL b4996d1435745640ebfa27655c95b945dd9e572771e9baf7b7f71466f7cadae76d6c9c889894d3b048e1edf3e1bfa1bd2f1cd018add706bf719db6c6cd5fa2f3 -MISC ChangeLog 3808 SHA256 bacd9137549255ec923fa52d9da980c77fd0b7732ca841fbb0c141140fe4e424 SHA512 1a16957157a4e285c7973ba93d6b6cb0977ac32a1d4a5821058f981e4971f1f354e094b02084004a1f8885d1a9e2265049ffcd1e0ac93791f516617303dccf0d WHIRLPOOL 4258acf61089641a2299ba78bcc3130a7467d07aa80c87f0bc1cbca24f3680ec85f0536933e3b95d64df12e77ec53ac5c1a1ed873879f743c05b6011c7f6c815 +MISC ChangeLog 3950 SHA256 bbd5b360da1b82487704882096b7f04adc73d71128661bd4e20a14ebc293d518 SHA512 705cb44b95bf6e0168eb9629a59e7028f7efeed48cf375a794247ddfffc2e8dcfc55ae2aab82e8df867cdc9d57e5336c781e05085f008b86d716fd6b9d709bcb WHIRLPOOL d8cb249d1f98f2180bdf8858a33f821cb39be1443162e4142439d68a28e271f403d55c0d1037d088c447b879fdb5c27c685127b0e4cffc345fc9f8498e7963f5 MISC metadata.xml 1492 SHA256 64533d61993cc09cb2f0151115fb131ba67dc024d2c746406091c0d4e7d94ac4 SHA512 70b417c1a97e668173b0ce5796b98094d6c2bc109f15064a79dac30a97feae1650e80d4cc2d2dd26c87a8e89503809c4bfb6f41614f1e577aa95c1e60980588a WHIRLPOOL cd5463af66fbff1dbeef6537ad96d6e6278abddb1b86bf256ac65be07b422139c8343ee47727f2de8ddd400cf0485cd91e3eea3e3d4bc8effc078dd27fc9c86b -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 -iJwEAQEIAAYFAlSfCzgACgkQG7kqcTWJkGdC8QQAqf2DXEwziyLQQK1DGb3cXxYu -3CXXhzbgopJ7egzZg6RbR1QeLRIZ2tSR+nLQZBTInDBJoA6jgovEClICF2FFsJE1 -2JKHHHXO8tusUtYJoSbSuFoAgUEabfNpMVd3my7FgrUecEUKFHxk85/Hh6SoL7yM -6TLoghX1z8t8VK04Uys= -=6wLc +iJwEAQEIAAYFAlSf0O4ACgkQG7kqcTWJkGdUQwQAyNy15l0BiQALAg0UOsoo67t0 +KNFAw9bEGcyaN1UD4qYlN64UFuYjb0cJRIo4K/LsmpWm44ohaZ4NDofXmaJvWjkL +usvCeQqpZ1Kk+GxmhhbAOwXS6rC6dNCg/GsDRM/3gH+KPgvIv/nZbI88BtoWTrWW +k75SrNWGEVyu75ZLVGs= +=JrQD -----END PGP SIGNATURE----- diff --git a/dev-libs/efl/files/efl-1.12.2-lauch_via_logind_or_root_privilege.patch b/dev-libs/efl/files/efl-1.12.2-lauch_via_logind_or_root_privilege.patch new file mode 100644 index 000000000000..b2fde0608e5b --- /dev/null +++ b/dev-libs/efl/files/efl-1.12.2-lauch_via_logind_or_root_privilege.patch @@ -0,0 +1,960 @@ +From b10ab1a86f35ab793ba6efb49224d9ecdd1b7dbd Mon Sep 17 00:00:00 2001 +From: Seunghun Lee +Date: Tue, 9 Dec 2014 09:36:42 -0500 +Subject: ecore-drm: added drm launcher that is allow to determine whether to + launch with logind or root privilege. + +Summary: +- allow to launch drm backend without systemd-logind with root privilege. +- allow to open drm device node via logind, not directly open it, in case exist systemd-logind. +- fixes issue that couldn't switch session, because ecore-drm couldn't drop master to drm device with no permission. (allow to switch session appropriate.) + +Reviewers: gwanglim, devilhorns + +Subscribers: torori, cedric + +Differential Revision: https://phab.enlightenment.org/D1704 + +diff --git a/configure.ac b/configure.ac +index e09213d..5911192 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -673,13 +673,18 @@ fi + AM_CONDITIONAL([HAVE_SYSTEMD_USER_SESSION], [test "x${have_systemd_user_session}" = "xyes"]) + AC_SUBST([USER_SESSION_DIR]) + +- + if test "x${have_systemd_pkg}" = "xauto" -o "x${have_systemd_pkg}" = "xyes"; then + PKG_CHECK_MODULES([SYSTEMD], [libsystemd-daemon >= 192 libsystemd-journal >= 192], + [have_systemd_pkg="yes"], + [have_systemd_pkg="no"]) + fi + ++PKG_CHECK_MODULES(SYSTEMD_LOGIN, [libsystemd-login >= 198], ++ [have_systemd_login=yes], [have_systemd_login=no]) ++AS_IF([test "x$have_systemd_login" = "xyes"], ++ [AC_DEFINE([HAVE_SYSTEMD_LOGIN], [1], [Have systemd-login])]) ++AM_CONDITIONAL(HAVE_SYSTEMD_LOGIN, test "x$have_systemd_login" = "xyes") ++ + # check for systemd library if requested + if test "x${want_systemd}" = "xyes" -a "x${have_systemd_pkg}" = "xno"; then + AC_MSG_ERROR([Systemd dependencie requested but not found]) +@@ -3072,7 +3077,7 @@ EFL_INTERNAL_DEPEND_PKG([ECORE_DRM], [eeze]) + EFL_INTERNAL_DEPEND_PKG([ECORE_DRM], [eo]) + EFL_INTERNAL_DEPEND_PKG([ECORE_DRM], [eina]) + +-EFL_DEPEND_PKG([ECORE_DRM], [DRM], [libdrm >= 2.4 xkbcommon >= 0.3.0 libsystemd-login >= 192 gbm]) ++EFL_DEPEND_PKG([ECORE_DRM], [DRM], [libdrm >= 2.4 xkbcommon >= 0.3.0 gbm]) + + EFL_EVAL_PKGS([ECORE_DRM]) + +diff --git a/src/Makefile_Ecore_Drm.am b/src/Makefile_Ecore_Drm.am +index 8867f37..b558277 100644 +--- a/src/Makefile_Ecore_Drm.am ++++ b/src/Makefile_Ecore_Drm.am +@@ -16,10 +16,17 @@ lib/ecore_drm/ecore_drm_inputs.c \ + lib/ecore_drm/ecore_drm_output.c \ + lib/ecore_drm/ecore_drm_tty.c \ + lib/ecore_drm/ecore_drm_device.c \ +-lib/ecore_drm/ecore_drm_dbus.c \ ++lib/ecore_drm/ecore_drm_launcher.c \ + lib/ecore_drm/ecore_drm.c \ ++lib/ecore_drm/ecore_drm_logind.h \ + lib/ecore_drm/ecore_drm_private.h + ++if HAVE_SYSTEMD_LOGIN ++lib_ecore_drm_libecore_drm_la_SOURCES += \ ++lib/ecore_drm/ecore_drm_logind.c \ ++lib/ecore_drm/ecore_drm_dbus.c ++endif ++ + lib_ecore_drm_libecore_drm_la_CPPFLAGS = \ + -I$(top_builddir)/src/lib/efl \ + @ECORE_DRM_CFLAGS@ \ +diff --git a/src/lib/ecore_drm/Ecore_Drm.h b/src/lib/ecore_drm/Ecore_Drm.h +index 80efaf5..3238a20 100644 +--- a/src/lib/ecore_drm/Ecore_Drm.h ++++ b/src/lib/ecore_drm/Ecore_Drm.h +@@ -194,4 +194,6 @@ EAPI Eina_Bool ecore_drm_sprites_crtc_supported(Ecore_Drm_Output *output, unsign + EAPI Ecore_Drm_Fb *ecore_drm_fb_create(Ecore_Drm_Device *dev, int width, int height); + EAPI void ecore_drm_fb_destroy(Ecore_Drm_Fb *fb); + ++EAPI Eina_Bool ecore_drm_launcher_connect(Ecore_Drm_Device *dev); ++EAPI void ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev); + #endif +diff --git a/src/lib/ecore_drm/ecore_drm.c b/src/lib/ecore_drm/ecore_drm.c +index c341c19..6413270 100644 +--- a/src/lib/ecore_drm/ecore_drm.c ++++ b/src/lib/ecore_drm/ecore_drm.c +@@ -6,7 +6,6 @@ + + /* local variables */ + static int _ecore_drm_init_count = 0; +-static char *sid; + + /* external variables */ + int _ecore_drm_log_dom = -1; +@@ -65,12 +64,6 @@ ecore_drm_init(void) + if (!eina_log_domain_level_check(_ecore_drm_log_dom, EINA_LOG_LEVEL_DBG)) + eina_log_domain_level_set("ecore_drm", EINA_LOG_LEVEL_DBG); + +- /* get sd-login properties we need */ +- if (sd_pid_get_session(getpid(), &sid) < 0) goto sd_err; +- +- /* try to init dbus */ +- if (!_ecore_drm_dbus_init(sid)) goto dbus_err; +- + /* try to init eeze */ + if (!eeze_init()) goto eeze_err; + +@@ -78,10 +71,6 @@ ecore_drm_init(void) + return _ecore_drm_init_count; + + eeze_err: +- _ecore_drm_dbus_shutdown(); +-dbus_err: +- free(sid); +-sd_err: + eina_log_domain_unregister(_ecore_drm_log_dom); + _ecore_drm_log_dom = -1; + log_err: +@@ -115,9 +104,6 @@ ecore_drm_shutdown(void) + /* close eeze */ + eeze_shutdown(); + +- /* cleanup dbus */ +- _ecore_drm_dbus_shutdown(); +- + /* shutdown ecore_event */ + ecore_event_shutdown(); + +@@ -131,8 +117,6 @@ ecore_drm_shutdown(void) + /* shutdown eina */ + eina_shutdown(); + +- free(sid); +- + /* return init count */ + return _ecore_drm_init_count; + } +diff --git a/src/lib/ecore_drm/ecore_drm_dbus.c b/src/lib/ecore_drm/ecore_drm_dbus.c +index 222b5e9..bfac33f 100644 +--- a/src/lib/ecore_drm/ecore_drm_dbus.c ++++ b/src/lib/ecore_drm/ecore_drm_dbus.c +@@ -175,7 +175,7 @@ _ecore_drm_dbus_session_release(const char *session) + return EINA_TRUE; + } + +-static void ++void + _ecore_drm_dbus_device_release(uint32_t major, uint32_t minor) + { + Eldbus_Proxy *proxy; +@@ -199,11 +199,35 @@ _ecore_drm_dbus_device_release(uint32_t major, uint32_t minor) + eldbus_proxy_send(proxy, msg, NULL, NULL, -1); + } + +-static int +-_ecore_drm_dbus_device_take(uint32_t major, uint32_t minor, Eldbus_Message_Cb callback, const void *data) ++static void ++_cb_device_taken(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending) ++{ ++ const char *errname, *errmsg; ++ Ecore_Drm_Open_Cb callback = NULL; ++ Eina_Bool b = EINA_FALSE; ++ int fd = -1; ++ ++ if (eldbus_message_error_get(msg, &errname, &errmsg)) ++ { ++ ERR("Eldbus Message Error: %s %s", errname, errmsg); ++ goto eldbus_err; ++ } ++ ++ /* DBUS_TYPE_UNIX_FD == 'h' */ ++ if (!eldbus_message_arguments_get(msg, "hb", &fd, &b)) ++ ERR("\tCould not get UNIX_FD from eldbus message: %d %d", fd, b); ++ ++eldbus_err: ++ callback = (Ecore_Drm_Open_Cb)eldbus_pending_data_del(pending, "callback"); ++ if (callback) callback(data, fd, b); ++} ++ ++int ++_ecore_drm_dbus_device_take(uint32_t major, uint32_t minor, Ecore_Drm_Open_Cb callback, void *data) + { + Eldbus_Proxy *proxy; + Eldbus_Message *msg; ++ Eldbus_Pending *pending; + + /* try to get the Session proxy */ + if (!(proxy = eldbus_proxy_get(dobj, "org.freedesktop.login1.Session"))) +@@ -219,11 +243,45 @@ _ecore_drm_dbus_device_take(uint32_t major, uint32_t minor, Eldbus_Message_Cb ca + } + + eldbus_message_arguments_append(msg, "uu", major, minor); +- eldbus_proxy_send(proxy, msg, callback, data, -1); ++ pending = eldbus_proxy_send(proxy, msg, _cb_device_taken, data, -1); ++ if (callback) eldbus_pending_data_set(pending, "callback", callback); + + return 1; + } + ++int ++_ecore_drm_dbus_device_take_no_pending(uint32_t major, uint32_t minor, Eina_Bool *paused_out, double timeout) ++{ ++ Eldbus_Proxy *proxy; ++ Eldbus_Message *msg, *reply; ++ Eina_Bool b; ++ int fd; ++ ++ /* try to get the Session proxy */ ++ if (!(proxy = eldbus_proxy_get(dobj, "org.freedesktop.login1.Session"))) ++ { ++ ERR("Could not get eldbus session proxy"); ++ return -1; ++ } ++ ++ if (!(msg = eldbus_proxy_method_call_new(proxy, "TakeDevice"))) ++ { ++ ERR("Could not create method call for proxy"); ++ return -1; ++ } ++ ++ if (!eldbus_message_arguments_append(msg, "uu", major, minor)) ++ return -1; ++ ++ reply = eldbus_proxy_send_and_block(proxy, msg, timeout); ++ ++ if (!eldbus_message_arguments_get(reply, "hb", &fd, &b)) ++ return -1; ++ ++ if (paused_out) *paused_out = b; ++ return fd; ++} ++ + int + _ecore_drm_dbus_init(const char *session) + { +@@ -343,25 +401,3 @@ _ecore_drm_dbus_shutdown(void) + + return _dbus_init_count; + } +- +-void +-_ecore_drm_dbus_device_open(const char *device, Eldbus_Message_Cb callback, const void *data) +-{ +- struct stat st; +- +- if (stat(device, &st) < 0) return; +- if (!S_ISCHR(st.st_mode)) return; +- +- _ecore_drm_dbus_device_take(major(st.st_rdev), minor(st.st_rdev), callback, data); +-} +- +-void +-_ecore_drm_dbus_device_close(const char *device) +-{ +- struct stat st; +- +- if (stat(device, &st) < 0) return; +- if (!S_ISCHR(st.st_mode)) return; +- +- _ecore_drm_dbus_device_release(major(st.st_rdev), minor(st.st_rdev)); +-} +diff --git a/src/lib/ecore_drm/ecore_drm_device.c b/src/lib/ecore_drm/ecore_drm_device.c +index e8ca052..957c439e 100644 +--- a/src/lib/ecore_drm/ecore_drm_device.c ++++ b/src/lib/ecore_drm/ecore_drm_device.c +@@ -254,7 +254,8 @@ ecore_drm_device_open(Ecore_Drm_Device *dev) + /* check for valid device */ + if ((!dev) || (!dev->drm.name)) return EINA_FALSE; + +- dev->drm.fd = open(dev->drm.name, O_RDWR | O_CLOEXEC); ++ /* DRM device node is needed immediately to keep going. */ ++ dev->drm.fd = _ecore_drm_launcher_device_open_no_pending(dev->drm.name, O_RDWR); + if (dev->drm.fd < 0) return EINA_FALSE; + + DBG("Opened Device %s : %d", dev->drm.name, dev->drm.fd); +@@ -319,7 +320,7 @@ ecore_drm_device_close(Ecore_Drm_Device *dev) + if (dev->drm.hdlr) ecore_main_fd_handler_del(dev->drm.hdlr); + dev->drm.hdlr = NULL; + +- close(dev->drm.fd); ++ _ecore_drm_launcher_device_close(dev->drm.name, dev->drm.fd); + + /* reset device fd */ + dev->drm.fd = -1; +diff --git a/src/lib/ecore_drm/ecore_drm_inputs.c b/src/lib/ecore_drm/ecore_drm_inputs.c +index f03af36..a1ca008 100644 +--- a/src/lib/ecore_drm/ecore_drm_inputs.c ++++ b/src/lib/ecore_drm/ecore_drm_inputs.c +@@ -57,29 +57,18 @@ flag_err: + } + + static void +-_cb_device_opened(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED) ++_cb_device_opened(void *data, int fd, Eina_Bool paused EINA_UNUSED) + { + Ecore_Drm_Device_Open_Data *d; + Ecore_Drm_Evdev *edev; + Eina_Bool b = EINA_FALSE; +- const char *errname, *errmsg; +- int fd = -1; + + if (!(d = data)) return; + +- if (eldbus_message_error_get(msg, &errname, &errmsg)) +- { +- ERR("Eldbus Message Error: %s %s", errname, errmsg); +- ERR("\tFailed to open device: %s", d->node); +- return; +- } +- +- /* DBG("Input Device Opened: %s", d->node); */ +- +- /* DBUS_TYPE_UNIX_FD == 'h' */ +- if (!eldbus_message_arguments_get(msg, "hb", &fd, &b)) ++ if (fd < 0) + { + ERR("\tCould not get UNIX_FD from eldbus message: %d %d", fd, b); ++ ERR("\tFailed to open device: %s", d->node); + goto cleanup; + } + +@@ -100,7 +89,7 @@ _cb_device_opened(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending + goto cleanup; + + release: +- _ecore_drm_dbus_device_close(d->node); ++ _ecore_drm_launcher_device_close(d->node, fd); + cleanup: + eina_stringshare_del(d->node); + free(d); +@@ -162,7 +151,8 @@ _device_add(Ecore_Drm_Input *input, const char *device) + + DBG("\tDevice Path: %s", data->node); + +- _ecore_drm_dbus_device_open(data->node, _cb_device_opened, data); ++ if (!_ecore_drm_launcher_device_open(data->node, _cb_device_opened, data, O_RDWR | O_NONBLOCK)) ++ goto dev_err; + + return EINA_TRUE; + +@@ -311,7 +301,7 @@ ecore_drm_inputs_destroy(Ecore_Drm_Device *dev) + + EINA_LIST_FREE(seat->devices, edev) + { +- _ecore_drm_dbus_device_close(edev->path); ++ _ecore_drm_launcher_device_close(edev->path, edev->fd); + _ecore_drm_evdev_device_destroy(edev); + } + } +diff --git a/src/lib/ecore_drm/ecore_drm_launcher.c b/src/lib/ecore_drm/ecore_drm_launcher.c +new file mode 100644 +index 0000000..e2d64d5 +--- /dev/null ++++ b/src/lib/ecore_drm/ecore_drm_launcher.c +@@ -0,0 +1,139 @@ ++#include "ecore_drm_private.h" ++#include "ecore_drm_logind.h" ++ ++static Eina_Bool logind = EINA_FALSE; ++ ++EAPI Eina_Bool ++ecore_drm_launcher_connect(Ecore_Drm_Device *dev) ++{ ++ if (!(logind = _ecore_drm_logind_connect(dev))) ++ { ++ DBG("Launcher: Not Support loignd\n"); ++ if (geteuid() == 0) ++ { ++ DBG("Launcher: Try to keep going with root privilege\n"); ++ if (!ecore_drm_tty_open(dev, NULL)) ++ { ++ ERR("Launcher: failed to open tty with root privilege\n"); ++ return EINA_FALSE; ++ } ++ } ++ else ++ { ++ ERR("Launcher: Need Root Privilege or logind\n"); ++ return EINA_FALSE; ++ } ++ } ++ DBG("Launcher: Success Connect\n"); ++ ++ return EINA_TRUE; ++} ++ ++EAPI void ++ecore_drm_launcher_disconnect(Ecore_Drm_Device *dev) ++{ ++ if (logind) ++ { ++ logind = EINA_FALSE; ++ _ecore_drm_logind_disconnect(dev); ++ } ++ else ++ { ++ ecore_drm_tty_close(dev); ++ } ++} ++ ++static int ++_device_flags_set(int fd, int flags) ++{ ++ int fl; ++ ++ fl = fcntl(fd, F_GETFL); ++ if (fl < 0) ++ return -1; ++ ++ if (flags & O_NONBLOCK) ++ fl |= O_NONBLOCK; ++ ++ if (fcntl(fd, F_SETFL, fl) < 0) ++ return -1; ++ ++ fl = fcntl(fd, F_GETFD); ++ if (fl < 0) ++ return -1; ++ ++ if (!(flags & O_CLOEXEC)) ++ fl &= ~FD_CLOEXEC; ++ ++ if (fcntl(fd, F_SETFD, fl) < 0) ++ return -1; ++ ++ return fd; ++} ++ ++Eina_Bool ++_ecore_drm_launcher_device_open(const char *device, Ecore_Drm_Open_Cb callback, void *data, int flags) ++{ ++ int fd = -1; ++ struct stat s; ++ ++ if (logind) ++ { ++ if (!_ecore_drm_logind_device_open(device, callback, data)) ++ return EINA_FALSE; ++ } ++ else ++ { ++ fd = open(device, flags | O_CLOEXEC); ++ if (fd < 0) return EINA_FALSE; ++ if (fstat(fd, &s) == -1) ++ { ++ close(fd); ++ fd = -1; ++ return EINA_FALSE; ++ } ++ ++ callback(data, fd, EINA_FALSE); ++ } ++ ++ return EINA_TRUE; ++} ++ ++int ++_ecore_drm_launcher_device_open_no_pending(const char *device, int flags) ++{ ++ int fd = -1; ++ struct stat s; ++ ++ if (logind) ++ { ++ fd = _ecore_drm_logind_device_open_no_pending(device); ++ if ((fd = _device_flags_set(fd, flags)) == -1) ++ { ++ _ecore_drm_logind_device_close(device); ++ return -1; ++ } ++ } ++ else ++ { ++ fd = open(device, flags, flags | O_CLOEXEC); ++ if (fd < 0) return fd; ++ if (fstat(fd, &s) == -1) ++ { ++ close(fd); ++ return -1; ++ } ++ } ++ ++ DBG("Device opened %s", device); ++ return fd; ++} ++ ++void ++_ecore_drm_launcher_device_close(const char *device, int fd) ++{ ++ if (logind) ++ return _ecore_drm_logind_device_close(device); ++ ++ close(fd); ++} +diff --git a/src/lib/ecore_drm/ecore_drm_logind.c b/src/lib/ecore_drm/ecore_drm_logind.c +new file mode 100644 +index 0000000..a3c6c1e +--- /dev/null ++++ b/src/lib/ecore_drm/ecore_drm_logind.c +@@ -0,0 +1,310 @@ ++#include ++#include ++#include ++#include ++#include ++#include "ecore_drm_private.h" ++#include "ecore_drm_logind.h" ++ ++#ifndef KDSKBMUTE ++# define KDSKBMUTE 0x4B51 ++#endif ++ ++static char *sid; ++ ++static Eina_Bool ++_ecore_drm_logind_cb_vt_switch(void *data, int type EINA_UNUSED, void *event) ++{ ++ Ecore_Drm_Device *dev; ++ Ecore_Event_Key *ev; ++ int keycode; ++ int vt; ++ ++ dev = data; ++ ev = event; ++ keycode = ev->keycode - 8; ++ ++ if ((ev->modifiers & ECORE_EVENT_MODIFIER_CTRL) && ++ (ev->modifiers & ECORE_EVENT_MODIFIER_ALT) && ++ (keycode >= KEY_F1) && (keycode <= KEY_F8)) ++ { ++ vt = (keycode - KEY_F1 + 1); ++ ++ if (ioctl(dev->tty.fd, VT_ACTIVATE, vt) < 0) ++ ERR("Failed to activate vt: %m"); ++ } ++ ++ return ECORE_CALLBACK_PASS_ON; ++} ++ ++static Eina_Bool ++_ecore_drm_logind_cb_vt_signal(void *data, int type EINA_UNUSED, void *event) ++{ ++ Ecore_Drm_Device *dev; ++ Ecore_Event_Signal_User *ev; ++ siginfo_t sigdata; ++ ++ dev = data; ++ ev = event; ++ ++ sigdata = ev->data; ++ if (sigdata.si_code != SI_KERNEL) return ECORE_CALLBACK_RENEW; ++ ++ if (ev->number == 1) ++ { ++ Ecore_Drm_Input *input; ++ Ecore_Drm_Output *output; ++ Ecore_Drm_Sprite *sprite; ++ Eina_List *l; ++ ++ /* disable inputs (suspends) */ ++ EINA_LIST_FOREACH(dev->inputs, l, input) ++ ecore_drm_inputs_disable(input); ++ ++ /* disable hardware cursor */ ++ EINA_LIST_FOREACH(dev->outputs, l, output) ++ ecore_drm_output_cursor_size_set(output, 0, 0, 0); ++ ++ /* disable sprites */ ++ EINA_LIST_FOREACH(dev->sprites, l, sprite) ++ ecore_drm_sprites_fb_set(sprite, 0, 0); ++ ++ if (!ecore_drm_tty_release(dev)) ++ ERR("Could not release VT: %m"); ++ } ++ else if (ev->number == 2) ++ { ++ if (ecore_drm_tty_acquire(dev)) ++ { ++ Ecore_Drm_Output *output; ++ Ecore_Drm_Input *input; ++ Eina_List *l; ++ ++ /* set output mode */ ++ EINA_LIST_FOREACH(dev->outputs, l, output) ++ ecore_drm_output_enable(output); ++ ++ /* enable inputs */ ++ EINA_LIST_FOREACH(dev->inputs, l, input) ++ ecore_drm_inputs_enable(input); ++ } ++ else ++ ERR("Could not acquire VT: %m"); ++ } ++ ++ return ECORE_CALLBACK_PASS_ON; ++} ++ ++static Eina_Bool ++_ecore_drm_logind_tty_setup(Ecore_Drm_Device *dev) ++{ ++ struct stat st; ++ int kmode; ++ struct vt_mode vtmode = { 0 }; ++ ++ if (fstat(dev->tty.fd, &st) == -1) ++ { ++ ERR("Failed to get stats for tty: %m"); ++ return EINA_FALSE; ++ } ++ ++ if (ioctl(dev->tty.fd, KDGETMODE, &kmode)) ++ { ++ ERR("Could not get tty mode: %m"); ++ return EINA_FALSE; ++ } ++ ++ if (ioctl(dev->tty.fd, VT_ACTIVATE, minor(st.st_rdev)) < 0) ++ { ++ ERR("Failed to activate vt: %m"); ++ return EINA_FALSE; ++ } ++ ++ if (ioctl(dev->tty.fd, VT_WAITACTIVE, minor(st.st_rdev)) < 0) ++ { ++ ERR("Failed to wait active: %m"); ++ return EINA_FALSE; ++ } ++ ++ /* NB: Don't set this. This Turns OFF keyboard on the VT */ ++ /* if (ioctl(dev->tty.fd, KDSKBMUTE, 1) && */ ++ /* ioctl(dev->tty.fd, KDSKBMODE, K_OFF)) */ ++ /* { */ ++ /* ERR("Could not set K_OFF keyboard mode: %m"); */ ++ /* return EINA_FALSE; */ ++ /* } */ ++ ++ if (kmode != KD_GRAPHICS) ++ { ++ if (ioctl(dev->tty.fd, KDSETMODE, KD_GRAPHICS)) ++ { ++ ERR("Could not set graphics mode: %m"); ++ goto err_kmode; ++ } ++ } ++ ++ vtmode.mode = VT_PROCESS; ++ vtmode.waitv = 0; ++ vtmode.relsig = SIGUSR1; ++ vtmode.acqsig = SIGUSR2; ++ if (ioctl(dev->tty.fd, VT_SETMODE, &vtmode) < 0) ++ { ++ ERR("Could not set Terminal Mode: %m"); ++ goto err_setmode; ++ } ++ ++ return EINA_TRUE; ++err_setmode: ++ ioctl(dev->tty.fd, KDSETMODE, KD_TEXT); ++err_kmode: ++ return EINA_FALSE; ++} ++ ++ ++static Eina_Bool ++_ecore_drm_logind_vt_open(Ecore_Drm_Device *dev, const char *name) ++{ ++ char tty[32] = ""; ++ ++ /* check for valid device */ ++ if ((!dev) || (!dev->drm.name)) return EINA_FALSE; ++ ++ /* assign default tty fd of -1 */ ++ dev->tty.fd = -1; ++ ++ if (!name) ++ { ++ char *env; ++ ++ if ((env = getenv("ECORE_DRM_TTY"))) ++ snprintf(tty, sizeof(tty), "%s", env); ++ else ++ dev->tty.fd = dup(STDIN_FILENO); ++ } ++ else ++ snprintf(tty, sizeof(tty), "%s", name); ++ ++ if (dev->tty.fd < 0) ++ { ++ DBG("Trying to Open Tty: %s", tty); ++ ++ dev->tty.fd = open(tty, O_RDWR | O_NOCTTY); ++ if (dev->tty.fd < 0) ++ { ++ DBG("Failed to Open Tty: %m"); ++ return EINA_FALSE; ++ } ++ } ++ ++ /* save tty name */ ++ dev->tty.name = eina_stringshare_add(tty); ++ ++ /* FIXME */ ++ if (!_ecore_drm_logind_tty_setup(dev)) ++ { ++ close(dev->tty.fd); ++ dev->tty.fd = -1; ++ return EINA_FALSE; ++ } ++ ++ /* setup handler for signals */ ++ dev->tty.event_hdlr = ++ ecore_event_handler_add(ECORE_EVENT_SIGNAL_USER, ++ _ecore_drm_logind_cb_vt_signal, dev); ++ ++ /* setup handler for key event of vt switch */ ++ dev->tty.switch_hdlr = ++ ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, ++ _ecore_drm_logind_cb_vt_switch, dev); ++ ++ /* set current tty into env */ ++ setenv("ECORE_DRM_TTY", tty, 1); ++ ++ return EINA_TRUE; ++} ++ ++static void ++_ecore_drm_logind_vt_close(Ecore_Drm_Device *dev) ++{ ++ struct vt_mode mode = { 0 }; ++ ++ ioctl(dev->tty.fd, KDSETMODE, KD_TEXT); ++ mode.mode = VT_AUTO; ++ ioctl(dev->tty.fd, VT_SETMODE, &mode); ++ ++ if (dev->tty.event_hdlr) ecore_event_handler_del(dev->tty.event_hdlr); ++ dev->tty.event_hdlr = NULL; ++ ++ if (dev->tty.switch_hdlr) ecore_event_handler_del(dev->tty.switch_hdlr); ++ dev->tty.switch_hdlr = NULL; ++ ++ if (dev->tty.name) eina_stringshare_del(dev->tty.name); ++ dev->tty.name = NULL; ++ ++ unsetenv("ECORE_DRM_TTY"); ++} ++ ++Eina_Bool ++_ecore_drm_logind_connect(Ecore_Drm_Device *dev) ++{ ++ /* get sd-login properties we need */ ++ if (sd_pid_get_session(getpid(), &sid) < 0) return EINA_FALSE; ++ ++ /* try to init dbus */ ++ if (!_ecore_drm_dbus_init(sid)) ++ { ++ free(sid); ++ return EINA_FALSE; ++ } ++ ++ if (!_ecore_drm_logind_vt_open(dev, NULL)) ++ { ++ free(sid); ++ return EINA_FALSE; ++ } ++ ++ return EINA_TRUE; ++} ++ ++void ++_ecore_drm_logind_disconnect(Ecore_Drm_Device *dev) ++{ ++ _ecore_drm_logind_vt_close(dev); ++ _ecore_drm_dbus_shutdown(); ++} ++ ++Eina_Bool ++_ecore_drm_logind_device_open(const char *device, Ecore_Drm_Open_Cb callback, void *data) ++{ ++ struct stat st; ++ ++ if (stat(device, &st) < 0) return EINA_FALSE; ++ if (!S_ISCHR(st.st_mode)) return EINA_FALSE; ++ ++ if (_ecore_drm_dbus_device_take(major(st.st_rdev), minor(st.st_rdev), callback, data) < 0) ++ return EINA_FALSE; ++ ++ return EINA_TRUE; ++} ++ ++int ++_ecore_drm_logind_device_open_no_pending(const char *device) ++{ ++ struct stat st; ++ ++ if (stat(device, &st) < 0) return EINA_FALSE; ++ if (!S_ISCHR(st.st_mode)) return EINA_FALSE; ++ ++ return _ecore_drm_dbus_device_take_no_pending(major(st.st_rdev), minor(st.st_rdev), NULL, -1); ++} ++ ++void ++_ecore_drm_logind_device_close(const char *device) ++{ ++ struct stat st; ++ ++ if (stat(device, &st) < 0) return; ++ if (!S_ISCHR(st.st_mode)) return; ++ ++ _ecore_drm_dbus_device_release(major(st.st_rdev), minor(st.st_rdev)); ++} +diff --git a/src/lib/ecore_drm/ecore_drm_logind.h b/src/lib/ecore_drm/ecore_drm_logind.h +new file mode 100644 +index 0000000..4315722 +--- /dev/null ++++ b/src/lib/ecore_drm/ecore_drm_logind.h +@@ -0,0 +1,55 @@ ++#ifndef _ECORE_DRM_LOGIN_H_ ++# define _ECORE_DRM_LOGIN_H_ ++ ++# ifdef HAVE_CONFIG_H ++# include "config.h" ++# endif ++ ++#ifdef HAVE_SYSTEMD_LOGIN ++# include ++ ++Eina_Bool _ecore_drm_logind_connect(Ecore_Drm_Device *dev); ++void _ecore_drm_logind_disconnect(Ecore_Drm_Device *dev); ++Eina_Bool _ecore_drm_logind_device_open(const char *device, Ecore_Drm_Open_Cb callback, void *data); ++int _ecore_drm_logind_device_open_no_pending(const char *device); ++void _ecore_drm_logind_device_close(const char *device); ++ ++int _ecore_drm_dbus_init(const char *session); ++int _ecore_drm_dbus_shutdown(void); ++int _ecore_drm_dbus_device_take(uint32_t major, uint32_t minor, Ecore_Drm_Open_Cb callback, void *data); ++int _ecore_drm_dbus_device_take_no_pending(uint32_t major, uint32_t minor, Eina_Bool *paused_out, double timeout); ++void _ecore_drm_dbus_device_release(uint32_t major, uint32_t minor); ++ ++#else ++static inline Eina_Bool ++_ecore_drm_logind_connect(Ecore_Drm_Device *dev EINA_UNUSED) ++{ ++ return EINA_FALSE; ++} ++ ++static inline void ++_ecore_drm_logind_disconnect(Ecore_Drm_Device *dev EINA_UNUSED) ++{ ++ return; ++} ++ ++static inline Eina_Bool ++_ecore_drm_logind_device_open(const char *device EINA_UNUSED, Ecore_Drm_Open_Cb callback EINA_UNUSED, void *data EINA_UNUSED) ++{ ++ return EINA_FALSE; ++} ++ ++static inline int ++_ecore_drm_logind_device_open_no_pending(const char *device EINA_UNUSED) ++{ ++ return -1; ++} ++ ++static inline void ++_ecore_drm_logind_device_close(const char *device EINA_UNUSED) ++{ ++ return; ++} ++#endif ++ ++#endif +diff --git a/src/lib/ecore_drm/ecore_drm_private.h b/src/lib/ecore_drm/ecore_drm_private.h +index fe769a4..7a3c0a0 100644 +--- a/src/lib/ecore_drm/ecore_drm_private.h ++++ b/src/lib/ecore_drm/ecore_drm_private.h +@@ -21,7 +21,6 @@ + + # include + //# include +-# include + # include + + # include +@@ -228,10 +227,11 @@ struct _Ecore_Drm_Sprite + unsigned int formats[]; + }; + +-int _ecore_drm_dbus_init(const char *session); +-int _ecore_drm_dbus_shutdown(void); +-void _ecore_drm_dbus_device_open(const char *device, Eldbus_Message_Cb callback, const void *data); +-void _ecore_drm_dbus_device_close(const char *device); ++typedef void (*Ecore_Drm_Open_Cb)(void *data, int fd, Eina_Bool b); ++ ++Eina_Bool _ecore_drm_launcher_device_open(const char *device, Ecore_Drm_Open_Cb callback, void *data, int flags); ++int _ecore_drm_launcher_device_open_no_pending(const char *device, int flags); ++void _ecore_drm_launcher_device_close(const char *device, int fd); + + Ecore_Drm_Evdev *_ecore_drm_evdev_device_create(Ecore_Drm_Seat *seat, const char *path, int fd); + void _ecore_drm_evdev_device_destroy(Ecore_Drm_Evdev *evdev); +diff --git a/src/modules/ecore_evas/engines/drm/ecore_evas_drm.c b/src/modules/ecore_evas/engines/drm/ecore_evas_drm.c +index ce6ce84..776939e 100644 +--- a/src/modules/ecore_evas/engines/drm/ecore_evas_drm.c ++++ b/src/modules/ecore_evas/engines/drm/ecore_evas_drm.c +@@ -474,6 +474,12 @@ _ecore_evas_drm_init(const char *device) + goto dev_err; + } + ++ if (!ecore_drm_launcher_connect(dev)) ++ { ++ ERR("Could not connect DRM launcher"); ++ goto launcher_err; ++ } ++ + /* try to open the graphics card */ + if (!ecore_drm_device_open(dev)) + { +@@ -481,13 +487,6 @@ _ecore_evas_drm_init(const char *device) + goto dev_open_err; + } + +- /* try to open the tty */ +- if (!ecore_drm_tty_open(dev, NULL)) +- { +- ERR("Could not open tty: %m"); +- goto tty_open_err; +- } +- + /* try to create sprites */ + if (!ecore_drm_sprites_create(dev)) + { +@@ -516,11 +515,11 @@ _ecore_evas_drm_init(const char *device) + output_err: + ecore_drm_sprites_destroy(dev); + sprite_err: +- ecore_drm_tty_close(dev); +-tty_open_err: + ecore_drm_device_close(dev); + dev_open_err: + ecore_drm_device_free(dev); ++ ecore_drm_launcher_disconnect(dev); ++launcher_err: + dev_err: + ecore_drm_shutdown(); + return --_ecore_evas_init_count; +@@ -534,9 +533,9 @@ _ecore_evas_drm_shutdown(void) + ecore_drm_sprites_destroy(dev); + /* NB: No need to free outputs here. Is done in device free */ + ecore_drm_inputs_destroy(dev); +- ecore_drm_tty_close(dev); + ecore_drm_device_close(dev); + ecore_drm_device_free(dev); ++ ecore_drm_launcher_disconnect(dev); + ecore_drm_shutdown(); + + ecore_event_evas_shutdown(); +-- +cgit v0.10.1 + -- 2.26.2