src/login/logind-button.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <fcntl.h>
   5 #include <sys/ioctl.h>
   6 #include <unistd.h>
   7
   8 #include "sd-messages.h"
   9
  10 #include "alloc-util.h"
  11 #include "fd-util.h"
  12 #include "logind-button.h"
  13 #include "missing_input.h"
  14 #include "string-util.h"
  15 #include "util.h"
  16
  17 #define CONST_MAX4(a, b, c, d) CONST_MAX(CONST_MAX(a, b), CONST_MAX(c, d))
  18
  19 #define ULONG_BITS (sizeof(unsigned long)*8)
  20
  21 static bool bitset_get(const unsigned long *bits, unsigned i) {
  22         return (bits[i / ULONG_BITS] >> (i % ULONG_BITS)) & 1UL;
  23 }
  24
  25 static void bitset_put(unsigned long *bits, unsigned i) {
  26         bits[i / ULONG_BITS] |= (unsigned long) 1 << (i % ULONG_BITS);
  27 }
  28
  29 Button* button_new(Manager *m, const char *name) {
  30         Button *b;
  31
  32         assert(m);
  33         assert(name);
  34
  35         b = new0(Button, 1);
  36         if (!b)
  37                 return NULL;
  38
  39         b->name = strdup(name);
  40         if (!b->name)
  41                 return mfree(b);
  42
  43         if (hashmap_put(m->buttons, b->name, b) < 0) {
  44                 free(b->name);
  45                 return mfree(b);
  46         }
  47
  48         b->manager = m;
  49         b->fd = -1;
  50
  51         return b;
  52 }
  53
  54 void button_free(Button *b) {
  55         assert(b);
  56
  57         hashmap_remove(b->manager->buttons, b->name);
  58
  59         sd_event_source_unref(b->io_event_source);
  60         sd_event_source_unref(b->check_event_source);
  61
  62         if (b->fd >= 0)
  63                 /* If the device has been unplugged close() returns
  64                  * ENODEV, let's ignore this, hence we don't use
  65                  * safe_close() */
  66                 (void) close(b->fd);
  67
  68         free(b->name);
  69         free(b->seat);
  70         free(b);
  71 }
  72
  73 int button_set_seat(Button *b, const char *sn) {
  74         char *s;
  75
  76         assert(b);
  77         assert(sn);
  78
  79         s = strdup(sn);
  80         if (!s)
  81                 return -ENOMEM;
  82
  83         free(b->seat);
  84         b->seat = s;
  85
  86         return 0;
  87 }
  88
  89 static void button_lid_switch_handle_action(Manager *manager, bool is_edge) {
  90         HandleAction handle_action;
  91
  92         assert(manager);
  93
  94         /* If we are docked or on external power, handle the lid switch
  95          * differently */
  96         if (manager_is_docked_or_external_displays(manager))
  97                 handle_action = manager->handle_lid_switch_docked;
  98         else if (manager->handle_lid_switch_ep != _HANDLE_ACTION_INVALID &&
  99                  manager_is_on_external_power())
 100                 handle_action = manager->handle_lid_switch_ep;
 101         else
 102                 handle_action = manager->handle_lid_switch;
 103
 104         manager_handle_action(manager, INHIBIT_HANDLE_LID_SWITCH, handle_action, manager->lid_switch_ignore_inhibited, is_edge);
 105 }
 106
 107 static int button_recheck(sd_event_source *e, void *userdata) {
 108         Button *b = userdata;
 109
 110         assert(b);
 111         assert(b->lid_closed);
 112
 113         button_lid_switch_handle_action(b->manager, false);
 114         return 1;
 115 }
 116
 117 static int button_install_check_event_source(Button *b) {
 118         int r;
 119         assert(b);
 120
 121         /* Install a post handler, so that we keep rechecking as long as the lid is closed. */
 122
 123         if (b->check_event_source)
 124                 return 0;
 125
 126         r = sd_event_add_post(b->manager->event, &b->check_event_source, button_recheck, b);
 127         if (r < 0)
 128                 return r;
 129
 130         return sd_event_source_set_priority(b->check_event_source, SD_EVENT_PRIORITY_IDLE+1);
 131 }
 132
 133 static int button_dispatch(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 134         Button *b = userdata;
 135         struct input_event ev;
 136         ssize_t l;
 137
 138         assert(s);
 139         assert(fd == b->fd);
 140         assert(b);
 141
 142         l = read(b->fd, &ev, sizeof(ev));
 143         if (l < 0)
 144                 return errno != EAGAIN ? -errno : 0;
 145         if ((size_t) l < sizeof(ev))
 146                 return -EIO;
 147
 148         if (ev.type == EV_KEY && ev.value > 0) {
 149
 150                 switch (ev.code) {
 151
 152                 case KEY_POWER:
 153                 case KEY_POWER2:
 154                         log_struct(LOG_INFO,
 155                                    LOG_MESSAGE("Power key pressed."),
 156                                    "MESSAGE_ID=" SD_MESSAGE_POWER_KEY_STR);
 157
 158                         manager_handle_action(b->manager, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, true);
 159                         break;
 160
 161                 /* The kernel is a bit confused here:
 162
 163                    KEY_SLEEP   = suspend-to-ram, which everybody else calls "suspend"
 164                    KEY_SUSPEND = suspend-to-disk, which everybody else calls "hibernate"
 165                 */
 166
 167                 case KEY_SLEEP:
 168                         log_struct(LOG_INFO,
 169                                    LOG_MESSAGE("Suspend key pressed."),
 170                                    "MESSAGE_ID=" SD_MESSAGE_SUSPEND_KEY_STR);
 171
 172                         manager_handle_action(b->manager, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, true);
 173                         break;
 174
 175                 case KEY_SUSPEND:
 176                         log_struct(LOG_INFO,
 177                                    LOG_MESSAGE("Hibernate key pressed."),
 178                                    "MESSAGE_ID=" SD_MESSAGE_HIBERNATE_KEY_STR);
 179
 180                         manager_handle_action(b->manager, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, true);
 181                         break;
 182                 }
 183
 184         } else if (ev.type == EV_SW && ev.value > 0) {
 185
 186                 if (ev.code == SW_LID) {
 187                         log_struct(LOG_INFO,
 188                                    LOG_MESSAGE("Lid closed."),
 189                                    "MESSAGE_ID=" SD_MESSAGE_LID_CLOSED_STR);
 190
 191                         b->lid_closed = true;
 192                         button_lid_switch_handle_action(b->manager, true);
 193                         button_install_check_event_source(b);
 194
 195                 } else if (ev.code == SW_DOCK) {
 196                         log_struct(LOG_INFO,
 197                                    LOG_MESSAGE("System docked."),
 198                                    "MESSAGE_ID=" SD_MESSAGE_SYSTEM_DOCKED_STR);
 199
 200                         b->docked = true;
 201                 }
 202
 203         } else if (ev.type == EV_SW && ev.value == 0) {
 204
 205                 if (ev.code == SW_LID) {
 206                         log_struct(LOG_INFO,
 207                                    LOG_MESSAGE("Lid opened."),
 208                                    "MESSAGE_ID=" SD_MESSAGE_LID_OPENED_STR);
 209
 210                         b->lid_closed = false;
 211                         b->check_event_source = sd_event_source_unref(b->check_event_source);
 212
 213                 } else if (ev.code == SW_DOCK) {
 214                         log_struct(LOG_INFO,
 215                                    LOG_MESSAGE("System undocked."),
 216                                    "MESSAGE_ID=" SD_MESSAGE_SYSTEM_UNDOCKED_STR);
 217
 218                         b->docked = false;
 219                 }
 220         }
 221
 222         return 0;
 223 }
 224
 225 static int button_suitable(int fd) {
 226         unsigned long types[CONST_MAX(EV_KEY, EV_SW)/ULONG_BITS+1];
 227
 228         assert(fd >= 0);
 229
 230         if (ioctl(fd, EVIOCGBIT(EV_SYN, sizeof types), types) < 0)
 231                 return -errno;
 232
 233         if (bitset_get(types, EV_KEY)) {
 234                 unsigned long keys[CONST_MAX4(KEY_POWER, KEY_POWER2, KEY_SLEEP, KEY_SUSPEND)/ULONG_BITS+1];
 235
 236                 if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof keys), keys) < 0)
 237                         return -errno;
 238
 239                 if (bitset_get(keys, KEY_POWER) ||
 240                     bitset_get(keys, KEY_POWER2) ||
 241                     bitset_get(keys, KEY_SLEEP) ||
 242                     bitset_get(keys, KEY_SUSPEND))
 243                         return true;
 244         }
 245
 246         if (bitset_get(types, EV_SW)) {
 247                 unsigned long switches[CONST_MAX(SW_LID, SW_DOCK)/ULONG_BITS+1];
 248
 249                 if (ioctl(fd, EVIOCGBIT(EV_SW, sizeof switches), switches) < 0)
 250                         return -errno;
 251
 252                 if (bitset_get(switches, SW_LID) ||
 253                     bitset_get(switches, SW_DOCK))
 254                         return true;
 255         }
 256
 257         return false;
 258 }
 259
 260 static int button_set_mask(const char *name, int fd) {
 261         unsigned long
 262                 types[CONST_MAX(EV_KEY, EV_SW)/ULONG_BITS+1] = {},
 263                 keys[CONST_MAX4(KEY_POWER, KEY_POWER2, KEY_SLEEP, KEY_SUSPEND)/ULONG_BITS+1] = {},
 264                 switches[CONST_MAX(SW_LID, SW_DOCK)/ULONG_BITS+1] = {};
 265         struct input_mask mask;
 266
 267         assert(name);
 268         assert(fd >= 0);
 269
 270         bitset_put(types, EV_KEY);
 271         bitset_put(types, EV_SW);
 272
 273         mask = (struct input_mask) {
 274                 .type = EV_SYN,
 275                 .codes_size = sizeof(types),
 276                 .codes_ptr = PTR_TO_UINT64(types),
 277         };
 278
 279         if (ioctl(fd, EVIOCSMASK, &mask) < 0)
 280                 /* Log only at debug level if the kernel doesn't do EVIOCSMASK yet */
 281                 return log_full_errno(IN_SET(errno, ENOTTY, EOPNOTSUPP, EINVAL) ? LOG_DEBUG : LOG_WARNING,
 282                                       errno, "Failed to set EV_SYN event mask on /dev/input/%s: %m", name);
 283
 284         bitset_put(keys, KEY_POWER);
 285         bitset_put(keys, KEY_POWER2);
 286         bitset_put(keys, KEY_SLEEP);
 287         bitset_put(keys, KEY_SUSPEND);
 288
 289         mask = (struct input_mask) {
 290                 .type = EV_KEY,
 291                 .codes_size = sizeof(keys),
 292                 .codes_ptr = PTR_TO_UINT64(keys),
 293         };
 294
 295         if (ioctl(fd, EVIOCSMASK, &mask) < 0)
 296                 return log_warning_errno(errno, "Failed to set EV_KEY event mask on /dev/input/%s: %m", name);
 297
 298         bitset_put(switches, SW_LID);
 299         bitset_put(switches, SW_DOCK);
 300
 301         mask = (struct input_mask) {
 302                 .type = EV_SW,
 303                 .codes_size = sizeof(switches),
 304                 .codes_ptr = PTR_TO_UINT64(switches),
 305         };
 306
 307         if (ioctl(fd, EVIOCSMASK, &mask) < 0)
 308                 return log_warning_errno(errno, "Failed to set EV_SW event mask on /dev/input/%s: %m", name);
 309
 310         return 0;
 311 }
 312
 313 int button_open(Button *b) {
 314         _cleanup_close_ int fd = -1;
 315         const char *p;
 316         char name[256];
 317         int r;
 318
 319         assert(b);
 320
 321         b->fd = safe_close(b->fd);
 322
 323         p = strjoina("/dev/input/", b->name);
 324
 325         fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
 326         if (fd < 0)
 327                 return log_warning_errno(errno, "Failed to open %s: %m", p);
 328
 329         r = button_suitable(fd);
 330         if (r < 0)
 331                 return log_warning_errno(r, "Failed to determine whether input device %s is relevant to us: %m", p);
 332         if (r == 0)
 333                 return log_debug_errno(SYNTHETIC_ERRNO(EADDRNOTAVAIL),
 334                                        "Device %s does not expose keys or switches relevant to us, ignoring.", p);
 335
 336         if (ioctl(fd, EVIOCGNAME(sizeof name), name) < 0)
 337                 return log_error_errno(errno, "Failed to get input name for %s: %m", p);
 338
 339         (void) button_set_mask(b->name, fd);
 340
 341         b->io_event_source = sd_event_source_unref(b->io_event_source);
 342         r = sd_event_add_io(b->manager->event, &b->io_event_source, fd, EPOLLIN, button_dispatch, b);
 343         if (r < 0)
 344                 return log_error_errno(r, "Failed to add button event for %s: %m", p);
 345
 346         b->fd = TAKE_FD(fd);
 347         log_info("Watching system buttons on %s (%s)", p, name);
 348         return 0;
 349 }
 350
 351 int button_check_switches(Button *b) {
 352         unsigned long switches[CONST_MAX(SW_LID, SW_DOCK)/ULONG_BITS+1] = {};
 353         assert(b);
 354
 355         if (b->fd < 0)
 356                 return -EINVAL;
 357
 358         if (ioctl(b->fd, EVIOCGSW(sizeof(switches)), switches) < 0)
 359                 return -errno;
 360
 361         b->lid_closed = bitset_get(switches, SW_LID);
 362         b->docked = bitset_get(switches, SW_DOCK);
 363
 364         if (b->lid_closed)
 365                 button_install_check_event_source(b);
 366
 367         return 0;
 368 }