* Chardev fix from Marc-André * config.status tweak from David * Header file tweaks from Markus, myself and Veronia (Outreachy candidate) * get_ticks_per_sec() removal from Rutuja (Outreachy candidate) * Coverity fix from myself * PKE implementation from myself, based on rth's XSAVE support -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iQEcBAABCAAGBQJW9ErPAAoJEL/70l94x66DJfEH/A/QkMpAhrgNdyVsahzsGrzE wx5gHFIc1nBYxyr62w4apUb5jPB7zaXu0LA7EAWDeAe0pyP8hZzLT9kJyOEDsuJu zwKN2QeLSNMtPbnbKN0I/YQ2za2xX1V5ruhSeOJoVslUI214hgnAURaGshhQNzuZ 2CluDT9KgL5cQifAnKs5kJrwhIYShYNQB+1eDC/7wk28dd/EH+sPALIoF+rqrSmt Zu4Mdqd+9Ns+oKOjA6br9ULq/Hzg0aDfY82J+XLVVqfF3PXQe8rTDmuMf/7jTn+M Un7ZOcei9oZF2/9vfAfKQpDCcgD9HvOUSbgqV/ubmkPPmN/LNJzeKj0fBhrRN+Y= =K12D -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging * Log filtering from Alex and Peter * Chardev fix from Marc-André * config.status tweak from David * Header file tweaks from Markus, myself and Veronia (Outreachy candidate) * get_ticks_per_sec() removal from Rutuja (Outreachy candidate) * Coverity fix from myself * PKE implementation from myself, based on rth's XSAVE support # gpg: Signature made Thu 24 Mar 2016 20:15:11 GMT using RSA key ID 78C7AE83 # gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>" # gpg: aka "Paolo Bonzini <pbonzini@redhat.com>" * remotes/bonzini/tags/for-upstream: (28 commits) target-i386: implement PKE for TCG config.status: Pass extra parameters char: translate from QIOChannel error to errno exec: fix error handling in file_ram_alloc cputlb: modernise the debug support qemu-log: support simple pid substitution for logs target-arm: dfilter support for in_asm qemu-log: dfilter-ise exec, out_asm, op and opt_op qemu-log: new option -dfilter to limit output qemu-log: Improve the "exec" TB execution logging qemu-log: Avoid function call for disabled qemu_log_mask logging qemu-log: correct help text for -d cpu tcg: pass down TranslationBlock to tcg_code_gen util: move declarations out of qemu-common.h Replaced get_tick_per_sec() by NANOSECONDS_PER_SECOND hw: explicitly include qemu-common.h and cpu.h include/crypto: Include qapi-types.h or qemu/bswap.h instead of qemu-common.h isa: Move DMA_transfer_handler from qemu-common.h to hw/isa/isa.h Move ParallelIOArg from qemu-common.h to sysemu/char.h Move QEMU_ALIGN_*() from qemu-common.h to qemu/osdep.h ... Signed-off-by: Peter Maydell <peter.maydell@linaro.org> Conflicts: scripts/clean-includes
488 lines
15 KiB
C
488 lines
15 KiB
C
/*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or
|
|
* (at your option) any later version. See the COPYING file in the
|
|
* top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qapi/error.h"
|
|
#include "qemu-common.h"
|
|
#include "qemu/config-file.h"
|
|
#include "qemu/sockets.h"
|
|
#include "sysemu/sysemu.h"
|
|
#include "ui/input.h"
|
|
#include "qom/object_interfaces.h"
|
|
|
|
#include <sys/ioctl.h>
|
|
#include "standard-headers/linux/input.h"
|
|
|
|
static int linux_to_qcode[KEY_CNT] = {
|
|
[KEY_ESC] = Q_KEY_CODE_ESC,
|
|
[KEY_1] = Q_KEY_CODE_1,
|
|
[KEY_2] = Q_KEY_CODE_2,
|
|
[KEY_3] = Q_KEY_CODE_3,
|
|
[KEY_4] = Q_KEY_CODE_4,
|
|
[KEY_5] = Q_KEY_CODE_5,
|
|
[KEY_6] = Q_KEY_CODE_6,
|
|
[KEY_7] = Q_KEY_CODE_7,
|
|
[KEY_8] = Q_KEY_CODE_8,
|
|
[KEY_9] = Q_KEY_CODE_9,
|
|
[KEY_0] = Q_KEY_CODE_0,
|
|
[KEY_MINUS] = Q_KEY_CODE_MINUS,
|
|
[KEY_EQUAL] = Q_KEY_CODE_EQUAL,
|
|
[KEY_BACKSPACE] = Q_KEY_CODE_BACKSPACE,
|
|
[KEY_TAB] = Q_KEY_CODE_TAB,
|
|
[KEY_Q] = Q_KEY_CODE_Q,
|
|
[KEY_W] = Q_KEY_CODE_W,
|
|
[KEY_E] = Q_KEY_CODE_E,
|
|
[KEY_R] = Q_KEY_CODE_R,
|
|
[KEY_T] = Q_KEY_CODE_T,
|
|
[KEY_Y] = Q_KEY_CODE_Y,
|
|
[KEY_U] = Q_KEY_CODE_U,
|
|
[KEY_I] = Q_KEY_CODE_I,
|
|
[KEY_O] = Q_KEY_CODE_O,
|
|
[KEY_P] = Q_KEY_CODE_P,
|
|
[KEY_LEFTBRACE] = Q_KEY_CODE_BRACKET_LEFT,
|
|
[KEY_RIGHTBRACE] = Q_KEY_CODE_BRACKET_RIGHT,
|
|
[KEY_ENTER] = Q_KEY_CODE_RET,
|
|
[KEY_LEFTCTRL] = Q_KEY_CODE_CTRL,
|
|
[KEY_A] = Q_KEY_CODE_A,
|
|
[KEY_S] = Q_KEY_CODE_S,
|
|
[KEY_D] = Q_KEY_CODE_D,
|
|
[KEY_F] = Q_KEY_CODE_F,
|
|
[KEY_G] = Q_KEY_CODE_G,
|
|
[KEY_H] = Q_KEY_CODE_H,
|
|
[KEY_J] = Q_KEY_CODE_J,
|
|
[KEY_K] = Q_KEY_CODE_K,
|
|
[KEY_L] = Q_KEY_CODE_L,
|
|
[KEY_SEMICOLON] = Q_KEY_CODE_SEMICOLON,
|
|
[KEY_APOSTROPHE] = Q_KEY_CODE_APOSTROPHE,
|
|
[KEY_GRAVE] = Q_KEY_CODE_GRAVE_ACCENT,
|
|
[KEY_LEFTSHIFT] = Q_KEY_CODE_SHIFT,
|
|
[KEY_BACKSLASH] = Q_KEY_CODE_BACKSLASH,
|
|
[KEY_102ND] = Q_KEY_CODE_LESS,
|
|
[KEY_Z] = Q_KEY_CODE_Z,
|
|
[KEY_X] = Q_KEY_CODE_X,
|
|
[KEY_C] = Q_KEY_CODE_C,
|
|
[KEY_V] = Q_KEY_CODE_V,
|
|
[KEY_B] = Q_KEY_CODE_B,
|
|
[KEY_N] = Q_KEY_CODE_N,
|
|
[KEY_M] = Q_KEY_CODE_M,
|
|
[KEY_COMMA] = Q_KEY_CODE_COMMA,
|
|
[KEY_DOT] = Q_KEY_CODE_DOT,
|
|
[KEY_SLASH] = Q_KEY_CODE_SLASH,
|
|
[KEY_RIGHTSHIFT] = Q_KEY_CODE_SHIFT_R,
|
|
[KEY_LEFTALT] = Q_KEY_CODE_ALT,
|
|
[KEY_SPACE] = Q_KEY_CODE_SPC,
|
|
[KEY_CAPSLOCK] = Q_KEY_CODE_CAPS_LOCK,
|
|
[KEY_F1] = Q_KEY_CODE_F1,
|
|
[KEY_F2] = Q_KEY_CODE_F2,
|
|
[KEY_F3] = Q_KEY_CODE_F3,
|
|
[KEY_F4] = Q_KEY_CODE_F4,
|
|
[KEY_F5] = Q_KEY_CODE_F5,
|
|
[KEY_F6] = Q_KEY_CODE_F6,
|
|
[KEY_F7] = Q_KEY_CODE_F7,
|
|
[KEY_F8] = Q_KEY_CODE_F8,
|
|
[KEY_F9] = Q_KEY_CODE_F9,
|
|
[KEY_F10] = Q_KEY_CODE_F10,
|
|
[KEY_NUMLOCK] = Q_KEY_CODE_NUM_LOCK,
|
|
[KEY_SCROLLLOCK] = Q_KEY_CODE_SCROLL_LOCK,
|
|
[KEY_KP0] = Q_KEY_CODE_KP_0,
|
|
[KEY_KP1] = Q_KEY_CODE_KP_1,
|
|
[KEY_KP2] = Q_KEY_CODE_KP_2,
|
|
[KEY_KP3] = Q_KEY_CODE_KP_3,
|
|
[KEY_KP4] = Q_KEY_CODE_KP_4,
|
|
[KEY_KP5] = Q_KEY_CODE_KP_5,
|
|
[KEY_KP6] = Q_KEY_CODE_KP_6,
|
|
[KEY_KP7] = Q_KEY_CODE_KP_7,
|
|
[KEY_KP8] = Q_KEY_CODE_KP_8,
|
|
[KEY_KP9] = Q_KEY_CODE_KP_9,
|
|
[KEY_KPMINUS] = Q_KEY_CODE_KP_SUBTRACT,
|
|
[KEY_KPPLUS] = Q_KEY_CODE_KP_ADD,
|
|
[KEY_KPDOT] = Q_KEY_CODE_KP_DECIMAL,
|
|
[KEY_KPENTER] = Q_KEY_CODE_KP_ENTER,
|
|
[KEY_KPSLASH] = Q_KEY_CODE_KP_DIVIDE,
|
|
[KEY_KPASTERISK] = Q_KEY_CODE_KP_MULTIPLY,
|
|
[KEY_F11] = Q_KEY_CODE_F11,
|
|
[KEY_F12] = Q_KEY_CODE_F12,
|
|
[KEY_RIGHTCTRL] = Q_KEY_CODE_CTRL_R,
|
|
[KEY_SYSRQ] = Q_KEY_CODE_SYSRQ,
|
|
[KEY_RIGHTALT] = Q_KEY_CODE_ALT_R,
|
|
[KEY_HOME] = Q_KEY_CODE_HOME,
|
|
[KEY_UP] = Q_KEY_CODE_UP,
|
|
[KEY_PAGEUP] = Q_KEY_CODE_PGUP,
|
|
[KEY_LEFT] = Q_KEY_CODE_LEFT,
|
|
[KEY_RIGHT] = Q_KEY_CODE_RIGHT,
|
|
[KEY_END] = Q_KEY_CODE_END,
|
|
[KEY_DOWN] = Q_KEY_CODE_DOWN,
|
|
[KEY_PAGEDOWN] = Q_KEY_CODE_PGDN,
|
|
[KEY_INSERT] = Q_KEY_CODE_INSERT,
|
|
[KEY_DELETE] = Q_KEY_CODE_DELETE,
|
|
[KEY_LEFTMETA] = Q_KEY_CODE_META_L,
|
|
[KEY_RIGHTMETA] = Q_KEY_CODE_META_R,
|
|
[KEY_MENU] = Q_KEY_CODE_MENU,
|
|
};
|
|
|
|
static int qemu_input_linux_to_qcode(unsigned int lnx)
|
|
{
|
|
assert(lnx < KEY_CNT);
|
|
return linux_to_qcode[lnx];
|
|
}
|
|
|
|
#define TYPE_INPUT_LINUX "input-linux"
|
|
#define INPUT_LINUX(obj) \
|
|
OBJECT_CHECK(InputLinux, (obj), TYPE_INPUT_LINUX)
|
|
#define INPUT_LINUX_GET_CLASS(obj) \
|
|
OBJECT_GET_CLASS(InputLinuxClass, (obj), TYPE_INPUT_LINUX)
|
|
#define INPUT_LINUX_CLASS(klass) \
|
|
OBJECT_CLASS_CHECK(InputLinuxClass, (klass), TYPE_INPUT_LINUX)
|
|
|
|
typedef struct InputLinux InputLinux;
|
|
typedef struct InputLinuxClass InputLinuxClass;
|
|
|
|
struct InputLinux {
|
|
Object parent;
|
|
|
|
char *evdev;
|
|
int fd;
|
|
bool repeat;
|
|
bool grab_request;
|
|
bool grab_active;
|
|
bool grab_all;
|
|
bool keydown[KEY_CNT];
|
|
int keycount;
|
|
int wheel;
|
|
bool initialized;
|
|
QTAILQ_ENTRY(InputLinux) next;
|
|
};
|
|
|
|
struct InputLinuxClass {
|
|
ObjectClass parent_class;
|
|
};
|
|
|
|
static QTAILQ_HEAD(, InputLinux) inputs = QTAILQ_HEAD_INITIALIZER(inputs);
|
|
|
|
static void input_linux_toggle_grab(InputLinux *il)
|
|
{
|
|
intptr_t request = !il->grab_active;
|
|
InputLinux *item;
|
|
int rc;
|
|
|
|
rc = ioctl(il->fd, EVIOCGRAB, request);
|
|
if (rc < 0) {
|
|
return;
|
|
}
|
|
il->grab_active = !il->grab_active;
|
|
|
|
if (!il->grab_all) {
|
|
return;
|
|
}
|
|
QTAILQ_FOREACH(item, &inputs, next) {
|
|
if (item == il || item->grab_all) {
|
|
/* avoid endless loops */
|
|
continue;
|
|
}
|
|
if (item->grab_active != il->grab_active) {
|
|
input_linux_toggle_grab(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void input_linux_event_keyboard(void *opaque)
|
|
{
|
|
InputLinux *il = opaque;
|
|
struct input_event event;
|
|
int rc;
|
|
|
|
for (;;) {
|
|
rc = read(il->fd, &event, sizeof(event));
|
|
if (rc != sizeof(event)) {
|
|
if (rc < 0 && errno != EAGAIN) {
|
|
fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
|
|
qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
|
|
close(il->fd);
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch (event.type) {
|
|
case EV_KEY:
|
|
if (event.value > 2 || (event.value > 1 && !il->repeat)) {
|
|
/*
|
|
* ignore autorepeat + unknown key events
|
|
* 0 == up, 1 == down, 2 == autorepeat, other == undefined
|
|
*/
|
|
continue;
|
|
}
|
|
if (event.code >= KEY_CNT) {
|
|
/*
|
|
* Should not happen. But better safe than sorry,
|
|
* and we make Coverity happy too.
|
|
*/
|
|
continue;
|
|
}
|
|
/* keep track of key state */
|
|
if (!il->keydown[event.code] && event.value) {
|
|
il->keydown[event.code] = true;
|
|
il->keycount++;
|
|
}
|
|
if (il->keydown[event.code] && !event.value) {
|
|
il->keydown[event.code] = false;
|
|
il->keycount--;
|
|
}
|
|
|
|
/* send event to guest when grab is active */
|
|
if (il->grab_active) {
|
|
int qcode = qemu_input_linux_to_qcode(event.code);
|
|
qemu_input_event_send_key_qcode(NULL, qcode, event.value);
|
|
}
|
|
|
|
/* hotkey -> record switch request ... */
|
|
if (il->keydown[KEY_LEFTCTRL] &&
|
|
il->keydown[KEY_RIGHTCTRL]) {
|
|
il->grab_request = true;
|
|
}
|
|
|
|
/*
|
|
* ... and do the switch when all keys are lifted, so we
|
|
* confuse neither guest nor host with keys which seem to
|
|
* be stuck due to missing key-up events.
|
|
*/
|
|
if (il->grab_request && !il->keycount) {
|
|
il->grab_request = false;
|
|
input_linux_toggle_grab(il);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void input_linux_event_mouse_button(int button)
|
|
{
|
|
qemu_input_queue_btn(NULL, button, true);
|
|
qemu_input_event_sync();
|
|
qemu_input_queue_btn(NULL, button, false);
|
|
qemu_input_event_sync();
|
|
}
|
|
|
|
static void input_linux_event_mouse(void *opaque)
|
|
{
|
|
InputLinux *il = opaque;
|
|
struct input_event event;
|
|
int rc;
|
|
|
|
for (;;) {
|
|
rc = read(il->fd, &event, sizeof(event));
|
|
if (rc != sizeof(event)) {
|
|
if (rc < 0 && errno != EAGAIN) {
|
|
fprintf(stderr, "%s: read: %s\n", __func__, strerror(errno));
|
|
qemu_set_fd_handler(il->fd, NULL, NULL, NULL);
|
|
close(il->fd);
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* only send event to guest when grab is active */
|
|
if (!il->grab_active) {
|
|
continue;
|
|
}
|
|
|
|
switch (event.type) {
|
|
case EV_KEY:
|
|
switch (event.code) {
|
|
case BTN_LEFT:
|
|
qemu_input_queue_btn(NULL, INPUT_BUTTON_LEFT, event.value);
|
|
break;
|
|
case BTN_RIGHT:
|
|
qemu_input_queue_btn(NULL, INPUT_BUTTON_RIGHT, event.value);
|
|
break;
|
|
case BTN_MIDDLE:
|
|
qemu_input_queue_btn(NULL, INPUT_BUTTON_MIDDLE, event.value);
|
|
break;
|
|
case BTN_GEAR_UP:
|
|
qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_UP, event.value);
|
|
break;
|
|
case BTN_GEAR_DOWN:
|
|
qemu_input_queue_btn(NULL, INPUT_BUTTON_WHEEL_DOWN,
|
|
event.value);
|
|
break;
|
|
};
|
|
break;
|
|
case EV_REL:
|
|
switch (event.code) {
|
|
case REL_X:
|
|
qemu_input_queue_rel(NULL, INPUT_AXIS_X, event.value);
|
|
break;
|
|
case REL_Y:
|
|
qemu_input_queue_rel(NULL, INPUT_AXIS_Y, event.value);
|
|
break;
|
|
case REL_WHEEL:
|
|
il->wheel = event.value;
|
|
break;
|
|
}
|
|
break;
|
|
case EV_SYN:
|
|
qemu_input_event_sync();
|
|
if (il->wheel != 0) {
|
|
input_linux_event_mouse_button((il->wheel > 0)
|
|
? INPUT_BUTTON_WHEEL_UP
|
|
: INPUT_BUTTON_WHEEL_DOWN);
|
|
il->wheel = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void input_linux_complete(UserCreatable *uc, Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(uc);
|
|
uint32_t evtmap;
|
|
int rc, ver;
|
|
|
|
if (!il->evdev) {
|
|
error_setg(errp, "no input device specified");
|
|
return;
|
|
}
|
|
|
|
il->fd = open(il->evdev, O_RDWR);
|
|
if (il->fd < 0) {
|
|
error_setg_file_open(errp, errno, il->evdev);
|
|
return;
|
|
}
|
|
qemu_set_nonblock(il->fd);
|
|
|
|
rc = ioctl(il->fd, EVIOCGVERSION, &ver);
|
|
if (rc < 0) {
|
|
error_setg(errp, "%s: is not an evdev device", il->evdev);
|
|
goto err_close;
|
|
}
|
|
|
|
rc = ioctl(il->fd, EVIOCGBIT(0, sizeof(evtmap)), &evtmap);
|
|
|
|
if (evtmap & (1 << EV_REL)) {
|
|
/* has relative axis -> assume mouse */
|
|
qemu_set_fd_handler(il->fd, input_linux_event_mouse, NULL, il);
|
|
} else if (evtmap & (1 << EV_ABS)) {
|
|
/* has absolute axis -> not supported */
|
|
error_setg(errp, "tablet/touchscreen not supported");
|
|
goto err_close;
|
|
} else if (evtmap & (1 << EV_KEY)) {
|
|
/* has keys/buttons (and no axis) -> assume keyboard */
|
|
qemu_set_fd_handler(il->fd, input_linux_event_keyboard, NULL, il);
|
|
} else {
|
|
/* Huh? What is this? */
|
|
error_setg(errp, "unknown kind of input device");
|
|
goto err_close;
|
|
}
|
|
input_linux_toggle_grab(il);
|
|
QTAILQ_INSERT_TAIL(&inputs, il, next);
|
|
il->initialized = true;
|
|
return;
|
|
|
|
err_close:
|
|
close(il->fd);
|
|
return;
|
|
}
|
|
|
|
static void input_linux_instance_finalize(Object *obj)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
if (il->initialized) {
|
|
QTAILQ_REMOVE(&inputs, il, next);
|
|
close(il->fd);
|
|
}
|
|
g_free(il->evdev);
|
|
}
|
|
|
|
static char *input_linux_get_evdev(Object *obj, Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
return g_strdup(il->evdev);
|
|
}
|
|
|
|
static void input_linux_set_evdev(Object *obj, const char *value,
|
|
Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
if (il->evdev) {
|
|
error_setg(errp, "evdev property already set");
|
|
return;
|
|
}
|
|
il->evdev = g_strdup(value);
|
|
}
|
|
|
|
static bool input_linux_get_grab_all(Object *obj, Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
return il->grab_all;
|
|
}
|
|
|
|
static void input_linux_set_grab_all(Object *obj, bool value,
|
|
Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
il->grab_all = value;
|
|
}
|
|
|
|
static bool input_linux_get_repeat(Object *obj, Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
return il->repeat;
|
|
}
|
|
|
|
static void input_linux_set_repeat(Object *obj, bool value,
|
|
Error **errp)
|
|
{
|
|
InputLinux *il = INPUT_LINUX(obj);
|
|
|
|
il->repeat = value;
|
|
}
|
|
|
|
static void input_linux_instance_init(Object *obj)
|
|
{
|
|
object_property_add_str(obj, "evdev",
|
|
input_linux_get_evdev,
|
|
input_linux_set_evdev, NULL);
|
|
object_property_add_bool(obj, "grab_all",
|
|
input_linux_get_grab_all,
|
|
input_linux_set_grab_all, NULL);
|
|
object_property_add_bool(obj, "repeat",
|
|
input_linux_get_repeat,
|
|
input_linux_set_repeat, NULL);
|
|
}
|
|
|
|
static void input_linux_class_init(ObjectClass *oc, void *data)
|
|
{
|
|
UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
|
|
|
|
ucc->complete = input_linux_complete;
|
|
}
|
|
|
|
static const TypeInfo input_linux_info = {
|
|
.name = TYPE_INPUT_LINUX,
|
|
.parent = TYPE_OBJECT,
|
|
.class_size = sizeof(InputLinuxClass),
|
|
.class_init = input_linux_class_init,
|
|
.instance_size = sizeof(InputLinux),
|
|
.instance_init = input_linux_instance_init,
|
|
.instance_finalize = input_linux_instance_finalize,
|
|
.interfaces = (InterfaceInfo[]) {
|
|
{ TYPE_USER_CREATABLE },
|
|
{ }
|
|
}
|
|
};
|
|
|
|
static void register_types(void)
|
|
{
|
|
type_register_static(&input_linux_info);
|
|
}
|
|
|
|
type_init(register_types);
|