1 /** 2 * Copyright © 2016 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <poll.h> 20 #include <stdbool.h> 21 #include <stdint.h> 22 #include <termios.h> /* for speed_t */ 23 #include <time.h> 24 #include <systemd/sd-bus.h> 25 #include <sys/time.h> 26 #include <sys/un.h> 27 28 struct console; 29 struct config; 30 31 /* Handler API. 32 * 33 * Console data handlers: these implement the functions that process 34 * data coming out of the main tty device. 35 * 36 * Handlers are registered at link time using the console_handler_register() 37 * macro. We call each handler's ->init() function at startup, and ->fini() at 38 * exit. 39 * 40 * Handlers will almost always want to register a ringbuffer consumer, which 41 * provides data coming from the tty. Use cosole_register_ringbuffer_consumer() 42 * for this. To send data to the tty, use console_data_out(). 43 * 44 * If a handler needs to monitor a separate file descriptor for events, use the 45 * poller API, through console_poller_register(). 46 */ 47 struct handler { 48 const char *name; 49 int (*init)(struct handler *handler, struct console *console, 50 struct config *config); 51 void (*fini)(struct handler *handler); 52 int (*baudrate)(struct handler *handler, speed_t baudrate); 53 bool active; 54 }; 55 56 /* NOLINTBEGIN(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp) */ 57 #define __handler_name(n) __handler_##n 58 #define _handler_name(n) __handler_name(n) 59 60 #define console_handler_register(h) \ 61 static const __attribute__((section("handlers"))) \ 62 __attribute__((used)) struct handler * \ 63 _handler_name(__COUNTER__) = h 64 /* NOLINTEND(bugprone-reserved-identifier,cert-dcl37-c,cert-dcl51-cpp) */ 65 66 int console_data_out(struct console *console, const uint8_t *data, size_t len); 67 68 enum poller_ret { 69 POLLER_OK = 0, 70 POLLER_REMOVE, 71 POLLER_EXIT, 72 }; 73 74 typedef char(socket_path_t)[sizeof(((struct sockaddr_un *)NULL)->sun_path)]; 75 76 typedef enum poller_ret (*poller_event_fn_t)(struct handler *handler, 77 int revents, void *data); 78 typedef enum poller_ret (*poller_timeout_fn_t)(struct handler *handler, 79 void *data); 80 81 /* Console server structure */ 82 struct console { 83 const char *tty_kname; 84 char *tty_sysfs_devnode; 85 char *tty_dev; 86 const char *console_id; 87 int tty_sirq; 88 uint16_t tty_lpc_addr; 89 speed_t tty_baud; 90 int tty_fd; 91 92 /* Socket name starts with null character hence we need length */ 93 socket_path_t socket_name; 94 ssize_t socket_name_len; 95 96 struct ringbuffer *rb; 97 98 struct handler **handlers; 99 long n_handlers; 100 101 struct poller **pollers; 102 long n_pollers; 103 104 struct pollfd *pollfds; 105 struct sd_bus *bus; 106 }; 107 108 /* poller API */ 109 struct poller { 110 struct handler *handler; 111 void *data; 112 poller_event_fn_t event_fn; 113 poller_timeout_fn_t timeout_fn; 114 struct timeval timeout; 115 bool remove; 116 }; 117 118 /* we have two extra entry in the pollfds array for the VUART tty */ 119 enum internal_pollfds { 120 POLLFD_HOSTTTY = 0, 121 POLLFD_DBUS = 1, 122 MAX_INTERNAL_POLLFD = 2, 123 }; 124 125 struct poller *console_poller_register(struct console *console, 126 struct handler *handler, 127 poller_event_fn_t poller_fn, 128 poller_timeout_fn_t timeout_fn, int fd, 129 int events, void *data); 130 131 void console_poller_unregister(struct console *console, struct poller *poller); 132 133 void console_poller_set_events(struct console *console, struct poller *poller, 134 int events); 135 136 void console_poller_set_timeout(struct console *console, struct poller *poller, 137 const struct timeval *tv); 138 139 /* ringbuffer API */ 140 141 enum ringbuffer_poll_ret { 142 RINGBUFFER_POLL_OK = 0, 143 RINGBUFFER_POLL_REMOVE, 144 }; 145 146 typedef enum ringbuffer_poll_ret (*ringbuffer_poll_fn_t)(void *data, 147 size_t force_len); 148 149 struct ringbuffer_consumer; 150 151 struct ringbuffer { 152 uint8_t *buf; 153 size_t size; 154 size_t tail; 155 struct ringbuffer_consumer **consumers; 156 int n_consumers; 157 }; 158 159 struct ringbuffer_consumer { 160 struct ringbuffer *rb; 161 ringbuffer_poll_fn_t poll_fn; 162 void *poll_data; 163 size_t pos; 164 }; 165 166 struct ringbuffer *ringbuffer_init(size_t size); 167 void ringbuffer_fini(struct ringbuffer *rb); 168 169 struct ringbuffer_consumer * 170 ringbuffer_consumer_register(struct ringbuffer *rb, 171 ringbuffer_poll_fn_t poll_fn, void *data); 172 173 void ringbuffer_consumer_unregister(struct ringbuffer_consumer *rbc); 174 175 int ringbuffer_queue(struct ringbuffer *rb, uint8_t *data, size_t len); 176 177 size_t ringbuffer_dequeue_peek(struct ringbuffer_consumer *rbc, size_t offset, 178 uint8_t **data); 179 180 int ringbuffer_dequeue_commit(struct ringbuffer_consumer *rbc, size_t len); 181 182 size_t ringbuffer_len(struct ringbuffer_consumer *rbc); 183 184 /* console wrapper around ringbuffer consumer registration */ 185 struct ringbuffer_consumer * 186 console_ringbuffer_consumer_register(struct console *console, 187 ringbuffer_poll_fn_t poll_fn, void *data); 188 189 /* Console server API */ 190 void tty_init_termios(struct console *console); 191 192 /* config API */ 193 struct config; 194 const char *config_get_value(struct config *config, const char *name); 195 struct config *config_init(const char *filename); 196 void config_fini(struct config *config); 197 198 int config_parse_baud(speed_t *speed, const char *baud_string); 199 uint32_t parse_baud_to_int(speed_t speed); 200 speed_t parse_int_to_baud(uint32_t baud); 201 int config_parse_logsize(const char *size_str, size_t *size); 202 203 /* socket paths */ 204 ssize_t console_socket_path(socket_path_t path, const char *id); 205 ssize_t console_socket_path_readable(const struct sockaddr_un *addr, 206 size_t addrlen, socket_path_t path); 207 208 /* utils */ 209 int write_buf_to_fd(int fd, const uint8_t *buf, size_t len); 210 211 /* console-dbus API */ 212 void dbus_init(struct console *console, 213 struct config *config __attribute__((unused))); 214 215 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) 216 217 #ifndef offsetof 218 #define offsetof(type, member) ((unsigned long)&((type *)NULL)->member) 219 #endif 220 221 #define container_of(ptr, type, member) \ 222 ((type *)((void *)((ptr)-offsetof(type, member)))) 223 224 #define BUILD_ASSERT(c) \ 225 do { \ 226 char __c[(c) ? 1 : -1] __attribute__((unused)); \ 227 } while (0) 228