blob: adbbad4321e23220b62970906486de20c5473292 [file] [log] [blame]
Andrew Jeffery23140be2018-09-05 14:15:07 +09301// SPDX-License-Identifier: Apache-2.0
2// Copyright (C) 2018 IBM Corp.
3#include "config.h"
4
Andrew Jefferya6ca7a92018-08-20 13:03:44 +09305#include <assert.h>
Andrew Jeffery23140be2018-09-05 14:15:07 +09306#include <errno.h>
Andrew Jefferya6ca7a92018-08-20 13:03:44 +09307#include <string.h>
Andrew Jeffery23140be2018-09-05 14:15:07 +09308#include <systemd/sd-bus.h>
9
10#include "common.h"
11#include "dbus.h"
12#include "mboxd.h"
13#include "protocol.h"
Andrew Jeffery23a48212018-08-10 14:41:48 +093014#include "transport.h"
15
Andrew Jeffery0453aa42018-08-21 08:25:46 +093016static int transport_dbus_property_update(struct mbox_context *context,
17 uint8_t events)
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093018{
Andrew Jeffery0453aa42018-08-21 08:25:46 +093019 /* Two properties plus a terminating NULL */
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093020 char *props[3] = { 0 };
21 int i = 0;
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093022
23 if (events & BMC_EVENT_FLASH_CTRL_LOST) {
24 props[i++] = "FlashControlLost";
25 }
26
27 if (events & BMC_EVENT_DAEMON_READY) {
28 props[i++] = "DaemonReady";
29 }
30
Andrew Jeffery0453aa42018-08-21 08:25:46 +093031 return sd_bus_emit_properties_changed_strv(context->bus,
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093032 MBOX_DBUS_OBJECT,
33 /* FIXME: Hard-coding v2 */
34 MBOX_DBUS_PROTOCOL_IFACE_V2,
35 props);
Andrew Jeffery0453aa42018-08-21 08:25:46 +093036}
37
38static int transport_dbus_set_events(struct mbox_context *context,
39 uint8_t events)
40{
41 int rc;
42
43 rc = transport_dbus_property_update(context, events);
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093044 if (rc < 0) {
45 return rc;
46 }
47
Andrew Jeffery0453aa42018-08-21 08:25:46 +093048 /*
49 * Handle signals - edge triggered, only necessary when they're
50 * asserted
51 */
Andrew Jefferya6ca7a92018-08-20 13:03:44 +093052 if (events & BMC_EVENT_WINDOW_RESET) {
53 sd_bus_message *m = NULL;
54
55 rc = sd_bus_message_new_signal(context->bus, &m,
56 MBOX_DBUS_OBJECT,
57 /* FIXME: Hard-coding v2 */
58 MBOX_DBUS_PROTOCOL_IFACE_V2,
59 "WindowReset");
60 if (rc < 0) {
61 return rc;
62 }
63
64 rc = sd_bus_send(context->bus, m, NULL);
65 if (rc < 0) {
66 return rc;
67 }
68 }
69
70 if (events & BMC_EVENT_REBOOT) {
71 sd_bus_message *m = NULL;
72
73 rc = sd_bus_message_new_signal(context->bus, &m,
74 MBOX_DBUS_OBJECT,
75 /* FIXME: Hard-coding v2 */
76 MBOX_DBUS_PROTOCOL_IFACE_V2,
77 "ProtocolReset");
78 if (rc < 0) {
79 return rc;
80 }
81
82 rc = sd_bus_send(context->bus, m, NULL);
83 if (rc < 0) {
84 return rc;
85 }
86 }
87
88 return 0;
89}
90
Andrew Jeffery4414fb82018-08-20 12:13:09 +093091static int transport_dbus_clear_events(struct mbox_context *context,
92 uint8_t events)
Andrew Jeffery23a48212018-08-10 14:41:48 +093093{
Andrew Jeffery0453aa42018-08-21 08:25:46 +093094 /* No need to emit signals for ackable events on clear */
95 return transport_dbus_property_update(context, events);
Andrew Jeffery23a48212018-08-10 14:41:48 +093096}
97
98static const struct transport_ops transport_dbus_ops = {
Andrew Jeffery4414fb82018-08-20 12:13:09 +093099 .set_events = transport_dbus_set_events,
100 .clear_events = transport_dbus_clear_events,
Andrew Jeffery23a48212018-08-10 14:41:48 +0930101};
Andrew Jeffery23140be2018-09-05 14:15:07 +0930102
Andrew Jeffery7255d262018-08-23 16:53:48 +0930103static int transport_dbus_reset(sd_bus_message *m, void *userdata,
104 sd_bus_error *ret_error)
105{
106 struct mbox_context *context = userdata;
107 sd_bus_message *n;
108 int rc;
109
110 if (!context) {
111 MSG_ERR("DBUS Internal Error\n");
112 return -EINVAL;
113 }
114
115 rc = context->protocol->reset(context);
116 if (rc < 0) {
117 return rc;
118 }
119
120 rc = sd_bus_message_new_method_return(m, &n);
121 if (rc < 0) {
122 MSG_ERR("sd_bus_message_new_method_return failed: %d\n", rc);
123 return rc;
124 }
125
126 return sd_bus_send(NULL, n, NULL);
127}
128
Andrew Jeffery23140be2018-09-05 14:15:07 +0930129static int transport_dbus_get_info(sd_bus_message *m, void *userdata,
130 sd_bus_error *ret_error)
131{
132 struct mbox_context *context = userdata;
133 struct protocol_get_info io;
134 sd_bus_message *n;
135 int rc;
136
137 if (!context) {
138 MSG_ERR("DBUS Internal Error\n");
139 return -EINVAL;
140 }
141
142 rc = sd_bus_message_read_basic(m, 'y', &io.req.api_version);
143 if (rc < 0) {
144 MSG_ERR("DBUS error reading message: %s\n", strerror(-rc));
145 return rc;
146 }
147
148 rc = context->protocol->get_info(context, &io);
149 if (rc < 0) {
150 return rc;
151 }
152
Andrew Jeffery23a48212018-08-10 14:41:48 +0930153 /* Switch transport to DBus. This is fine as DBus signals are async */
154 context->transport = &transport_dbus_ops;
Andrew Jeffery0453aa42018-08-21 08:25:46 +0930155 /* A bit messy, but we need the correct event mask */
156 protocol_events_set(context, context->bmc_events);
Andrew Jeffery23a48212018-08-10 14:41:48 +0930157
Andrew Jeffery23140be2018-09-05 14:15:07 +0930158 rc = sd_bus_message_new_method_return(m, &n);
159 if (rc < 0) {
160 MSG_ERR("sd_bus_message_new_method_return failed: %d\n", rc);
161 return rc;
162 }
163
164 if (API_VERSION_2 != io.resp.api_version) {
165 MSG_ERR("Unsupported protocol version for DBus transport: %d\n",
166 io.resp.api_version);
167 return rc;
168 }
169
170 rc = sd_bus_message_append(n, "yyq",
171 io.resp.api_version,
172 io.resp.v2.block_size_shift,
173 io.resp.v2.timeout);
174 if (rc < 0) {
175 MSG_ERR("sd_bus_message_append failed!\n");
176 return rc;
177 }
178
179 return sd_bus_send(NULL, n, NULL);
180}
181
Andrew Jeffery9c627172018-08-23 20:59:54 +0930182static int transport_dbus_get_flash_info(sd_bus_message *m, void *userdata,
183 sd_bus_error *ret_error)
184{
185 struct mbox_context *context = userdata;
186 struct protocol_get_flash_info io;
187 sd_bus_message *n;
188 int rc;
189
190 if (!context) {
191 MSG_ERR("DBUS Internal Error\n");
192 return -EINVAL;
193 }
194
195 rc = context->protocol->get_flash_info(context, &io);
196 if (rc < 0) {
197 return rc;
198 }
199
200 rc = sd_bus_message_new_method_return(m, &n);
201 if (rc < 0) {
202 MSG_ERR("sd_bus_message_new_method_return failed: %d\n", rc);
203 return rc;
204 }
205
206 rc = sd_bus_message_append(n, "qq",
207 io.resp.v2.flash_size,
208 io.resp.v2.erase_size);
209 if (rc < 0) {
210 MSG_ERR("sd_bus_message_append failed!\n");
211 return rc;
212 }
213
214 return sd_bus_send(NULL, n, NULL);
215}
216
Andrew Jefferybcc33992018-08-23 17:19:25 +0930217static int transport_dbus_ack(sd_bus_message *m, void *userdata,
218 sd_bus_error *ret_error)
219{
220 struct mbox_context *context = userdata;
221 struct protocol_ack io;
222 sd_bus_message *n;
223 int rc;
224
225 if (!context) {
226 MSG_ERR("DBUS Internal Error\n");
227 return -EINVAL;
228 }
229
230 rc = sd_bus_message_read_basic(m, 'y', &io.req.flags);
231 if (rc < 0) {
232 MSG_ERR("DBUS error reading message: %s\n", strerror(-rc));
233 return rc;
234 }
235
236 rc = context->protocol->ack(context, &io);
237 if (rc < 0) {
238 return rc;
239 }
240
241 rc = sd_bus_message_new_method_return(m, &n);
242 if (rc < 0) {
243 MSG_ERR("sd_bus_message_new_method_return failed: %d\n", rc);
244 return rc;
245 }
246
247 return sd_bus_send(NULL, n, NULL);
248}
249
Andrew Jefferya6ca7a92018-08-20 13:03:44 +0930250static int transport_dbus_get_property(sd_bus *bus,
251 const char *path,
252 const char *interface,
253 const char *property,
254 sd_bus_message *reply,
255 void *userdata,
256 sd_bus_error *ret_error)
257{
258 struct mbox_context *context = userdata;
259 bool value;
260
261 assert(!strcmp(MBOX_DBUS_OBJECT, path));
262 assert(!strcmp(MBOX_DBUS_PROTOCOL_IFACE_V2, interface));
263
264 if (!strcmp("FlashControlLost", property)) {
265 value = context->bmc_events & BMC_EVENT_FLASH_CTRL_LOST;
266 } else if (!strcmp("DaemonReady", property)) {
267 value = context->bmc_events & BMC_EVENT_DAEMON_READY;
268 } else {
269 MSG_ERR("Unknown DBus property: %s\n", property);
270 return -EINVAL;
271 }
272
273 return sd_bus_message_append(reply, "b", value);
274}
275
Andrew Jeffery23140be2018-09-05 14:15:07 +0930276static const sd_bus_vtable protocol_unversioned_vtable[] = {
277 SD_BUS_VTABLE_START(0),
Andrew Jeffery7255d262018-08-23 16:53:48 +0930278 SD_BUS_METHOD("Reset", NULL, NULL, &transport_dbus_reset,
279 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jeffery23140be2018-09-05 14:15:07 +0930280 SD_BUS_METHOD("GetInfo", "y", "yyq", &transport_dbus_get_info,
281 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jefferybcc33992018-08-23 17:19:25 +0930282 SD_BUS_METHOD("Ack", "y", NULL, &transport_dbus_ack,
283 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jeffery23140be2018-09-05 14:15:07 +0930284 SD_BUS_VTABLE_END
285};
286
287static const sd_bus_vtable protocol_v2_vtable[] = {
288 SD_BUS_VTABLE_START(0),
Andrew Jeffery7255d262018-08-23 16:53:48 +0930289 SD_BUS_METHOD("Reset", NULL, NULL, &transport_dbus_reset,
290 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jeffery23140be2018-09-05 14:15:07 +0930291 SD_BUS_METHOD("GetInfo", "y", "yyq", &transport_dbus_get_info,
292 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jeffery9c627172018-08-23 20:59:54 +0930293 SD_BUS_METHOD("GetFlashInfo", NULL, "qq",
294 &transport_dbus_get_flash_info,
295 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jefferybcc33992018-08-23 17:19:25 +0930296 SD_BUS_METHOD("Ack", "y", NULL, &transport_dbus_ack,
297 SD_BUS_VTABLE_UNPRIVILEGED),
Andrew Jefferya6ca7a92018-08-20 13:03:44 +0930298 SD_BUS_PROPERTY("FlashControlLost", "b", transport_dbus_get_property,
299 0, /* Just a pointer to struct mbox_context */
300 SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
301 SD_BUS_PROPERTY("DaemonReady", "b", transport_dbus_get_property,
302 0, /* Just a pointer to struct mbox_context */
303 SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
304 SD_BUS_SIGNAL("ProtocolReset", NULL, 0),
305 SD_BUS_SIGNAL("WindowReset", NULL, 0),
Andrew Jeffery23140be2018-09-05 14:15:07 +0930306 SD_BUS_VTABLE_END
307};
308
309int transport_dbus_init(struct mbox_context *context)
310{
311 int rc;
312
313 rc = sd_bus_add_object_vtable(context->bus, NULL,
314 MBOX_DBUS_OBJECT,
315 MBOX_DBUS_PROTOCOL_IFACE,
316 protocol_unversioned_vtable,
317 context);
318 if (rc < 0) {
319 return rc;
320 }
321
322 rc = sd_bus_add_object_vtable(context->bus, NULL,
323 MBOX_DBUS_OBJECT,
Andrew Jefferya6ca7a92018-08-20 13:03:44 +0930324 MBOX_DBUS_PROTOCOL_IFACE_V2,
Andrew Jeffery23140be2018-09-05 14:15:07 +0930325 protocol_v2_vtable, context);
326
327 return rc;
328}
329
330#define __unused __attribute__((unused))
331void transport_dbus_free(struct mbox_context *context __unused)
332{
333 return;
334}