diff -ur upower-0.99.4-orig/configure.ac upower-0.99.4/configure.ac
--- upower-0.99.4-orig/configure.ac 2017-12-22 13:49:01.103499900 +0000
+++ upower-0.99.4/configure.ac 2017-12-22 13:52:02.433807222 +0000
@@ -182,13 +182,14 @@
dnl ---------------------------------------------------------------------------
AC_ARG_WITH([backend],
AS_HELP_STRING([--with-backend=<option>],
- [Default backend to use linux, freebsd, openbsd, dummy (dummy)]))
+ [Default backend to use linux, freebsd, openbsd, illumos, dummy (dummy)]))
# default to a sane option
AC_CANONICAL_HOST
if test x$with_backend = x; then
AS_CASE([$host],
[*-linux*], [with_backend=linux],
[*-*freebsd*], [with_backend=freebsd],
+ [*-*solaris*], [with_backend=illumos],
[*-openbsd*], [with_backend=openbsd],
[with_backend=dummy])
fi
@@ -216,6 +217,7 @@
AM_CONDITIONAL(BACKEND_TYPE_LINUX, [test x$with_backend = xlinux])
AM_CONDITIONAL(BACKEND_TYPE_FREEBSD, [test x$with_backend = xfreebsd])
AM_CONDITIONAL(BACKEND_TYPE_OPENBSD, [test x$with_backend = xopenbsd])
+AM_CONDITIONAL(BACKEND_TYPE_ILLUMOS, [test x$with_backend = xillumos])
dnl ---------------------------------------------------------------------------
dnl - Build self tests
@@ -252,6 +254,7 @@
src/dummy/Makefile
src/freebsd/Makefile
src/openbsd/Makefile
+src/illumos/Makefile
src/linux/Makefile
src/bsd/Makefile
tools/Makefile
--- upower-0.99.4-orig/src/Makefile.am 2017-12-22 13:49:01.088869218 +0000
+++ upower-0.99.4/src/Makefile.am 2017-12-22 14:11:15.858740851 +0000
@@ -1,7 +1,7 @@
## Process this file with automake to produce Makefile.in
-DIST_SUBDIRS = dummy freebsd linux openbsd bsd
-SUBDIRS = dummy freebsd linux openbsd
+DIST_SUBDIRS = dummy freebsd linux openbsd bsd illumos
+SUBDIRS = dummy freebsd linux openbsd illumos
if BACKEND_TYPE_FREEBSD
SUBDIRS += bsd
@@ -11,6 +11,10 @@
SUBDIRS += bsd
endif
+if BACKEND_TYPE_ILLUMOS
+SUBDIRS += bsd
+endif
+
AM_CPPFLAGS = \
$(PIE_CFLAGS) \
-I$(top_builddir)/src -I$(top_srcdir)/src \
@@ -90,6 +94,13 @@
bsd/libupsharedcommon.la
endif
+if BACKEND_TYPE_ILLUMOS
+upowerd_LDADD += \
+ illumos/libupshared.la \
+ bsd/libupsharedcommon.la
+endif
+
+
if BACKEND_TYPE_LINUX
upowerd_LDADD += \
linux/libupshared.la \
diff -urN upower-0.99.4-orig/src/illumos/Makefile.am upower-0.99.4/src/illumos/Makefile.am
--- upower-0.99.4/src/illumos/Makefile.am.~1~ 2017-12-28 12:33:16.160144165 +0000
+++ upower-0.99.4/src/illumos/Makefile.am 2017-12-28 12:37:16.557439612 +0000
@@ -0,0 +1,31 @@
+## Process this file with automake to produce Makefile.in
+
+AM_CPPFLAGS = \
+ -I$(top_builddir)/src -I$(top_srcdir)/src \
+ -I$(top_builddir)/ -I$(top_srcdir)/ \
+ -DUP_COMPILATION \
+ -DG_LOG_DOMAIN=\"UPower-illumos\" \
+ -I$(top_srcdir)/libupower-glib \
+ $(POLKIT_CFLAGS) \
+ $(GLIB_CFLAGS)
+
+if BACKEND_TYPE_ILLUMOS
+noinst_LTLIBRARIES = libupshared.la
+endif
+
+libupshared_la_SOURCES = \
+ up-native.c \
+ up-backend.c \
+ $(BUILT_SOURCES)
+
+libupshared_la_CFLAGS = \
+ $(WARNINGFLAGS_C)
+
+libupshared_la_LDFLAGS = \
+ -lsysevent \
+ -ldevinfo
+
+clean-local :
+ rm -f *~
+
+-include $(top_srcdir)/git.mk
diff -urN upower-0.99.4-orig/src/illumos/up-acpi-native.h upower-0.99.4/src/illumos/up-acpi-native.h
--- upower-0.99.4-orig/src/illumos/up-acpi-native.h 1970-01-01 03:00:00.000000000 +0000
+++ upower-0.99.4/src/illumos/up-acpi-native.h 2017-12-26 13:41:47.340610361 +0000
@@ -0,0 +1,54 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2011 Landry Breuil <landry@openbsd.org>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef __UP_ACPI_NATIVE_H__
+#define __UP_ACPI_NATIVE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define UP_TYPE_ACPI_NATIVE (up_acpi_native_get_type ())
+#define UP_ACPI_NATIVE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UP_TYPE_ACPI_NATIVE, UpAcpiNative))
+#define UP_ACPI_NATIVE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), UP_TYPE_ACPI_NATIVE, UpAcpiNativeClass))
+#define UP_IS_ACPI_NATIVE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UP_TYPE_ACPI_NATIVE))
+#define UP_IS_ACPI_NATIVE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), UP_TYPE_ACPI_NATIVE))
+#define UP_ACPI_NATIVE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), UP_TYPE_ACPI_NATIVE, UpAcpiNativeClass))
+
+typedef struct
+{
+ GObject parent;
+ gchar* path;
+} UpAcpiNative;
+
+typedef struct
+{
+ GObjectClass parent_class;
+} UpAcpiNativeClass;
+
+
+UpAcpiNative* up_acpi_native_new (const char*);
+const gchar * up_acpi_native_get_path (UpAcpiNative*);
+GType up_acpi_native_get_type (void);
+G_END_DECLS
+
+#endif
diff -urN upower-0.99.4-orig/src/illumos/up-backend.c upower-0.99.4/src/illumos/up-backend.c
--- upower-0.99.4/src/illumos/up-backend.c.~1~ 2018-01-20 09:48:32.501653060 +0000
+++ upower-0.99.4/src/illumos/up-backend.c 2018-01-20 12:33:59.490627981 +0000
@@ -0,0 +1,918 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2011 Landry Breuil <landry@openbsd.org>
+ * Copyright (C) 2018 Alexander Pyhalov <apyhalov@gmail.com>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "up-backend.h"
+#include "up-daemon.h"
+#include "up-device.h"
+#include "up-acpi-native.h"
+#include "up-backend-bsd-private.h"
+#include <stdio.h>
+#include <string.h> /* strcmp() */
+#include <libdevinfo.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/acpi_drv.h>
+#include <libsysevent.h>
+#include <sys/sysevent/dev.h>
+#include <sys/sysevent/pwrctl.h>
+
+#define DEVFS_PREFIX "/devices"
+
+#define BST_FLAG_DISCHARGING (0x1)
+#define BST_FLAG_CHARGING (0x2)
+
+#define DEVPATH_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyz0123456789/_"
+
+#define POLL_INTERVAL 20*1000 /* 20 seconds */
+
+static void up_backend_class_init (UpBackendClass *klass);
+static void up_backend_init (UpBackend *backend);
+static void up_backend_finalize (GObject *object);
+
+static int up_backend_acpi_get_ac_online();
+static void up_backend_update_lid_status(UpDaemon*);
+
+static gboolean up_acpi_device_get_on_battery (UpDevice *device, gboolean *on_battery);
+static gboolean up_acpi_device_get_online (UpDevice *device, gboolean *online);
+static gboolean up_acpi_device_refresh (UpDevice *device);
+
+static int minor_device_ioctl(di_node_t node, void *arg);
+static int estimate_time(int charge_rate, int current_charge, int last_fullcharge, int is_discharging, int is_charging);
+
+static char* up_backend_get_ac_device_path(enum acpi_drv_type device);
+
+static sysevent_handle_t *shp;
+static void up_backend_sysevent_dev_handler(sysevent_t *ev);
+static gboolean sysevent_iochannel_data(GIOChannel *, GIOCondition, gpointer);
+static void up_backend_initialize_sysevent_handler(UpBackend *backend);
+static int sysevent_pipe_fds[2];
+static GIOChannel *sysevent_iochannel;
+static gboolean simulate_iochannel_data (gpointer data);
+
+#define UP_BACKEND_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_BACKEND, UpBackendPrivate))
+
+struct UpBackendPrivate
+{
+ UpDaemon *daemon;
+ UpDevice *ac;
+ UpDevice *battery;
+ gboolean has_ac_device; /* ac device node is present */
+ gboolean has_bat_device; /* battery device node is present */
+ UpConfig *config;
+ GDBusProxy *seat_manager_proxy;
+};
+
+struct mdi_arg {
+ const char *name;
+ gboolean exact_match;
+ int ctl;
+ gboolean present;
+ gboolean success;
+ void *result;
+ char *device_path;
+};
+
+enum {
+ SIGNAL_DEVICE_ADDED,
+ SIGNAL_DEVICE_REMOVED,
+ SIGNAL_LAST
+};
+
+struct lid_state {
+ gboolean present;
+ gboolean open;
+};
+
+static guint signals [SIGNAL_LAST] = { 0 };
+
+G_DEFINE_TYPE (UpBackend, up_backend, G_TYPE_OBJECT)
+
+/**
+ * functions called by upower daemon
+ **/
+
+
+/* those three ripped from freebsd/up-device-supply.c */
+gboolean
+up_acpi_device_get_on_battery (UpDevice *device, gboolean * on_battery)
+{
+ UpDeviceKind type;
+ UpDeviceState state;
+ gboolean is_present;
+
+ g_return_val_if_fail (on_battery != NULL, FALSE);
+
+ g_object_get (device,
+ "type", &type,
+ "state", &state,
+ "is-present", &is_present,
+ (void*) NULL);
+
+ if (type != UP_DEVICE_KIND_BATTERY)
+ return FALSE;
+ if (state == UP_DEVICE_STATE_UNKNOWN)
+ return FALSE;
+ if (!is_present)
+ return FALSE;
+
+ *on_battery = (state == UP_DEVICE_STATE_DISCHARGING);
+ return TRUE;
+}
+
+gboolean
+up_acpi_device_get_online (UpDevice *device, gboolean * online)
+{
+ UpDeviceKind type;
+ gboolean online_tmp;
+
+ g_return_val_if_fail (online != NULL, FALSE);
+
+ g_object_get (device,
+ "type", &type,
+ "online", &online_tmp,
+ (void*) NULL);
+
+ if (type != UP_DEVICE_KIND_LINE_POWER)
+ return FALSE;
+
+ *online = online_tmp;
+
+ return TRUE;
+}
+/**
+ * up_backend_coldplug:
+ * @backend: The %UpBackend class instance
+ * @daemon: The %UpDaemon controlling instance
+ *
+ * Finds all the devices already plugged in, and emits device-add signals for
+ * each of them.
+ *
+ * Return value: %TRUE for success
+ **/
+gboolean
+up_backend_coldplug (UpBackend *backend, UpDaemon *daemon)
+{
+ UpAcpiNative *acnative = NULL;
+ UpAcpiNative *battnative = NULL;
+ char *devpath;
+
+ backend->priv->daemon = g_object_ref (daemon);
+
+ if (backend->priv->has_ac_device || backend->priv->has_bat_device) {
+ up_backend_update_lid_status(daemon);
+ }
+
+ if (backend->priv->has_ac_device) {
+ devpath = up_backend_get_ac_device_path(ACPI_DRV_TYPE_AC);
+ if (devpath) {
+ devpath = g_strcanon(devpath, DEVPATH_ALLOWED_CHARS, '_');
+ acnative = up_acpi_native_new(devpath);
+ if (!up_device_coldplug (backend->priv->ac, backend->priv->daemon, G_OBJECT(acnative)))
+ g_warning ("failed to coldplug ac");
+ else
+ g_signal_emit (backend, signals[SIGNAL_DEVICE_ADDED], 0, acnative, backend->priv->ac);
+ g_free(devpath);
+ }
+ }
+
+ if (backend->priv->has_bat_device) {
+ devpath = up_backend_get_ac_device_path(ACPI_DRV_TYPE_CBAT);
+ if (devpath) {
+ devpath = g_strcanon(devpath, DEVPATH_ALLOWED_CHARS, '_');
+ battnative = up_acpi_native_new(devpath);
+ if (!up_device_coldplug (backend->priv->battery, backend->priv->daemon, G_OBJECT(battnative)))
+ g_warning ("failed to coldplug battery");
+ else
+ g_signal_emit (backend, signals[SIGNAL_DEVICE_ADDED], 0, battnative, backend->priv->battery);
+ g_free(devpath);
+ }
+ }
+
+ return TRUE;
+}
+
+/**
+ * up_backend_unplug:
+ * @backend: The %UpBackend class instance
+ *
+ * Forget about all learned devices, effectively undoing up_backend_coldplug.
+ * Resources are released without emitting signals.
+ */
+void
+up_backend_unplug (UpBackend *backend)
+{
+ if (backend->priv->daemon != NULL) {
+ g_object_unref (backend->priv->daemon);
+ backend->priv->daemon = NULL;
+ }
+}
+
+/**
+ * up_backend_get_seat_manager_proxy:
+ * @backend: The %UpBackend class instance
+ *
+ * Returns the seat manager object or NULL on error. [transfer none]
+ */
+GDBusProxy *
+up_backend_get_seat_manager_proxy (UpBackend *backend)
+{
+ g_return_val_if_fail (UP_IS_BACKEND (backend), NULL);
+
+ return backend->priv->seat_manager_proxy;
+}
+
+/**
+ * up_backend_get_config:
+ * @backend: The %UpBackend class instance
+ *
+ * Returns the UpConfig object or NULL on error. [transfer none]
+ */
+UpConfig *
+up_backend_get_config (UpBackend *backend)
+{
+ g_return_val_if_fail (UP_IS_BACKEND (backend), NULL);
+
+ return backend->priv->config;
+}
+
+
+/**
+ * illumos specific code
+ **/
+
+static gboolean
+up_backend_update_ac_state(UpDevice* device)
+{
+ gboolean new_is_online, cur_is_online;
+ int ret;
+
+ up_backend_update_lid_status(up_device_get_daemon(device));
+ ret = up_backend_acpi_get_ac_online();
+ if (ret < 0)
+ return FALSE;
+
+ g_object_get (device, "online", &cur_is_online, (void*) NULL);
+
+ new_is_online = (ret > 0 ? TRUE : FALSE);
+ if (cur_is_online != new_is_online)
+ {
+ g_object_set (device,
+ "online", new_is_online,
+ (void*) NULL);
+ return TRUE;
+ }
+ return FALSE;
+}
+
+static gboolean
+up_backend_update_battery_state(UpDevice* device)
+{
+ gdouble percentage = 0, new_percentage = 0;
+ gboolean is_present;
+ UpDeviceState cur_state, new_state;
+ gint64 cur_time_to_empty, new_time_to_empty; /* in seconds */
+
+ di_node_t root_node;
+ struct mdi_arg ma;
+ acpi_bst_t bst;
+ acpi_bif_t bif;
+
+ new_state = UP_DEVICE_STATE_UNKNOWN;
+
+ memset(&bif, 0, sizeof(bif));
+ ma.name = "battery";
+ ma.exact_match = FALSE;
+ ma.ctl = ACPI_DRV_IOC_INFO;
+ ma.result = &bif;
+
+ errno = 0;
+ if((root_node = di_init("/", DINFOSUBTREE|DINFOMINOR)) == DI_NODE_NIL) {
+ g_error("di_init() failed: %s", g_strerror(errno));
+ }
+ di_walk_node(root_node, DI_WALK_CLDFIRST, &ma, minor_device_ioctl);
+ di_fini(root_node);
+ if (ma.device_path)
+ g_free(ma.device_path);
+
+ if (!ma.success) {
+ /* If device file is present, but ioctl has failed,
+ consider that battery is absent */
+ if (ma.present) {
+ g_object_set (device,
+ "state", UP_DEVICE_STATE_EMPTY,
+ "percentage", (gdouble) 0.0,
+ "time-to-empty", (guint64) 0,
+ "is-present", FALSE,
+ (void*) NULL);
+ /* Reset some known fields which remain untouched below. */
+ g_object_set(device,
+ "is-rechargeable", FALSE,
+ "energy", (gdouble) 0.0,
+ "energy-empty", (gdouble) 0.0,
+ "energy-full", (gdouble) 0.0,
+ "energy-full-design", (gdouble) 0.0,
+ "energy-rate", (gdouble) 0.0,
+ NULL);
+ return TRUE;
+ } else {
+ g_warning("Couldn't get state of battery");
+ return FALSE;
+ }
+ }
+
+
+ memset(&bst, 0, sizeof(bst));
+ ma.name = "battery";
+ ma.exact_match = FALSE;
+ ma.ctl = ACPI_DRV_IOC_STATUS;
+ ma.result = &bst;
+
+ errno = 0;
+ if((root_node = di_init("/", DINFOSUBTREE|DINFOMINOR)) == DI_NODE_NIL) {
+ g_error("di_init() failed: %s", g_strerror(errno));
+ return FALSE;
+ }
+ di_walk_node(root_node, DI_WALK_CLDFIRST, &ma, minor_device_ioctl);
+ di_fini(root_node);
+ if (ma.device_path)
+ g_free(ma.device_path);
+
+ g_object_get (device,
+ "state", &cur_state,
+ "percentage", &percentage,
+ "time-to-empty", &cur_time_to_empty,
+ "is-present", &is_present,
+ (void*) NULL);
+
+ if (ma.success) {
+ int reporting_rate;
+ int reporting_current;
+ int reporting_lastfull;
+ int reporting_lowcap;
+ int reporting_design_capacity;
+ int design_voltage;
+ int present_voltage;
+ int charging, discharging;
+
+ charging = bst.bst_state & BST_FLAG_CHARGING;
+ discharging = bst.bst_state & BST_FLAG_DISCHARGING;
+
+ reporting_rate = bst.bst_rate;
+ reporting_current = bst.bst_rem_cap;
+ reporting_lastfull = bif.bif_last_cap;
+ reporting_lowcap = bif.bif_low_cap;
+ design_voltage = bif.bif_voltage;
+ present_voltage = bst.bst_voltage;
+ reporting_design_capacity = bif.bif_design_cap;
+ if (bif.bif_unit) { /* Battery is reporting in mAh */
+ /*
+ * If the present_voltage is inaccurate, set it to the
+ * design_voltage.
+ */
+ if (((present_voltage * 10) < design_voltage) ||
+ (present_voltage <= 0) ||
+ (present_voltage > design_voltage)) {
+ present_voltage = design_voltage;
+ }
+ reporting_rate = (reporting_rate * present_voltage) / 1000;
+ reporting_lastfull = (reporting_lastfull * present_voltage) /1000;
+ reporting_current = (reporting_current * present_voltage) / 1000;
+ reporting_design_capacity = (reporting_design_capacity * present_voltage) / 1000;
+ reporting_lowcap = (reporting_lowcap * present_voltage) / 1000;
+ }
+
+ /* Make sure the current charge does not exceed the full charge */
+ if (reporting_current > reporting_lastfull) {
+ reporting_current = reporting_lastfull;
+ }
+
+ if (reporting_current < 0) {
+ reporting_current = 0;
+ }
+
+ if (!(charging) && !(discharging)) {
+ reporting_rate = 0;
+ }
+
+ if (reporting_lastfull > 0) {
+ new_percentage = ((double) reporting_current / (double) reporting_lastfull) * 100.0;
+ }
+ if (new_percentage < 0) {
+ new_percentage = 0;
+ }
+ if (new_percentage > 100) {
+ new_percentage = 100;
+ }
+
+ new_time_to_empty = estimate_time(reporting_rate, reporting_current, reporting_lastfull, discharging, charging);
+ if (new_time_to_empty < 0) { /* Need to do something more sane here */
+ new_time_to_empty = 0;
+ }
+
+ if (discharging)
+ new_state = UP_DEVICE_STATE_DISCHARGING;
+ else if (charging)
+ new_state = UP_DEVICE_STATE_CHARGING;
+
+ if (!discharging && !charging) {
+ if (new_percentage >= 99.0) {
+ new_state = UP_DEVICE_STATE_FULLY_CHARGED;
+ } else {
+ /* Really we should set UP_DEVICE_STATE_PENDING_CHARGE here,
+ but it seems that up_daemon can't sum up such device
+ and we end up in unkonw state, so let's say that we are charging */
+ new_state = UP_DEVICE_STATE_CHARGING;
+ }
+ }
+
+ if (cur_state != new_state ||
+ percentage != new_percentage ||
+ cur_time_to_empty != new_time_to_empty) {
+ g_object_set (device,
+ "state", new_state,
+ "percentage", new_percentage,
+ "time-to-empty", new_time_to_empty,
+ "is-present", TRUE,
+ (void*) NULL);
+ g_object_set (device,
+ "energy", ((gdouble) reporting_current)/1000.0,
+ "energy-full", ((gdouble) reporting_lastfull)/1000.0,
+ "energy-full-design", ((gdouble)reporting_design_capacity)/1000.0 ,
+ "energy-rate", ((gdouble) reporting_rate)/1000.0,
+ "energy-empty", ((gdouble) reporting_lowcap)/1000.0,
+ "voltage", (gdouble) present_voltage,
+ "capacity", new_percentage,
+ (void*) NULL);
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+static gboolean
+up_acpi_device_refresh(UpDevice* device)
+{
+ UpDeviceKind type;
+ gboolean ret;
+ g_object_get (device, "type", &type, NULL);
+
+ switch (type) {
+ case UP_DEVICE_KIND_LINE_POWER:
+ ret = up_backend_update_ac_state(device);
+ break;
+ case UP_DEVICE_KIND_BATTERY:
+ ret = up_backend_update_battery_state(device);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ g_object_set (device, "update-time", (guint64) g_get_real_time () / G_USEC_PER_SEC, NULL);
+
+ return TRUE;
+}
+
+/*
+ * Check the lid status, return TRUE if one was found, FALSE otherwise.
+ */
+static void
+up_backend_update_lid_status(UpDaemon *daemon)
+{
+ di_node_t root_node;
+ struct mdi_arg ma;
+ int state = 0;
+
+ ma.name = "lid";
+ ma.exact_match = TRUE;
+ ma.ctl = ACPI_DRV_IOC_LID_UPDATE;
+ ma.result = &state;
+ ma.device_path = NULL;
+
+ errno = 0;
+ if((root_node = di_init("/", DINFOSUBTREE|DINFOMINOR)) == DI_NODE_NIL) {
+ g_error("di_init() failed: %s", g_strerror(errno));
+ return;
+ }
+ di_walk_node(root_node, DI_WALK_CLDFIRST, &ma, minor_device_ioctl);
+ di_fini(root_node);
+
+ up_daemon_set_lid_is_present (daemon, ma.present);
+ if (ma.present)
+ up_daemon_set_lid_is_closed (daemon, state ? FALSE: TRUE);
+ if (ma.device_path)
+ g_free(ma.device_path);
+}
+
+static gboolean
+sysevent_iochannel_data(GIOChannel *source, GIOCondition condition, gpointer user_data)
+{
+ GError *err = NULL;
+ gchar *s = NULL;
+ gsize len;
+ UpBackend *backend;
+
+ backend = UP_BACKEND(user_data);
+
+ while (g_io_channel_read_line (sysevent_iochannel, &s, &len, NULL,
+ &err) == G_IO_STATUS_NORMAL) {
+ if (backend->priv->has_ac_device) {
+ up_acpi_device_refresh(backend->priv->ac);
+ }
+ if (backend->priv->has_bat_device) {
+ up_acpi_device_refresh(backend->priv->battery);
+ }
+ }
+
+ return TRUE;
+}
+
+static gboolean
+simulate_iochannel_data (gpointer data) {
+ write(sysevent_pipe_fds[1],"\n", strlen("\n"));
+
+ return TRUE;
+}
+
+static void
+up_backend_sysevent_dev_handler(sysevent_t *ev) {
+ char *class;
+ char *subclass;
+
+ if ((class = sysevent_get_class_name(ev)) == NULL)
+ return;
+
+ if ((subclass = sysevent_get_subclass_name(ev)) == NULL)
+ return;
+
+ if (strcmp(class, EC_PWRCTL) == 0) {
+ write(sysevent_pipe_fds[1],"\n", strlen("\n"));
+ }
+}
+
+static void
+up_backend_initialize_sysevent_handler(UpBackend *backend) {
+ const char *subcl[6];
+ GError *err = NULL;
+
+ if (pipe(sysevent_pipe_fds) != 0) {
+ g_warning("Failed to initialize sysevent pipe");
+ return;
+ }
+
+ sysevent_iochannel = g_io_channel_unix_new (sysevent_pipe_fds[0]);
+ if (sysevent_iochannel == NULL) {
+ g_warning("Failed to create sysevent iochannel");
+ return;
+ }
+ g_io_channel_set_flags (sysevent_iochannel, G_IO_FLAG_NONBLOCK, &err);
+ g_io_add_watch (sysevent_iochannel, G_IO_IN, sysevent_iochannel_data, backend);
+
+ shp = sysevent_bind_handle(up_backend_sysevent_dev_handler);
+ if (shp == NULL) {
+ g_warning("Failed to initialize sysevent handler");
+ return;
+ }
+
+ subcl[0] = ESC_PWRCTL_ADD;
+ subcl[1] = ESC_PWRCTL_REMOVE;
+ subcl[2] = ESC_PWRCTL_STATE_CHANGE;
+ subcl[3] = ESC_PWRCTL_BRIGHTNESS_UP;
+ subcl[4] = ESC_PWRCTL_BRIGHTNESS_DOWN;
+ subcl[5] = ESC_PWRCTL_POWER_BUTTON;
+
+ if (sysevent_subscribe_event(shp, EC_PWRCTL, subcl, 6) != 0) {
+ g_warning("Failed to subscribe to EC_PWRCTL events");
+ sysevent_unbind_handle(shp);
+ return;
+ }
+}
+
+
+/**
+ * GObject class functions
+ **/
+
+/**
+ * up_backend_new:
+ *
+ * Return value: a new %UpBackend object.
+ **/
+UpBackend *
+up_backend_new (void)
+{
+ return g_object_new (UP_TYPE_BACKEND, NULL);
+}
+
+/**
+ * up_backend_class_init:
+ * @klass: The UpBackendClass
+ **/
+static void
+up_backend_class_init (UpBackendClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ object_class->finalize = up_backend_finalize;
+
+ signals [SIGNAL_DEVICE_ADDED] =
+ g_signal_new ("device-added",
+ G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (UpBackendClass, device_added),
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER);
+ signals [SIGNAL_DEVICE_REMOVED] =
+ g_signal_new ("device-removed",
+ G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (UpBackendClass, device_removed),
+ NULL, NULL, NULL,
+ G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ g_type_class_add_private (klass, sizeof (UpBackendPrivate));
+}
+
+/**
+ * up_backend_init:
+ **/
+static void
+up_backend_init (UpBackend *backend)
+{
+ UpDeviceClass *device_class;
+ char *devpath = NULL;
+ gint64 current_time;
+
+ backend->priv = UP_BACKEND_GET_PRIVATE (backend);
+
+ devpath = up_backend_get_ac_device_path(ACPI_DRV_TYPE_AC);
+ if (devpath) {
+ backend->priv->has_ac_device = TRUE;
+ g_free(devpath);
+ } else {
+ backend->priv->has_ac_device = FALSE;
+ }
+
+ devpath = up_backend_get_ac_device_path(ACPI_DRV_TYPE_CBAT);
+ if (devpath) {
+ backend->priv->has_bat_device = TRUE;
+ g_free(devpath);
+ } else {
+ backend->priv->has_bat_device = FALSE;
+ }
+
+ current_time = g_get_real_time () / G_USEC_PER_SEC;
+ if (backend->priv->has_ac_device)
+ {
+ backend->priv->ac = UP_DEVICE(up_device_new());
+ device_class = UP_DEVICE_GET_CLASS (backend->priv->ac);
+ device_class->get_on_battery = up_acpi_device_get_on_battery;
+ device_class->get_online = up_acpi_device_get_online;
+ device_class->refresh = up_acpi_device_refresh;
+
+ /* setup dummy */
+ g_object_set (backend->priv->ac,
+ "type", UP_DEVICE_KIND_LINE_POWER,
+ "online", TRUE,
+ "power-supply", TRUE,
+ "update-time", (guint64) current_time,
+ (void*) NULL);
+ }
+
+ if (backend->priv->has_bat_device)
+ {
+ backend->priv->battery = UP_DEVICE(up_device_new ());
+ device_class = UP_DEVICE_GET_CLASS (backend->priv->battery);
+ device_class->get_on_battery = up_acpi_device_get_on_battery;
+ device_class->get_online = up_acpi_device_get_online;
+ device_class->refresh = up_acpi_device_refresh;
+
+ /* setup dummy */
+ g_object_set (backend->priv->battery,
+ "type", UP_DEVICE_KIND_BATTERY,
+ "power-supply", TRUE,
+ "is-present", TRUE,
+ "is-rechargeable", TRUE,
+ "has-history", TRUE,
+ "state", UP_DEVICE_STATE_UNKNOWN,
+ "percentage", 0.0f,
+ "time-to-empty", (gint64) 0,
+ "update-time", (guint64) current_time,
+ (void*) NULL);
+ }
+
+ if (backend->priv->has_bat_device || backend->priv->has_ac_device) {
+ /* Initialize sysevent handler */
+ up_backend_initialize_sysevent_handler(backend);
+ /* Some acpi devices are broken enough to avoid generating
+ EC_PWRCTL events, so we force update once per POLL_INTERVAL */
+ g_timeout_add (POLL_INTERVAL, simulate_iochannel_data, NULL);
+
+ }
+
+ backend->priv->config = up_config_new ();
+ backend->priv->seat_manager_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+ 0,
+ NULL,
+ CONSOLEKIT2_DBUS_NAME,
+ CONSOLEKIT2_DBUS_PATH,
+ CONSOLEKIT2_DBUS_INTERFACE,
+ NULL,
+ NULL);
+}
+/**
+ * up_backend_finalize:
+ **/
+static void
+up_backend_finalize (GObject *object)
+{
+ UpBackend *backend;
+
+ g_return_if_fail (UP_IS_BACKEND (object));
+
+ backend = UP_BACKEND (object);
+
+ sysevent_unbind_handle(shp);
+ shp = NULL;
+
+ g_object_unref (backend->priv->config);
+ if (backend->priv->daemon != NULL)
+ g_object_unref (backend->priv->daemon);
+ if (backend->priv->battery != NULL)
+ g_object_unref (backend->priv->battery);
+ if (backend->priv->ac != NULL)
+ g_object_unref (backend->priv->ac);
+ g_clear_object (&backend->priv->seat_manager_proxy);
+
+ G_OBJECT_CLASS (up_backend_parent_class)->finalize (object);
+}
+
+static int
+minor_device_ioctl(di_node_t node, void *arg)
+{
+ struct mdi_arg *st;
+ char *dn;
+
+ st = (struct mdi_arg*) arg;
+
+ st->present = FALSE;
+ st->success = FALSE;
+
+ dn=di_driver_name(node);
+ if (dn && !strcmp("acpi_drv",dn)) {
+ di_minor_t minor;
+
+ minor = DI_MINOR_NIL;
+ while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
+ char *dp, *fdp;
+ int fd;
+ char *mname;
+
+ dp=di_devfs_path(node);
+ if (!dp) {
+ g_warning("Couldn't get path for acpi_drv device");
+ continue;
+ }
+
+ mname = di_minor_name(minor);
+ if ((st->exact_match && strcmp(st->name, mname) != 0) ||
+ (!st->exact_match && strncmp(st->name, mname, strlen(st->name)) != 0)) {
+ g_debug("Device %s is not a %s. Skipping.", mname, st->name);
+ di_devfs_path_free(dp);
+ continue;
+ }
+ fdp = g_strconcat(DEVFS_PREFIX, dp,":", di_minor_name(minor), NULL);
+ if (!fdp) {
+ g_warning("Couldn't allocate memory");
+ di_devfs_path_free(dp);
+ continue;
+ }
+
+ fd = open(fdp, O_RDONLY);
+ if (fd == -1) {
+ g_warning("Couldn't open %s device", fdp);
+ di_devfs_path_free(dp);
+ g_free(fdp);
+ continue;
+ }
+
+ st->present = TRUE;
+ st->device_path = fdp;
+
+ if (ioctl(fd, st->ctl, st->result) < 0) {
+ st->success = FALSE;
+ g_warning("ioctl %d to device %s failed", st->ctl, fdp);
+ } else {
+ st->success = TRUE;
+ }
+
+ close(fd);
+ di_devfs_path_free(dp);
+ return DI_WALK_TERMINATE;
+ }
+ }
+ return DI_WALK_CONTINUE;
+}
+
+static char*
+up_backend_get_ac_device_path(enum acpi_drv_type device)
+{
+ di_node_t root_node;
+
+ struct mdi_arg ma;
+ int state = 0;
+ acpi_bif_t bif;
+
+ switch (device) {
+ case ACPI_DRV_TYPE_CBAT:
+ ma.name = "battery";
+ ma.ctl = ACPI_DRV_IOC_INFO;
+ ma.exact_match = FALSE;
+ /* We don't do it as we ignore result anyway */
+ /* memset(&bif, 0, sizeof(bif));*/
+ ma.result = &bif;
+ break;
+ case ACPI_DRV_TYPE_AC:
+ ma.name = "ac";
+ ma.ctl = ACPI_DRV_IOC_POWER_STATUS;
+ ma.exact_match = FALSE;
+ ma.result = &state;
+ break;
+ default:
+ return NULL;
+ }
+
+ ma.device_path = NULL;
+
+ errno = 0;
+ if((root_node = di_init("/", DINFOSUBTREE|DINFOMINOR)) == DI_NODE_NIL) {
+ g_error("di_init() failed: %s", g_strerror(errno));
+ return FALSE;
+ }
+ di_walk_node(root_node, DI_WALK_CLDFIRST, &ma, minor_device_ioctl);
+ di_fini(root_node);
+ return ma.device_path;
+}
+
+static int
+up_backend_acpi_get_ac_online()
+{
+ di_node_t root_node;
+
+ struct mdi_arg ma;
+ int state = 0;
+
+ ma.name = "ac";
+ ma.exact_match = FALSE;
+ ma.ctl = ACPI_DRV_IOC_POWER_STATUS;
+ ma.result = &state;
+ ma.device_path = NULL;
+
+ errno = 0;
+ if((root_node = di_init("/", DINFOSUBTREE|DINFOMINOR)) == DI_NODE_NIL) {
+ g_error("di_init() failed: %s", g_strerror(errno));
+ return FALSE;
+ }
+ di_walk_node(root_node, DI_WALK_CLDFIRST, &ma, minor_device_ioctl);
+ di_fini(root_node);
+ if (ma.device_path)
+ g_free(ma.device_path);
+ if (!ma.success)
+ state = -1;
+ return state;
+}
+
+static int
+estimate_time(int charge_rate, int current_charge, int last_fullcharge, int is_discharging, int is_charging)
+{
+ int rem_secs = 0;
+ if (charge_rate > 0 && last_fullcharge >= current_charge && (is_discharging ^ is_charging)) {
+ if (is_discharging) {
+ rem_secs = ((double) current_charge / (double) charge_rate) * 60 * 60;
+ } else {
+ rem_secs = (((double)(last_fullcharge - current_charge))/ (double) charge_rate) * 60 * 60;
+ }
+ return rem_secs;
+ } else {
+ /* Can't estimate time */
+ return -1;
+ }
+}
diff -urN upower-0.99.4-orig/src/illumos/up-native.c upower-0.99.4/src/illumos/up-native.c
--- upower-0.99.4-orig/src/illumos/up-native.c 1970-01-01 03:00:00.000000000 +0000
+++ upower-0.99.4/src/illumos/up-native.c 2017-12-26 13:49:53.077225711 +0000
@@ -0,0 +1,68 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2011 Landry Breuil <landry@openbsd.org>
+ * Copyright (C) 2018 Alexander Pyhalov <apyhalov@gmail.com>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "up-acpi-native.h"
+#include "up-native.h"
+#include <unistd.h> /* close() */
+#include <string.h> /* strcmp() */
+
+G_DEFINE_TYPE (UpAcpiNative, up_acpi_native, G_TYPE_OBJECT)
+
+static void
+up_acpi_native_class_init (UpAcpiNativeClass *klass)
+{
+}
+
+static void
+up_acpi_native_init (UpAcpiNative *self)
+{
+ self->path = NULL;
+}
+
+UpAcpiNative *
+up_acpi_native_new(const gchar * path)
+{
+ UpAcpiNative *native;
+ native = UP_ACPI_NATIVE (g_object_new (UP_TYPE_ACPI_NATIVE, NULL));
+ native->path = g_strdup(path);
+ return native;
+}
+
+const gchar *
+up_acpi_native_get_path(UpAcpiNative * native)
+{
+ return native->path;
+}
+
+/**
+ * up_native_get_native_path:
+ * @object: the native tracking object
+ *
+ * This converts a GObject used as the device data into a native path.
+ *
+ * Return value: The native path for the device which is unique, e.g. "/devices/pseudo/acpi_drv@0:battery0"
+ **/
+const gchar *
+up_native_get_native_path (GObject *object)
+{
+ return up_acpi_native_get_path (UP_ACPI_NATIVE (object));
+}