chiark / gitweb /
Dynamically allocate bootchart logs
[elogind.git] / src / login / logind-button.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2012 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
22 #include <assert.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <sys/ioctl.h>
27 #include <unistd.h>
28 #include <linux/input.h>
29 #include <sys/epoll.h>
30
31 #include "conf-parser.h"
32 #include "util.h"
33 #include "logind-button.h"
34 #include "special.h"
35 #include "dbus-common.h"
36 #include "sd-messages.h"
37
38 Button* button_new(Manager *m, const char *name) {
39         Button *b;
40
41         assert(m);
42         assert(name);
43
44         b = new0(Button, 1);
45         if (!b)
46                 return NULL;
47
48         b->name = strdup(name);
49         if (!b->name) {
50                 free(b);
51                 return NULL;
52         }
53
54         if (hashmap_put(m->buttons, b->name, b) < 0) {
55                 free(b->name);
56                 free(b);
57                 return NULL;
58         }
59
60         b->manager = m;
61         b->fd = -1;
62
63         return b;
64 }
65
66 void button_free(Button *b) {
67         assert(b);
68
69         hashmap_remove(b->manager->buttons, b->name);
70
71         if (b->fd >= 0) {
72                 hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
73                 assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
74
75                 /* If the device has been unplugged close() returns
76                  * ENODEV, let's ignore this, hence we don't use
77                  * close_nointr_nofail() */
78                 close(b->fd);
79         }
80
81         free(b->name);
82         free(b->seat);
83         free(b);
84 }
85
86 int button_set_seat(Button *b, const char *sn) {
87         char *s;
88
89         assert(b);
90         assert(sn);
91
92         s = strdup(sn);
93         if (!s)
94                 return -ENOMEM;
95
96         free(b->seat);
97         b->seat = s;
98
99         return 0;
100 }
101
102 int button_open(Button *b) {
103         char name[256], *p;
104         struct epoll_event ev;
105         int r;
106
107         assert(b);
108
109         if (b->fd >= 0) {
110                 close(b->fd);
111                 b->fd = -1;
112         }
113
114         p = strappend("/dev/input/", b->name);
115         if (!p)
116                 return log_oom();
117
118         b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
119         free(p);
120         if (b->fd < 0) {
121                 log_warning("Failed to open %s: %m", b->name);
122                 return -errno;
123         }
124
125         if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
126                 log_error("Failed to get input name: %m");
127                 r = -errno;
128                 goto fail;
129         }
130
131         zero(ev);
132         ev.events = EPOLLIN;
133         ev.data.u32 = FD_OTHER_BASE + b->fd;
134
135         if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
136                 log_error("Failed to add to epoll: %m");
137                 r = -errno;
138                 goto fail;
139         }
140
141         r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
142         if (r < 0) {
143                 log_error("Failed to add to hash map: %s", strerror(-r));
144                 assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
145                 goto fail;
146         }
147
148         log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
149
150         return 0;
151
152 fail:
153         close(b->fd);
154         b->fd = -1;
155         return r;
156 }
157
158 static int button_handle(
159                 Button *b,
160                 InhibitWhat inhibit_key,
161                 HandleAction handle,
162                 bool ignore_inhibited,
163                 bool is_edge) {
164
165         int r;
166
167         assert(b);
168
169         r = manager_handle_action(b->manager, inhibit_key, handle, ignore_inhibited, is_edge);
170         if (r > 0)
171                 /* We are executing the operation, so make sure we don't
172                  * execute another one until the lid is opened/closed again */
173                 b->lid_close_queued = false;
174
175         return r;
176 }
177
178 int button_process(Button *b) {
179         struct input_event ev;
180         ssize_t l;
181
182         assert(b);
183
184         l = read(b->fd, &ev, sizeof(ev));
185         if (l < 0)
186                 return errno != EAGAIN ? -errno : 0;
187         if ((size_t) l < sizeof(ev))
188                 return -EIO;
189
190         if (ev.type == EV_KEY && ev.value > 0) {
191
192                 switch (ev.code) {
193
194                 case KEY_POWER:
195                 case KEY_POWER2:
196                         log_struct(LOG_INFO,
197                                    "MESSAGE=Power key pressed.",
198                                    MESSAGE_ID(SD_MESSAGE_POWER_KEY),
199                                    NULL);
200                         return button_handle(b, INHIBIT_HANDLE_POWER_KEY, b->manager->handle_power_key, b->manager->power_key_ignore_inhibited, true);
201
202                 /* The kernel is a bit confused here:
203
204                    KEY_SLEEP   = suspend-to-ram, which everybody else calls "suspend"
205                    KEY_SUSPEND = suspend-to-disk, which everybody else calls "hibernate"
206                 */
207
208                 case KEY_SLEEP:
209                         log_struct(LOG_INFO,
210                                    "MESSAGE=Suspend key pressed.",
211                                    MESSAGE_ID(SD_MESSAGE_SUSPEND_KEY),
212                                    NULL);
213                         return button_handle(b, INHIBIT_HANDLE_SUSPEND_KEY, b->manager->handle_suspend_key, b->manager->suspend_key_ignore_inhibited, true);
214
215                 case KEY_SUSPEND:
216                         log_struct(LOG_INFO,
217                                    "MESSAGE=Hibernate key pressed.",
218                                    MESSAGE_ID(SD_MESSAGE_HIBERNATE_KEY),
219                                    NULL);
220                         return button_handle(b, INHIBIT_HANDLE_HIBERNATE_KEY, b->manager->handle_hibernate_key, b->manager->hibernate_key_ignore_inhibited, true);
221                 }
222
223         } else if (ev.type == EV_SW && ev.value > 0) {
224
225                 switch (ev.code) {
226
227                 case SW_LID:
228                         log_struct(LOG_INFO,
229                                    "MESSAGE=Lid closed.",
230                                    MESSAGE_ID(SD_MESSAGE_LID_CLOSED),
231                                    NULL);
232                         b->lid_close_queued = true;
233
234                         return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, true);
235                 }
236
237         } else if (ev.type == EV_SW && ev.value == 0) {
238
239                 switch (ev.code) {
240
241                 case SW_LID:
242                         log_struct(LOG_INFO,
243                                    "MESSAGE=Lid opened.",
244                                    MESSAGE_ID(SD_MESSAGE_LID_OPENED),
245                                    NULL);
246                         b->lid_close_queued = false;
247                         break;
248                 }
249         }
250
251         return 0;
252 }
253
254 int button_recheck(Button *b) {
255         assert(b);
256
257         if (!b->lid_close_queued)
258                 return 0;
259
260         return button_handle(b, INHIBIT_HANDLE_LID_SWITCH, b->manager->handle_lid_switch, b->manager->lid_switch_ignore_inhibited, false);
261 }