[thirdparty/systemd.git] / src / backlight / backlight.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include "util.h"
#include "mkdir.h"
#include "fileio.h"
#include "libudev.h"
#include "udev-util.h"
#include "def.h"

static struct udev_device *find_pci_or_platform_parent(struct udev_device *device) {
        struct udev_device *parent;
        const char *subsystem, *sysname;

        assert(device);

        parent = udev_device_get_parent(device);
        if (!parent)
                return NULL;

        subsystem = udev_device_get_subsystem(parent);
        if (!subsystem)
                return NULL;

        sysname = udev_device_get_sysname(parent);
        if (!sysname)
                return NULL;

        if (streq(subsystem, "drm")) {
                const char *c;

                c = startswith(sysname, "card");
                if (!c)
                        return NULL;

                c += strspn(c, DIGITS);
                if (*c == '-') {
                        /* A connector DRM device, let's ignore all but LVDS and eDP! */

                        if (!startswith(c, "-LVDS-") &&
                            !startswith(c, "-Embedded DisplayPort-"))
                                return NULL;
                }

        } else if (streq(subsystem, "pci")) {
                const char *value;

                value = udev_device_get_sysattr_value(parent, "class");
                if (value) {
                        unsigned long class = 0;

                        if (safe_atolu(value, &class) < 0) {
                                log_warning("Cannot parse PCI class %s of device %s:%s.",
                                            value, subsystem, sysname);
                                return NULL;
                        }

                        /* Graphics card */
                        if (class == 0x30000)
                                return parent;
                }

        } else if (streq(subsystem, "platform"))
                return parent;

        return find_pci_or_platform_parent(parent);
}

static bool same_device(struct udev_device *a, struct udev_device *b) {
        assert(a);
        assert(b);

        if (!streq_ptr(udev_device_get_subsystem(a), udev_device_get_subsystem(b)))
                return false;

        if (!streq_ptr(udev_device_get_sysname(a), udev_device_get_sysname(b)))
                return false;

        return true;
}

static bool validate_device(struct udev *udev, struct udev_device *device) {
        _cleanup_udev_enumerate_unref_ struct udev_enumerate *enumerate = NULL;
        struct udev_list_entry *item = NULL, *first = NULL;
        struct udev_device *parent;
        const char *v, *subsystem;
        int r;

        assert(udev);
        assert(device);

        /* Verify whether we should actually care for a specific
         * backlight device. For backlight devices there might be
         * multiple ways to access the same control: "firmware"
         * (i.e. ACPI), "platform" (i.e. via the machine's EC) and
         * "raw" (via the graphics card). In general we should prefer
         * "firmware" (i.e. ACPI) or "platform" access over "raw"
         * access, in order not to confuse the BIOS/EC, and
         * compatibility with possible low-level hotkey handling of
         * screen brightness. The kernel will already make sure to
         * expose only one of "firmware" and "platform" for the same
         * device to userspace. However, we still need to make sure
         * that we use "raw" only if no "firmware" or "platform"
         * device for the same device exists. */

        subsystem = udev_device_get_subsystem(device);
        if (!streq_ptr(subsystem, "backlight"))
                return true;

        v = udev_device_get_sysattr_value(device, "type");
        if (!streq_ptr(v, "raw"))
                return true;

        parent = find_pci_or_platform_parent(device);
        if (!parent)
                return true;

        subsystem = udev_device_get_subsystem(parent);
        if (!subsystem)
                return true;

        enumerate = udev_enumerate_new(udev);
        if (!enumerate)
                return true;

        r = udev_enumerate_add_match_subsystem(enumerate, "backlight");
        if (r < 0)
                return true;

        r = udev_enumerate_scan_devices(enumerate);
        if (r < 0)
                return true;

        first = udev_enumerate_get_list_entry(enumerate);
        udev_list_entry_foreach(item, first) {
                _cleanup_udev_device_unref_ struct udev_device *other;
                struct udev_device *other_parent;
                const char *other_subsystem;

                other = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
                if (!other)
                        return true;

                if (same_device(device, other))
                        continue;

                v = udev_device_get_sysattr_value(other, "type");
                if (!streq_ptr(v, "platform") && !streq_ptr(v, "firmware"))
                        continue;

                /* OK, so there's another backlight device, and it's a
                 * platform or firmware device, so, let's see if we
                 * can verify it belongs to the same device as
                 * ours. */
                other_parent = find_pci_or_platform_parent(other);
                if (!other_parent)
                        continue;

                if (same_device(parent, other_parent)) {
                        /* Both have the same PCI parent, that means
                         * we are out. */
                        log_debug("Skipping backlight device %s, since device %s is on same PCI device and takes precedence.",
                                  udev_device_get_sysname(device),
                                  udev_device_get_sysname(other));
                        return false;
                }

                other_subsystem = udev_device_get_subsystem(other_parent);
                if (streq_ptr(other_subsystem, "platform") && streq_ptr(subsystem, "pci")) {
                        /* The other is connected to the platform bus
                         * and we are a PCI device, that also means we
                         * are out. */
                        log_debug("Skipping backlight device %s, since device %s is a platform device and takes precedence.",
                                  udev_device_get_sysname(device),
                                  udev_device_get_sysname(other));
                        return false;
                }
        }

        return true;
}

static unsigned get_max_brightness(struct udev_device *device) {
        int r;
        const char *max_brightness_str;
        unsigned max_brightness;

        max_brightness_str = udev_device_get_sysattr_value(device, "max_brightness");
        if (!max_brightness_str) {
                log_warning("Failed to read 'max_brightness' attribute.");
                return 0;
        }

        r = safe_atou(max_brightness_str, &max_brightness);
        if (r < 0) {
                log_warning("Failed to parse 'max_brightness' \"%s\": %s", max_brightness_str, strerror(-r));
                return 0;
        }

        if (max_brightness <= 0) {
                log_warning("Maximum brightness is 0, ignoring device.");
                return 0;
        }

        return max_brightness;
}

/* Some systems turn the backlight all the way off at the lowest levels.
 * clamp_brightness clamps the saved brightness to at least 1 or 5% of
 * max_brightness in case of 'backlight' subsystem. This avoids preserving
 * an unreadably dim screen, which would otherwise force the user to
 * disable state restoration. */
static void clamp_brightness(struct udev_device *device, char **value, unsigned max_brightness) {
        int r;
        unsigned brightness, new_brightness, min_brightness;
        const char *subsystem;

        r = safe_atou(*value, &brightness);
        if (r < 0) {
                log_warning("Failed to parse brightness \"%s\": %s", *value, strerror(-r));
                return;
        }

        subsystem = udev_device_get_subsystem(device);
        if (streq_ptr(subsystem, "backlight"))
                min_brightness = MAX(1U, max_brightness/20);
        else
                min_brightness = 0;

        new_brightness = CLAMP(brightness, min_brightness, max_brightness);
        if (new_brightness != brightness) {
                char *old_value = *value;

                r = asprintf(value, "%u", new_brightness);
                if (r < 0) {
                        log_oom();
                        return;
                }

                log_info("Saved brightness %s %s to %s.", old_value,
                         new_brightness > brightness ?
                         "too low; increasing" : "too high; decreasing",
                         *value);

                free(old_value);
        }
}

int main(int argc, char *argv[]) {
        _cleanup_udev_unref_ struct udev *udev = NULL;
        _cleanup_udev_device_unref_ struct udev_device *device = NULL;
        _cleanup_free_ char *saved = NULL, *ss = NULL, *escaped_ss = NULL, *escaped_sysname = NULL, *escaped_path_id = NULL;
        const char *sysname, *path_id;
        unsigned max_brightness;
        int r;

        if (argc != 3) {
                log_error("This program requires two arguments.");
                return EXIT_FAILURE;
        }

        log_set_target(LOG_TARGET_AUTO);
        log_parse_environment();
        log_open();

        umask(0022);

        r = mkdir_p("/var/lib/systemd/backlight", 0755);
        if (r < 0) {
                log_error("Failed to create backlight directory /var/lib/systemd/backlight: %s",
                          strerror(-r));
                return EXIT_FAILURE;
        }

        udev = udev_new();
        if (!udev) {
                log_oom();
                return EXIT_FAILURE;
        }

        sysname = strchr(argv[2], ':');
        if (!sysname) {
                log_error("Requires a subsystem and sysname pair specifying a backlight device.");
                return EXIT_FAILURE;
        }

        ss = strndup(argv[2], sysname - argv[2]);
        if (!ss) {
                log_oom();
                return EXIT_FAILURE;
        }

        sysname++;

        if (!streq(ss, "backlight") && !streq(ss, "leds")) {
                log_error("Not a backlight or LED device: '%s:%s'", ss, sysname);
                return EXIT_FAILURE;
        }

        errno = 0;
        device = udev_device_new_from_subsystem_sysname(udev, ss, sysname);
        if (!device) {
                if (errno != 0)
                        log_error("Failed to get backlight or LED device '%s:%s': %m", ss, sysname);
                else
                        log_oom();

                return EXIT_FAILURE;
        }

        /* If max_brightness is 0, then there is no actual backlight
         * device. This happens on desktops with Asus mainboards
         * that load the eeepc-wmi module.
         */
        max_brightness = get_max_brightness(device);
        if (max_brightness == 0)
                return EXIT_SUCCESS;

        escaped_ss = cescape(ss);
        if (!escaped_ss) {
                log_oom();
                return EXIT_FAILURE;
        }

        escaped_sysname = cescape(sysname);
        if (!escaped_sysname) {
                log_oom();
                return EXIT_FAILURE;
        }

        path_id = udev_device_get_property_value(device, "ID_PATH");
        if (path_id) {
                escaped_path_id = cescape(path_id);
                if (!escaped_path_id) {
                        log_oom();
                        return EXIT_FAILURE;
                }

                saved = strjoin("/var/lib/systemd/backlight/", escaped_path_id, ":", escaped_ss, ":", escaped_sysname, NULL);
        } else
                saved = strjoin("/var/lib/systemd/backlight/", escaped_ss, ":", escaped_sysname, NULL);

        if (!saved) {
                log_oom();
                return EXIT_FAILURE;
        }

        /* If there are multiple conflicting backlight devices, then
         * their probing at boot-time might happen in any order. This
         * means the validity checking of the device then is not
         * reliable, since it might not see other devices conflicting
         * with a specific backlight. To deal with this, we will
         * actively delete backlight state files at shutdown (where
         * device probing should be complete), so that the validity
         * check at boot time doesn't have to be reliable. */

        if (streq(argv[1], "load") && shall_restore_state()) {
                _cleanup_free_ char *value = NULL;

                if (!validate_device(udev, device))
                        return EXIT_SUCCESS;

                r = read_one_line_file(saved, &value);
                if (r < 0) {

                        if (r == -ENOENT)
                                return EXIT_SUCCESS;

                        log_error("Failed to read %s: %s", saved, strerror(-r));
                        return EXIT_FAILURE;
                }

                clamp_brightness(device, &value, max_brightness);

                r = udev_device_set_sysattr_value(device, "brightness", value);
                if (r < 0) {
                        log_error("Failed to write system 'brightness' attribute: %s",
                                  strerror(-r));
                        return EXIT_FAILURE;
                }

        } else if (streq(argv[1], "save")) {
                const char *value;

                if (!validate_device(udev, device)) {
                        unlink(saved);
                        return EXIT_SUCCESS;
                }

                value = udev_device_get_sysattr_value(device, "brightness");
                if (!value) {
                        log_error("Failed to read system 'brightness' attribute");
                        return EXIT_FAILURE;
                }

                r = write_string_file(saved, value);
                if (r < 0) {
                        log_error("Failed to write %s: %s", saved, strerror(-r));
                        return EXIT_FAILURE;
                }

        } else {
                log_error("Unknown verb %s.", argv[1]);
                return EXIT_FAILURE;
        }

        return EXIT_SUCCESS;
}
Commit	Line	Data
3731acf1 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
3731acf1 LP	22	#include "util.h"
	23	#include "mkdir.h"
	24	#include "fileio.h"
1ca208fb ZJS	25	#include "libudev.h"
1ca208fb ZJS	26	#include "udev-util.h"
938d2699	27	#include "def.h"
3731acf1	28
0f4ba83c LP	29	static struct udev_device find_pci_or_platform_parent(struct udev_device device) {
	30	struct udev_device *parent;
	31	const char subsystem, sysname;
	32
	33	assert(device);
	34
	35	parent = udev_device_get_parent(device);
	36	if (!parent)
	37	return NULL;
	38
	39	subsystem = udev_device_get_subsystem(parent);
	40	if (!subsystem)
	41	return NULL;
	42
	43	sysname = udev_device_get_sysname(parent);
	44	if (!sysname)
	45	return NULL;
	46
	47	if (streq(subsystem, "drm")) {
	48	const char *c;
	49
	50	c = startswith(sysname, "card");
	51	if (!c)
	52	return NULL;
	53
938d2699	54	c += strspn(c, DIGITS);
0f4ba83c LP	55	if (*c == '-') {
	56	/* A connector DRM device, let's ignore all but LVDS and eDP! */
	57
	58	if (!startswith(c, "-LVDS-") &&
	59	!startswith(c, "-Embedded DisplayPort-"))
	60	return NULL;
	61	}
	62
	63	} else if (streq(subsystem, "pci")) {
	64	const char *value;
	65
	66	value = udev_device_get_sysattr_value(parent, "class");
	67	if (value) {
39883f62	68	unsigned long class = 0;
0f4ba83c LP	69
0f4ba83c LP	70	if (safe_atolu(value, &class) < 0) {
938d2699 ZJS	71	log_warning("Cannot parse PCI class %s of device %s:%s.",
938d2699 ZJS	72	value, subsystem, sysname);
0f4ba83c LP	73	return NULL;
	74	}
	75
	76	/* Graphics card */
	77	if (class == 0x30000)
	78	return parent;
	79	}
	80
	81	} else if (streq(subsystem, "platform"))
	82	return parent;
	83
	84	return find_pci_or_platform_parent(parent);
	85	}
	86
	87	static bool same_device(struct udev_device a, struct udev_device b) {
	88	assert(a);
	89	assert(b);
	90
	91	if (!streq_ptr(udev_device_get_subsystem(a), udev_device_get_subsystem(b)))
	92	return false;
	93
	94	if (!streq_ptr(udev_device_get_sysname(a), udev_device_get_sysname(b)))
	95	return false;
	96
	97	return true;
	98	}
	99
	100	static bool validate_device(struct udev udev, struct udev_device device) {
	101	_cleanup_udev_enumerate_unref_ struct udev_enumerate *enumerate = NULL;
	102	struct udev_list_entry item = NULL, first = NULL;
	103	struct udev_device *parent;
	104	const char v, subsystem;
	105	int r;
	106
	107	assert(udev);
	108	assert(device);
	109
	110	/* Verify whether we should actually care for a specific
	111	* backlight device. For backlight devices there might be
	112	* multiple ways to access the same control: "firmware"
	113	* (i.e. ACPI), "platform" (i.e. via the machine's EC) and
	114	* "raw" (via the graphics card). In general we should prefer
	115	* "firmware" (i.e. ACPI) or "platform" access over "raw"
	116	* access, in order not to confuse the BIOS/EC, and
	117	* compatibility with possible low-level hotkey handling of
	118	* screen brightness. The kernel will already make sure to
	119	* expose only one of "firmware" and "platform" for the same
	120	* device to userspace. However, we still need to make sure
	121	* that we use "raw" only if no "firmware" or "platform"
	122	* device for the same device exists. */
	123
	124	subsystem = udev_device_get_subsystem(device);
	125	if (!streq_ptr(subsystem, "backlight"))
	126	return true;
	127
	128	v = udev_device_get_sysattr_value(device, "type");
	129	if (!streq_ptr(v, "raw"))
	130	return true;
	131
	132	parent = find_pci_or_platform_parent(device);
	133	if (!parent)
	134	return true;
	135
	136	subsystem = udev_device_get_subsystem(parent);
137	if (!subsystem)
138	return true;
139
140	enumerate = udev_enumerate_new(udev);
141	if (!enumerate)
142	return true;
143
144	r = udev_enumerate_add_match_subsystem(enumerate, "backlight");
145	if (r < 0)
146	return true;
147
148	r = udev_enumerate_scan_devices(enumerate);
149	if (r < 0)
150	return true;
151
152	first = udev_enumerate_get_list_entry(enumerate);
153	udev_list_entry_foreach(item, first) {
154	_cleanup_udev_device_unref_ struct udev_device *other;
155	struct udev_device *other_parent;
156	const char *other_subsystem;
157
158	other = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
159	if (!other)
160	return true;
161
162	if (same_device(device, other))
163	continue;
164
165	v = udev_device_get_sysattr_value(other, "type");
166	if (!streq_ptr(v, "platform") && !streq_ptr(v, "firmware"))
167	continue;
168
169	/* OK, so there's another backlight device, and it's a
170	* platform or firmware device, so, let's see if we
171	* can verify it belongs to the same device as
172	* ours. */
173	other_parent = find_pci_or_platform_parent(other);
174	if (!other_parent)
175	continue;
176
177	if (same_device(parent, other_parent)) {
178	/* Both have the same PCI parent, that means
179	* we are out. */
938d2699 ZJS	180	log_debug("Skipping backlight device %s, since device %s is on same PCI device and takes precedence.",
	181	udev_device_get_sysname(device),
	182	udev_device_get_sysname(other));
0f4ba83c LP	183	return false;
	184	}
	185
	186	other_subsystem = udev_device_get_subsystem(other_parent);
	187	if (streq_ptr(other_subsystem, "platform") && streq_ptr(subsystem, "pci")) {
	188	/* The other is connected to the platform bus
	189	* and we are a PCI device, that also means we
	190	* are out. */
938d2699 ZJS	191	log_debug("Skipping backlight device %s, since device %s is a platform device and takes precedence.",
	192	udev_device_get_sysname(device),
	193	udev_device_get_sysname(other));
0f4ba83c LP	194	return false;
	195	}
	196	}
	197
	198	return true;
	199	}
	200
3cadce7d	201	static unsigned get_max_brightness(struct udev_device *device) {
7b909d74 JT	202	int r;
7b909d74 JT	203	const char *max_brightness_str;
3cadce7d	204	unsigned max_brightness;
7b909d74 JT	205
	206	max_brightness_str = udev_device_get_sysattr_value(device, "max_brightness");
	207	if (!max_brightness_str) {
c7fdf44d	208	log_warning("Failed to read 'max_brightness' attribute.");
3cadce7d	209	return 0;
7b909d74 JT	210	}
7b909d74 JT	211
3cadce7d	212	r = safe_atou(max_brightness_str, &max_brightness);
7b909d74	213	if (r < 0) {
c7fdf44d LP	214	log_warning("Failed to parse 'max_brightness' \"%s\": %s", max_brightness_str, strerror(-r));
	215	return 0;
	216	}
	217
	218	if (max_brightness <= 0) {
	219	log_warning("Maximum brightness is 0, ignoring device.");
3cadce7d	220	return 0;
7b909d74 JT	221	}
7b909d74 JT	222
3cadce7d TB	223	return max_brightness;
	224	}
	225
	226	/* Some systems turn the backlight all the way off at the lowest levels.
	227	* clamp_brightness clamps the saved brightness to at least 1 or 5% of
4cd2b2cf DT	228	* max_brightness in case of 'backlight' subsystem. This avoids preserving
	229	* an unreadably dim screen, which would otherwise force the user to
	230	* disable state restoration. */
3cadce7d TB	231	static void clamp_brightness(struct udev_device device, char *value, unsigned max_brightness) {
3cadce7d TB	232	int r;
0c9d8f1d	233	unsigned brightness, new_brightness, min_brightness;
4cd2b2cf	234	const char *subsystem;
3cadce7d TB	235
3cadce7d TB	236	r = safe_atou(*value, &brightness);
7b909d74	237	if (r < 0) {
3cadce7d	238	log_warning("Failed to parse brightness \"%s\": %s", *value, strerror(-r));
7b909d74 JT	239	return;
	240	}
	241
4cd2b2cf DT	242	subsystem = udev_device_get_subsystem(device);
	243	if (streq_ptr(subsystem, "backlight"))
	244	min_brightness = MAX(1U, max_brightness/20);
	245	else
	246	min_brightness = 0;
	247
0c9d8f1d	248	new_brightness = CLAMP(brightness, min_brightness, max_brightness);
7b909d74 JT	249	if (new_brightness != brightness) {
	250	char old_value = value;
	251
	252	r = asprintf(value, "%u", new_brightness);
	253	if (r < 0) {
	254	log_oom();
	255	return;
	256	}
	257
0c9d8f1d JN	258	log_info("Saved brightness %s %s to %s.", old_value,
	259	new_brightness > brightness ?
	260	"too low; increasing" : "too high; decreasing",
	261	*value);
	262
7b909d74 JT	263	free(old_value);
	264	}
	265	}
	266
3731acf1	267	int main(int argc, char *argv[]) {
1ca208fb ZJS	268	_cleanup_udev_unref_ struct udev *udev = NULL;
1ca208fb ZJS	269	_cleanup_udev_device_unref_ struct udev_device *device = NULL;
be3f52f4 LP	270	_cleanup_free_ char saved = NULL, ss = NULL, escaped_ss = NULL, escaped_sysname = NULL, *escaped_path_id = NULL;
be3f52f4 LP	271	const char sysname, path_id;
3cadce7d	272	unsigned max_brightness;
3731acf1 LP	273	int r;
	274
	275	if (argc != 3) {
	276	log_error("This program requires two arguments.");
	277	return EXIT_FAILURE;
	278	}
	279
	280	log_set_target(LOG_TARGET_AUTO);
	281	log_parse_environment();
	282	log_open();
	283
	284	umask(0022);
	285
ef5bfcf6	286	r = mkdir_p("/var/lib/systemd/backlight", 0755);
3731acf1	287	if (r < 0) {
938d2699 ZJS	288	log_error("Failed to create backlight directory /var/lib/systemd/backlight: %s",
938d2699 ZJS	289	strerror(-r));
1ca208fb	290	return EXIT_FAILURE;
3731acf1 LP	291	}
	292
	293	udev = udev_new();
	294	if (!udev) {
1ca208fb ZJS	295	log_oom();
1ca208fb ZJS	296	return EXIT_FAILURE;
3731acf1 LP	297	}
3731acf1 LP	298
0f4ba83c LP	299	sysname = strchr(argv[2], ':');
0f4ba83c LP	300	if (!sysname) {
938d2699	301	log_error("Requires a subsystem and sysname pair specifying a backlight device.");
0f4ba83c LP	302	return EXIT_FAILURE;
	303	}
	304
	305	ss = strndup(argv[2], sysname - argv[2]);
	306	if (!ss) {
	307	log_oom();
	308	return EXIT_FAILURE;
	309	}
	310
	311	sysname++;
	312
	313	if (!streq(ss, "backlight") && !streq(ss, "leds")) {
	314	log_error("Not a backlight or LED device: '%s:%s'", ss, sysname);
	315	return EXIT_FAILURE;
	316	}
	317
875c6e1b	318	errno = 0;
0f4ba83c	319	device = udev_device_new_from_subsystem_sysname(udev, ss, sysname);
3731acf1	320	if (!device) {
1ca208fb	321	if (errno != 0)
0f4ba83c	322	log_error("Failed to get backlight or LED device '%s:%s': %m", ss, sysname);
1ca208fb	323	else
0f4ba83c	324	log_oom();
3731acf1	325
1ca208fb	326	return EXIT_FAILURE;
3731acf1 LP	327	}
3731acf1 LP	328
3cadce7d TB	329	/* If max_brightness is 0, then there is no actual backlight
	330	* device. This happens on desktops with Asus mainboards
	331	* that load the eeepc-wmi module.
	332	*/
	333	max_brightness = get_max_brightness(device);
	334	if (max_brightness == 0)
	335	return EXIT_SUCCESS;
	336
be3f52f4 LP	337	escaped_ss = cescape(ss);
	338	if (!escaped_ss) {
	339	log_oom();
	340	return EXIT_FAILURE;
	341	}
	342
	343	escaped_sysname = cescape(sysname);
	344	if (!escaped_sysname) {
	345	log_oom();
	346	return EXIT_FAILURE;
	347	}
	348
	349	path_id = udev_device_get_property_value(device, "ID_PATH");
	350	if (path_id) {
	351	escaped_path_id = cescape(path_id);
	352	if (!escaped_path_id) {
	353	log_oom();
	354	return EXIT_FAILURE;
	355	}
	356
	357	saved = strjoin("/var/lib/systemd/backlight/", escaped_path_id, ":", escaped_ss, ":", escaped_sysname, NULL);
	358	} else
	359	saved = strjoin("/var/lib/systemd/backlight/", escaped_ss, ":", escaped_sysname, NULL);
	360
3731acf1	361	if (!saved) {
1ca208fb ZJS	362	log_oom();
1ca208fb ZJS	363	return EXIT_FAILURE;
3731acf1 LP	364	}
3731acf1 LP	365
0f4ba83c LP	366	/* If there are multiple conflicting backlight devices, then
	367	* their probing at boot-time might happen in any order. This
	368	* means the validity checking of the device then is not
	369	* reliable, since it might not see other devices conflicting
73e231ab	370	* with a specific backlight. To deal with this, we will
0f4ba83c LP	371	* actively delete backlight state files at shutdown (where
	372	* device probing should be complete), so that the validity
	373	* check at boot time doesn't have to be reliable. */
	374
74df0fca	375	if (streq(argv[1], "load") && shall_restore_state()) {
3731acf1 LP	376	_cleanup_free_ char *value = NULL;
3731acf1 LP	377
0f4ba83c LP	378	if (!validate_device(udev, device))
	379	return EXIT_SUCCESS;
	380
3731acf1 LP	381	r = read_one_line_file(saved, &value);
	382	if (r < 0) {
	383
1ca208fb ZJS	384	if (r == -ENOENT)
1ca208fb ZJS	385	return EXIT_SUCCESS;
3731acf1 LP	386
3731acf1 LP	387	log_error("Failed to read %s: %s", saved, strerror(-r));
1ca208fb	388	return EXIT_FAILURE;
3731acf1 LP	389	}
3731acf1 LP	390
3cadce7d	391	clamp_brightness(device, &value, max_brightness);
7b909d74	392
3731acf1 LP	393	r = udev_device_set_sysattr_value(device, "brightness", value);
3731acf1 LP	394	if (r < 0) {
938d2699 ZJS	395	log_error("Failed to write system 'brightness' attribute: %s",
938d2699 ZJS	396	strerror(-r));
1ca208fb	397	return EXIT_FAILURE;
3731acf1 LP	398	}
	399
	400	} else if (streq(argv[1], "save")) {
	401	const char *value;
	402
0f4ba83c LP	403	if (!validate_device(udev, device)) {
	404	unlink(saved);
	405	return EXIT_SUCCESS;
	406	}
	407
3731acf1 LP	408	value = udev_device_get_sysattr_value(device, "brightness");
3731acf1 LP	409	if (!value) {
938d2699	410	log_error("Failed to read system 'brightness' attribute");
1ca208fb	411	return EXIT_FAILURE;
3731acf1 LP	412	}
	413
	414	r = write_string_file(saved, value);
	415	if (r < 0) {
	416	log_error("Failed to write %s: %s", saved, strerror(-r));
1ca208fb	417	return EXIT_FAILURE;
3731acf1 LP	418	}
	419
	420	} else {
	421	log_error("Unknown verb %s.", argv[1]);
1ca208fb	422	return EXIT_FAILURE;
3731acf1 LP	423	}
3731acf1 LP	424
1ca208fb	425	return EXIT_SUCCESS;
3731acf1	426	}