/*
* This file is part of ioctl_kd strace test.
*
* Copyright (c) 2019-2021 Eugene Syromyatnikov <evgsyr@gmail.com>
* All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "tests.h"
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "scno.h"
#include <linux/ioctl.h>
#include <linux/kd.h>
#include <linux/keyboard.h>
#ifndef RETVAL_INJECTED
# define RETVAL_INJECTED 0
#endif
#if RETVAL_INJECTED
# define RETVAL "42 (INJECTED)\n"
#else
# define RETVAL "-1 EBADF (%m)\n"
#endif
#ifndef HAVE_STRUCT_KBDIACRUC
struct kbdiacruc {
unsigned int diacr, base, result;
};
#endif
#ifndef HAVE_STRUCT_KBDIACRSUC
struct kbdiacrsuc {
struct kbdiacruc kbdiacruc[256];
}
#endif
struct arg_val {
kernel_ulong_t val;
const char *str;
};
static long
sys_ioctl(kernel_long_t fd, kernel_ulong_t cmd, kernel_ulong_t arg)
{
return syscall(__NR_ioctl, fd, cmd, arg);
}
static void
check_null_invalid(unsigned int c, const char *s)
{
static char *p;
if (!p)
p = tail_alloc(1);
sys_ioctl(-1, c, 0);
printf("ioctl(-1, " XLAT_FMT ", NULL) = " RETVAL, XLAT_SEL(c, s));
if (F8ILL_KULONG_SUPPORTED) {
sys_ioctl(-1, c, F8ILL_KULONG_MASK);
printf("ioctl(-1, " XLAT_FMT ", NULL) = " RETVAL,
XLAT_SEL(c, s));
}
sys_ioctl(-1, c, (uintptr_t) p + 1);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL, XLAT_SEL(c, s), p + 1);
}
/* GIO_SCRNMAP, PIO_SCRNMAP */
static void
check_scrnmap(unsigned int c, const char *s)
{
char *scrnmap = tail_alloc(E_TABSZ);
int saved_errno;
long rc;
fill_memory_ex(scrnmap, E_TABSZ, 0, 0xff);
check_null_invalid(c, s);
sys_ioctl(-1, c, (uintptr_t) scrnmap + E_TABSZ - 31);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), scrnmap + E_TABSZ - 31);
sys_ioctl(-1, c, (uintptr_t) scrnmap + E_TABSZ - 32);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), scrnmap + E_TABSZ - 32);
rc = sys_ioctl(-1, c, (uintptr_t) scrnmap + E_TABSZ - 33);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if ((rc >= 0 || c == PIO_SCRNMAP) && (DEFAULT_STRLEN <= 32)) {
print_quoted_hex(scrnmap + E_TABSZ - 33, 32);
printf("...");
} else {
printf("%p", scrnmap + E_TABSZ - 33);
}
errno = saved_errno;
printf(") = " RETVAL);
rc = sys_ioctl(-1, c, (uintptr_t) scrnmap);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (rc >= 0 || c == PIO_SCRNMAP) {
print_quoted_hex(scrnmap, MIN(E_TABSZ, DEFAULT_STRLEN));
if (DEFAULT_STRLEN < E_TABSZ)
printf("...");
} else {
printf("%p", scrnmap);
}
errno = saved_errno;
printf(") = " RETVAL);
}
/* KDGKBENT, KDSKBENT */
static void
check_kbdent(unsigned int c, const char *s)
{
static const struct arg_val kbtbl_vecs[] = {
{ ARG_XLAT_KNOWN(0, "K_NORMTAB") },
{ ARG_XLAT_KNOWN(0x1, "K_SHIFTTAB") },
{ ARG_XLAT_KNOWN(0x3, "K_ALTSHIFTTAB") },
{ ARG_XLAT_KNOWN(0x4, "1<<KG_CTRL") },
{ ARG_XLAT_KNOWN(0xff,
"1<<KG_SHIFT|1<<KG_ALTGR|1<<KG_CTRL"
"|1<<KG_ALT|1<<KG_SHIFTL|1<<KG_SHIFTR"
"|1<<KG_CTRLL|1<<KG_CTRLR") },
};
static const struct arg_val kbval_vecs[] = {
{ ARG_STR(0) NRAW(" /* K(KT_LATIN, '\\x00') */") },
{ ARG_STR(0x10) NRAW(" /* K(KT_LATIN, '\\x10') */") },
{ ARG_STR(0x20) NRAW(" /* K(KT_LATIN, ' ') */") },
{ ARG_STR(0x7e) NRAW(" /* K(KT_LATIN, '~') */") },
{ ARG_STR(0x7f) NRAW(" /* K(KT_LATIN, '\\x7f') */") },
{ ARG_STR(0x100) NRAW(" /* K_F1 */") },
{ ARG_STR(0x11d) NRAW(" /* K_PAUSE */") },
{ ARG_STR(0x1ff) NRAW(" /* K_UNDO */") },
{ ARG_STR(0x200) NRAW(" /* K_HOLE */") },
{ ARG_STR(0x213) NRAW(" /* K_BARENUMLOCK */") },
{ ARG_STR(0x214) NRAW(" /* K(KT_SPEC, 0x14) */") },
{ ARG_STR(0x27d) NRAW(" /* K(KT_SPEC, 0x7d) */") },
{ ARG_STR(0x27e) NRAW(" /* K_ALLOCATED */") },
{ ARG_STR(0x27f) NRAW(" /* K_NOSUCHMAP */") },
{ ARG_STR(0x280) NRAW(" /* K(KT_SPEC, 0x80) */") },
{ ARG_STR(0x2ff) NRAW(" /* K(KT_SPEC, 0xff) */") },
{ ARG_STR(0x300) NRAW(" /* K_P0 */") },
{ ARG_STR(0x313) NRAW(" /* K_PPARENR */") },
{ ARG_STR(0x314) NRAW(" /* K(KT_PAD, 0x14) */") },
{ ARG_STR(0x37f) NRAW(" /* K(KT_PAD, 0x7f) */") },
{ ARG_STR(0x3ff) NRAW(" /* K(KT_PAD, 0xff) */") },
{ ARG_STR(0x400) NRAW(" /* K_DGRAVE */") },
{ ARG_STR(0x41a) NRAW(" /* K_DGREEK */") },
{ ARG_STR(0x41b) NRAW(" /* K(KT_DEAD, 0x1b) */") },
{ ARG_STR(0x47f) NRAW(" /* K(KT_DEAD, 0x7f) */") },
{ ARG_STR(0x4ff) NRAW(" /* K(KT_DEAD, 0xff) */") },
{ ARG_STR(0x500) NRAW(" /* K(KT_CONS, 0) */") },
{ ARG_STR(0x540) NRAW(" /* K(KT_CONS, 0x40) */") },
{ ARG_STR(0x5ff) NRAW(" /* K(KT_CONS, 0xff) */") },
{ ARG_STR(0x600) NRAW(" /* K_DOWN */") },
{ ARG_STR(0x603) NRAW(" /* K_UP */") },
{ ARG_STR(0x604) NRAW(" /* K(KT_CUR, 0x4) */") },
{ ARG_STR(0x680) NRAW(" /* K(KT_CUR, 0x80) */") },
{ ARG_STR(0x6ff) NRAW(" /* K(KT_CUR, 0xff) */") },
{ ARG_STR(0x700) NRAW(" /* K_SHIFT */") },
{ ARG_STR(0x708) NRAW(" /* K_CAPSSHIFT */") },
{ ARG_STR(0x709) NRAW(" /* K(KT_SHIFT, 0x9) */") },
{ ARG_STR(0x7ff) NRAW(" /* K(KT_SHIFT, 0xff) */") },
{ ARG_STR(0x800) NRAW(" /* K(KT_META, '\\x00') */") },
{ ARG_STR(0x841) NRAW(" /* K(KT_META, 'A') */") },
{ ARG_STR(0x8ff) NRAW(" /* K(KT_META, '\\xff') */") },
{ ARG_STR(0x900) NRAW(" /* K_ASC0 */") },
{ ARG_STR(0x909) NRAW(" /* K_ASC9 */") },
{ ARG_STR(0x90a) NRAW(" /* K_HEX0 */") },
{ ARG_STR(0x919) NRAW(" /* K_HEXf */") },
{ ARG_STR(0x91a) NRAW(" /* K(KT_ASCII, 0x1a) */") },
{ ARG_STR(0x9ff) NRAW(" /* K(KT_ASCII, 0xff) */") },
{ ARG_STR(0xa00) NRAW(" /* K_SHIFTLOCK */") },
{ ARG_STR(0xa08) NRAW(" /* K_CAPSSHIFTLOCK */") },
{ ARG_STR(0xa09) NRAW(" /* K(KT_LOCK, 0x9) */") },
{ ARG_STR(0xaff) NRAW(" /* K(KT_LOCK, 0xff) */") },
{ ARG_STR(0xb00) NRAW(" /* K(KT_LETTER, '\\x00') */") },
{ ARG_STR(0xb40) NRAW(" /* K(KT_LETTER, '@') */") },
{ ARG_STR(0xb7f) NRAW(" /* K(KT_LETTER, '\\x7f') */") },
{ ARG_STR(0xbff) NRAW(" /* K(KT_LETTER, '\\xff') */") },
{ ARG_STR(0xc00) NRAW(" /* K_SHIFT_SLOCK */") },
{ ARG_STR(0xc08) NRAW(" /* K_CAPSSHIFT_SLOCK */") },
{ ARG_STR(0xc09) NRAW(" /* K(KT_SLOCK, 0x9) */") },
{ ARG_STR(0xcff) NRAW(" /* K(KT_SLOCK, 0xff) */") },
{ ARG_STR(0xd00) NRAW(" /* K(KT_DEAD2, '\\x00') */") },
{ ARG_STR(0xd13) NRAW(" /* K(KT_DEAD2, '\\x13') */") },
{ ARG_STR(0xd5c) NRAW(" /* K(KT_DEAD2, '\\\\') */") },
{ ARG_STR(0xdff) NRAW(" /* K(KT_DEAD2, '\\xff') */") },
{ ARG_STR(0xe00) NRAW(" /* K_BRL_BLANK */") },
{ ARG_STR(0xe0a) NRAW(" /* K_BRL_DOT10 */") },
{ ARG_STR(0xe0b) NRAW(" /* K(KT_BRL, 0xb) */") },
{ ARG_STR(0xeff) NRAW(" /* K(KT_BRL, 0xff) */") },
{ ARG_STR(0xf00) NRAW(" /* K(0xf, 0) */") },
{ ARG_STR(0xfed) NRAW(" /* K(0xf, 0xed) */") },
{ ARG_STR(0xf00d) NRAW(" /* K(0xf0, 0xd) */") },
};
struct kbentry *kbe = tail_alloc(sizeof(*kbe));
int saved_errno;
long rc;
check_null_invalid(c, s);
kbe->kb_value = 0xa8a8;
sys_ioctl(-1, c, (uintptr_t) kbe + 2);
printf("ioctl(-1, " XLAT_FMT ", {kb_table=%s, kb_index=168%s}"
") = " RETVAL,
XLAT_SEL(c, s), XLAT_STR(1<<KG_ALT|1<<KG_SHIFTR|1<<KG_CTRLR),
RETVAL_INJECTED || c == KDSKBENT ? ", kb_value=???" : ""
);
for (size_t i = 0;
i < MAX(ARRAY_SIZE(kbtbl_vecs), ARRAY_SIZE(kbval_vecs)); i++) {
kbe->kb_table = kbtbl_vecs[i % ARRAY_SIZE(kbtbl_vecs)].val;
kbe->kb_index = i * 3141;
kbe->kb_value = kbval_vecs[i % ARRAY_SIZE(kbval_vecs)].val;
rc = sys_ioctl(-1, c, (uintptr_t) kbe);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", {kb_table=%s, kb_index=%u",
XLAT_SEL(c, s),
kbtbl_vecs[i % ARRAY_SIZE(kbtbl_vecs)].str,
kbe->kb_index);
if (rc >= 0 || c == KDSKBENT) {
printf(", kb_value=%s",
kbval_vecs[i % ARRAY_SIZE(kbval_vecs)].str);
}
errno = saved_errno;
printf("}) = " RETVAL);
}
}
/* KDGKBSENT, KDSKBSENT */
static void
check_kbdsent(unsigned int c, const char *s)
{
static struct arg_val kbse_offsets[] = {
{ sizeof(struct kbsentry) - 1, "KVAL(K_F2)" },
{ sizeof(struct kbsentry) - 2, "KVAL(K_F1)" },
{ sizeof(struct kbsentry) - 34, "KVAL(K_F214)" },
{ sizeof(struct kbsentry) - 35, "KVAL(K_F213)" },
{ 1, "KVAL(K_F1)" },
{ 0, "KVAL(K_F245)" },
};
static const struct arg_val kbfn_vecs[] = {
{ ARG_XLAT_KNOWN(0, "KVAL(K_F1)") },
{ ARG_XLAT_KNOWN(0x10, "KVAL(K_F17)") },
{ ARG_XLAT_KNOWN(0x7f, "KVAL(K_F118)") },
{ ARG_XLAT_KNOWN(0xff, "KVAL(K_UNDO)") },
};
struct kbsentry *kbse = tail_alloc(sizeof(*kbse));
int saved_errno;
fill_memory_ex(kbse->kb_string, sizeof(kbse->kb_string), 0, 0xff);
kbse->kb_func = 0xfe;
check_null_invalid(c, s);
for (size_t i = 0; i < ARRAY_SIZE(kbse_offsets); i++) {
sys_ioctl(-1, c,
(uintptr_t) kbse + kbse_offsets[i].val);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", {kb_func=%s",
XLAT_SEL(c, s),
sprintxlat(kbse_offsets[i].str,
(kbse_offsets[i].val + 254) % 0xff, NULL));
if (RETVAL_INJECTED || c == KDSKBSENT) {
printf(", kb_string=");
if (kbse_offsets[i].val < 255 * 2) {
print_quoted_stringn(
(char *) kbse->kb_string +
kbse_offsets[i].val,
MIN(DEFAULT_STRLEN,
sizeof(kbse->kb_string)));
} else {
printf("???");
}
}
errno = saved_errno;
printf("}) = " RETVAL);
}
fill_memory_ex(kbse->kb_string, sizeof(kbse->kb_string), 0x80, 0x7f);
kbse->kb_func = KVAL(K_PGDN);
sys_ioctl(-1, c, (uintptr_t) kbse);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", {kb_func="
XLAT_KNOWN(0x19, "KVAL(K_PGDN)"),
XLAT_SEL(c, s));
if (RETVAL_INJECTED || c == KDSKBSENT) {
printf(", kb_string=");
print_quoted_stringn((char *) kbse->kb_string,
MIN(DEFAULT_STRLEN,
sizeof(kbse->kb_string)));
}
errno = saved_errno;
printf("}) = " RETVAL);
for (size_t i = 0; i < ARRAY_SIZE(kbfn_vecs); i++) {
kbse->kb_func = kbfn_vecs[i].val;
fill_memory_ex(kbse->kb_string, sizeof(kbse->kb_string),
i * 357 + 42, i * 257 + 13);
sys_ioctl(-1, c, (uintptr_t) kbse);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", {kb_func=%s",
XLAT_SEL(c, s),
kbfn_vecs[i].str);
if (RETVAL_INJECTED || c == KDSKBSENT) {
printf(", kb_string=");
print_quoted_stringn((char *) kbse->kb_string,
MIN(DEFAULT_STRLEN,
sizeof(kbse->kb_string)));
}
errno = saved_errno;
printf("}) = " RETVAL);
}
}
/* KDGKBDIACR, KDSKBDIACR */
static void
check_diacr(unsigned int c, const char *s)
{
static struct arg_val diac_vecs[] = {
{ 0, "\\x00" },
{ '\n', "\\n" },
{ ' ', " " },
{ 'a', "a" },
{ '~', "~" },
{ '\'', "\\'" },
{ '\\', "\\\\" },
{ '"', "\"" },
{ '`', "`" },
{ 0x7f, "\\x7f" },
{ 0xff, "\\xff" },
};
struct kbdiacrs *diacrs0 = tail_alloc(sizeof(diacrs0->kb_cnt));
struct kbdiacrs *diacrs1 = tail_alloc(sizeof(diacrs1->kb_cnt) +
4 * sizeof(struct kbdiacr));
struct kbdiacrs *diacrs2 = tail_alloc(sizeof(*diacrs2));
int saved_errno;
check_null_invalid(c, s);
for (size_t i = 0; i < 2; i++) {
diacrs0->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs0);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (RETVAL_INJECTED || c == KDSKBDIACR) {
printf("{kb_cnt=%zu, kbdiacr=", i);
if (i)
printf("%p}", diacrs0->kbdiacr);
else
printf("[]}");
} else {
printf("%p", diacrs0);
}
errno = saved_errno;
printf(") = " RETVAL);
}
fill_memory_ex(diacrs1->kbdiacr, 4 * sizeof(struct kbdiacr), 40, 44);
for (size_t i = 0; i < 7; i++) {
diacrs1->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs1);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (RETVAL_INJECTED || c == KDSKBDIACR) {
printf("{kb_cnt=%zu, kbdiacr=[", i);
for (size_t j = 0; j < MIN(i, 4); j++)
printf("%s{diacr='%c', base='%c', result='%c'}",
j ? ", " : "", (int) (40 + j * 3),
(int) (41 + j * 3), (int) (42 + j * 3));
if (i > 4)
printf(", ... /* %p */", diacrs1->kbdiacr + 4);
printf("]}");
} else {
printf("%p", diacrs1);
}
errno = saved_errno;
printf(") = " RETVAL);
}
fill_memory_ex(diacrs2->kbdiacr, sizeof(diacrs2->kbdiacr), 40, 52);
for (size_t i = ARRAY_SIZE(diacrs2->kbdiacr) - 1;
i < ARRAY_SIZE(diacrs2->kbdiacr) + 3; i++) {
diacrs2->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs2);
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
saved_errno = errno;
if (RETVAL_INJECTED || c == KDSKBDIACR) {
printf("{kb_cnt=%zu, kbdiacr=[", i);
for (size_t j = 0;
j < MIN(i, MIN(DEFAULT_STRLEN,
ARRAY_SIZE(diacrs2->kbdiacr))); j++)
printf("%s{diacr='%c', base='%c', result='%c'}",
j ? ", " : "",
(int) (40 + (j * 3 + 0) % 52),
(int) (40 + (j * 3 + 1) % 52),
(int) (40 + (j * 3 + 2) % 52));
if (i > MIN(DEFAULT_STRLEN,
ARRAY_SIZE(diacrs2->kbdiacr)))
printf(", ...");
printf("]}");
} else {
printf("%p", diacrs2);
}
errno = saved_errno;
printf(") = " RETVAL);
}
for (size_t i = 0; i< ARRAY_SIZE(diac_vecs); i++) {
diacrs2->kbdiacr[i].diacr = diac_vecs[i].val;
diacrs2->kbdiacr[i].base = diac_vecs[i].val;
diacrs2->kbdiacr[i].result = diac_vecs[i].val;
}
diacrs2->kb_cnt = ARRAY_SIZE(diac_vecs);
sys_ioctl(-1, c, (uintptr_t) diacrs2);
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
saved_errno = errno;
if (RETVAL_INJECTED || c == KDSKBDIACR) {
printf("{kb_cnt=%zu, kbdiacr=[", ARRAY_SIZE(diac_vecs));
for (size_t i = 0; i < ARRAY_SIZE(diac_vecs); i++)
printf("%1$s{diacr='%2$s', base='%2$s', result='%2$s'}",
i ? ", " : "", diac_vecs[i].str);
printf("]}");
} else {
printf("%p", diacrs2);
}
errno = saved_errno;
printf(") = " RETVAL);
}
/* KDGETKEYCODE, KDSETKEYCODE */
static void
check_xetkeycode(unsigned int c, const char *s)
{
static const struct kbkeycode args[] = {
{ 0, 0 },
{ 0, 0xdeadface },
{ 0xfacefeed, 0 },
{ 0xdecaffed, 0xdadfaced },
};
struct kbkeycode *tail_arg = tail_alloc(sizeof(args[0]));
check_null_invalid(c, s);
sys_ioctl(-1, c, (uintptr_t) tail_arg + 4);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), (char *) tail_arg + 4);
for (size_t i = 0; i < ARRAY_SIZE(args); i++) {
memcpy(tail_arg, args + i, sizeof(args[i]));
sys_ioctl(-1, c, (uintptr_t) tail_arg);
printf("ioctl(-1, " XLAT_FMT ", {scancode=%#x, keycode=%#x",
XLAT_SEL(c, s), args[i].scancode, args[i].keycode);
if ((c == KDGETKEYCODE) && RETVAL_INJECTED)
printf(" => %#x", args[i].keycode);
printf("}) = " RETVAL);
}
}
/* KDKBDREP */
static void
check_kbdrep(unsigned int c, const char *s)
{
static const struct kbd_repeat args[] = {
{ -1, -1 },
{ -1234567890, 0 },
{ 0, -2134567890 },
{ 314159265, 271828182 },
};
struct kbd_repeat *tail_arg = tail_alloc(sizeof(args[0]));
check_null_invalid(c, s);
sys_ioctl(-1, c, (uintptr_t) tail_arg + 4);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), (char *) tail_arg + 4);
for (size_t i = 0; i < ARRAY_SIZE(args); i++) {
memcpy(tail_arg, args + i, sizeof(args[i]));
sys_ioctl(-1, c, (uintptr_t) tail_arg);
printf("ioctl(-1, " XLAT_FMT, XLAT_SEL(c, s));
for (size_t j = 0; j < 1 + RETVAL_INJECTED; j++) {
printf("%s {delay=%d, period=%d}",
j ? " =>" : ",", args[i].delay, args[i].period);
}
printf(") = " RETVAL);
}
}
/* GIO_FONT, PIO_FONT */
static void
check_font(unsigned int c, const char *s)
{
char *data = tail_alloc(8192);
char *data_end = data + 8192;
fill_memory(data, 8192);
check_null_invalid(c, s);
sys_ioctl(-1, c, (uintptr_t) data_end - 31);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), data_end - 31);
sys_ioctl(-1, c, (uintptr_t) data_end - 32);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_SEL(c, s), data_end - 32);
bool ok = (DEFAULT_STRLEN == 32)
&& ((c != GIO_FONT) || RETVAL_INJECTED);
sys_ioctl(-1, c, (uintptr_t) data_end - 33);
printf("ioctl(-1, " XLAT_FMT ", %s", XLAT_SEL(c, s), ok ? "\"" : "");
if (ok) {
for (size_t i = 8192 - 33; i < 8192 - 1; i++)
printf("\\x%hhx", (unsigned char) ( 0x80 + i % 0x80));
} else {
printf("%p", data_end - 33);
}
printf("%s) = " RETVAL, ok ? "\"..." : "");
ok = (c != GIO_FONT) || RETVAL_INJECTED;
sys_ioctl(-1, c, (uintptr_t) data_end - 1025);
printf("ioctl(-1, " XLAT_FMT ", %s", XLAT_SEL(c, s), ok ? "\"" : "");
if (ok) {
for (size_t i = 8192 - 1025; i < 8192 - 1025 + DEFAULT_STRLEN;
i++)
printf("\\x%hhx", (unsigned char) (0x80 + i % 0x80));
} else {
printf("%p", data_end - 1025);
}
printf("%s) = " RETVAL, ok ? "\"..." : "");
sys_ioctl(-1, c, (uintptr_t) data);
printf("ioctl(-1, " XLAT_FMT ", %s", XLAT_SEL(c, s), ok ? "\"" : "");
if (ok) {
for (size_t i = 0; i < DEFAULT_STRLEN; i++)
printf("\\x%hhx", (unsigned char) (0x80 + i % 0x80));
} else {
printf("%p", data);
}
printf("%s) = " RETVAL, ok ? "\"..." : "");
}
/* GIO_UNIMAP, PIO_UNIMAP */
static void
check_unimap(unsigned int c, const char *s)
{
struct unimapdesc *umd = tail_alloc(sizeof(*umd));
struct unipair *ups = tail_alloc(33 * sizeof(*ups));
fill_memory16(ups, 33 * sizeof(*ups));
ups[0].unicode = 0;
ups[0].fontpos = 0;
check_null_invalid(c, s);
umd->entry_ct = 0xdead;
umd->entries = NULL;
sys_ioctl(-1, c, (uintptr_t) umd);
printf("ioctl(-1, " XLAT_FMT ", {entry_ct=57005%s, entries=NULL}) = "
RETVAL, XLAT_SEL(c, s), c == GIO_UNIMAP ? " => 57005" : "");
umd->entry_ct = 0;
umd->entries = ups + 33;
sys_ioctl(-1, c, (uintptr_t) umd);
printf("ioctl(-1, " XLAT_FMT ", {entry_ct=0%s, entries=",
XLAT_SEL(c, s), c == GIO_UNIMAP ? " => 0" : "");
if (c == GIO_UNIMAP && !RETVAL_INJECTED)
printf("%p", ups + 33);
else
printf("[]");
printf("}) = " RETVAL);
umd->entry_ct = 1;
sys_ioctl(-1, c, (uintptr_t) umd);
printf("ioctl(-1, " XLAT_FMT ", {entry_ct=1%s, entries=%p}) = " RETVAL,
XLAT_SEL(c, s), c == GIO_UNIMAP ? " => 1" : "", ups + 33);
for (unsigned int i = 0; i < 6; i++) {
umd->entry_ct = 31 + (i + 1) / 2;
umd->entries = ups + 2 - i / 2;
sys_ioctl(-1, c, (uintptr_t) umd);
printf("ioctl(-1, " XLAT_FMT ", {entry_ct=%u",
XLAT_SEL(c, s), 31 + (i + 1) / 2);
if (c == GIO_UNIMAP) {
printf(" => %u", 31 + (i + 1) / 2);
#if !RETVAL_INJECTED
printf(", entries=%p}) = " RETVAL, ups + 2 - i / 2);
continue;
#endif
}
printf(", entries=[%s", i > 3 ? "{unicode=0, fontpos=0}" : "");
for (unsigned int j = 0; j < 31
#if DEFAULT_STRLEN > 32
+ MIN(i / 2, 1)
#else
+ ((i / 2) == 1)
#endif
; j++) {
printf("%s{unicode=%#x, fontpos=%#x}",
j == 0 && i < 4 ? "" : ", ",
0x80c4 + 2 * (j - MIN(i / 2, 1)),
0x80c5 + 2 * (j - MIN(i / 2, 1)));
}
if (i == 1 || i == 3 || ((DEFAULT_STRLEN > 32) && (i == 5)))
printf(", ... /* %p */", ups + 33);
#if DEFAULT_STRLEN == 32
if (i > 3)
printf(", ...");
#endif
printf("]}) = " RETVAL);
}
}
/* GIO_UNISCRNMAP, PIO_UNISCRNMAP */
static void
check_uniscrnmap(unsigned int c, const char *s)
{
uint16_t *map = tail_alloc(256 * sizeof(*map));
for (unsigned int i = 0; i < 256; i++)
map[i] = 0xeff1 + 32 * (i % 112) - i / 8;
check_null_invalid(c, s);
for (unsigned int i = 0; i < 3; i++) {
sys_ioctl(-1, c, (uintptr_t) (map + 224 - 112 * i));
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (c == GIO_UNISCRNMAP && !RETVAL_INJECTED) {
printf("%p) = " RETVAL, map + 224 - 112 * i);
continue;
}
for (size_t j = 0;
j < MIN(32 + 112 * i, DEFAULT_STRLEN); j++) {
uint16_t v = 0xefd5 + 32 * (j % 112) - j / 8 + i * 14;
if ((j % 112) < (2 - (i + 1 - j / 112) / 2)
|| (j % 112) > (17 - (i + 1 - j / 112) / 2)) {
printf("%s%#hx", j ? ", " : "[", v);
} else {
printf(", "
XLAT_KNOWN_FMT("%#hx",
"UNI_DIRECT_BASE+%#hx"),
XLAT_SEL(v, (uint16_t) (v - 0xf000)));
}
}
if (DEFAULT_STRLEN == 32 || i < 2) {
printf(", ...");
if (DEFAULT_STRLEN >= 32 + 112 * i)
printf(" /* %p */", map + 256);
}
printf("]) = " RETVAL);
}
}
/* GIO_FONTX, PIO_FONTX */
static void
check_fontx(unsigned int c, const char *s)
{
static const short cnts[] = { 1, 32, 256 };
struct consolefontdesc *cfd = tail_alloc(sizeof(*cfd));
char *data = tail_alloc(2048);
char *data_end = data + 2048;
fill_memory_ex(data, 2048, 0xf0, 255);
check_null_invalid(c, s);
cfd->charcount = 0;
cfd->charheight = 0xdead;
cfd->chardata = NULL;
sys_ioctl(-1, c, (uintptr_t) cfd);
printf("ioctl(-1, " XLAT_FMT
", {charcount=0, charheight=57005, chardata=NULL}%s) = " RETVAL,
XLAT_SEL(c, s), RETVAL_INJECTED && (c == GIO_FONTX)
? " => {charcount=0, charheight=57005, chardata=NULL}" : "");
cfd->chardata = data_end;
sys_ioctl(-1, c, (uintptr_t) cfd);
printf("ioctl(-1, " XLAT_FMT
", {charcount=0, charheight=57005, chardata=%p}",
XLAT_SEL(c, s), data_end);
#if RETVAL_INJECTED
if (c == GIO_FONTX)
printf(" => {charcount=0, charheight=57005, chardata=\"\"}");
#endif
printf(") = " RETVAL);
cfd->chardata = data;
sys_ioctl(-1, c, (uintptr_t) cfd);
printf("ioctl(-1, " XLAT_FMT
", {charcount=0, charheight=57005, chardata=%p}",
XLAT_SEL(c, s), data);
#if RETVAL_INJECTED
if (c == GIO_FONTX)
printf(" => {charcount=0, charheight=57005, chardata=\"\"}");
#endif
printf(") = " RETVAL);
for (size_t i = 0; i < ARRAY_SIZE(cnts); i++) {
char *p = data_end - MIN(2048, cnts[i] * 32);
cfd->charcount = cnts[i];
cfd->chardata = p + 1;
sys_ioctl(-1, c, (uintptr_t) cfd);
printf("ioctl(-1, " XLAT_FMT
", {charcount=%u, charheight=57005, chardata=",
XLAT_SEL(c, s), cnts[i]);
if (c == PIO_FONTX && cnts[i] * 32 > DEFAULT_STRLEN) {
print_quoted_hex(p + 1, DEFAULT_STRLEN);
printf("...}");
} else {
printf("%p}", p + 1);
}
#if RETVAL_INJECTED
if (c == GIO_FONTX) {
printf(" => {charcount=%u, charheight=57005, chardata=",
cnts[i]);
if (cnts[i] * 32 > DEFAULT_STRLEN) {
print_quoted_hex(p + 1, DEFAULT_STRLEN);
printf("...}");
} else {
printf("%p}", p + 1);
}
}
#endif
printf(") = " RETVAL);
cfd->chardata = p;
sys_ioctl(-1, c, (uintptr_t) cfd);
printf("ioctl(-1, " XLAT_FMT
", {charcount=%u, charheight=57005, chardata=",
XLAT_SEL(c, s), cnts[i]);
if (c == PIO_FONTX) {
print_quoted_hex(p, MIN(DEFAULT_STRLEN, cnts[i] * 32));
if (cnts[i] * 32 > DEFAULT_STRLEN)
printf("...");
} else {
printf("%p", p);
}
printf("}");
#if RETVAL_INJECTED
if (c == GIO_FONTX) {
printf(" => {charcount=%u, charheight=57005, chardata=",
cnts[i]);
print_quoted_hex(p, MIN(DEFAULT_STRLEN, cnts[i] * 32));
if (cnts[i] * 32 > DEFAULT_STRLEN)
printf("...");
printf("}");
}
#endif
printf(") = " RETVAL);
}
}
/* GIO_CMAP, PIO_CMAP */
static void
check_cmap(unsigned int c, const char *s)
{
char *cmap = tail_alloc(48);
fill_memory(cmap, 48);
check_null_invalid(c, s);
sys_ioctl(-1, c, (uintptr_t) (cmap + 1));
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if ((c == PIO_CMAP || RETVAL_INJECTED) && (DEFAULT_STRLEN == 32)) {
printf("\"");
for (unsigned int i = 0; i < MIN(DEFAULT_STRLEN, 48); i++)
printf("\\x%x", 0x81 + i);
printf("\"...");
} else {
printf("%p", cmap + 1);
}
printf(") = " RETVAL);
sys_ioctl(-1, c, (uintptr_t) cmap);
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (c == PIO_CMAP || RETVAL_INJECTED) {
printf("\"");
for (unsigned int i = 0; i < MIN(DEFAULT_STRLEN, 48); i++)
printf("\\x%x", 0x80 + i);
#if DEFAULT_STRLEN == 32
printf("\"...");
#else
printf("\"");
#endif
} else {
printf("%p", cmap);
}
printf(") = " RETVAL);
}
/* KDGKBDIACRUC, KDSKBDIACRUC */
static void
check_diacruc(unsigned int c, const char *s)
{
struct kbdiacrsuc *diacrs0 = tail_alloc(sizeof(diacrs0->kb_cnt));
struct kbdiacrsuc *diacrs1 = tail_alloc(sizeof(diacrs1->kb_cnt) +
4 * sizeof(struct kbdiacruc));
struct kbdiacrsuc *diacrs2 = tail_alloc(sizeof(*diacrs2));
int saved_errno;
check_null_invalid(c, s);
for (size_t i = 0; i < 2; i++) {
diacrs0->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs0);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (RETVAL_INJECTED || c == KDSKBDIACRUC) {
printf("{kb_cnt=%zu, kbdiacruc=", i);
if (i)
printf("%p}", diacrs0->kbdiacruc);
else
printf("[]}");
} else {
printf("%p", diacrs0);
}
errno = saved_errno;
printf(") = " RETVAL);
}
fill_memory32(diacrs1->kbdiacruc, 4 * sizeof(struct kbdiacruc));
for (size_t i = 0; i < 7; i++) {
diacrs1->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs1);
saved_errno = errno;
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
if (RETVAL_INJECTED || c == KDSKBDIACRUC) {
printf("{kb_cnt=%zu, kbdiacruc=[", i);
for (size_t j = 0; j < MIN(i, 4); j++)
printf("%s{diacr=%#x, base=%#x, result=%#x}",
j ? ", " : "",
(unsigned int) (0x80a0c0e0 + j * 3),
(unsigned int) (0x80a0c0e1 + j * 3),
(unsigned int) (0x80a0c0e2 + j * 3));
if (i > 4) {
printf(", ... /* %p */",
diacrs1->kbdiacruc + 4);
}
printf("]}");
} else {
printf("%p", diacrs1);
}
errno = saved_errno;
printf(") = " RETVAL);
}
fill_memory32(diacrs2->kbdiacruc, sizeof(diacrs2->kbdiacruc));
for (size_t i = ARRAY_SIZE(diacrs2->kbdiacruc) - 1;
i < ARRAY_SIZE(diacrs2->kbdiacruc) + 3; i++) {
diacrs2->kb_cnt = i;
sys_ioctl(-1, c, (uintptr_t) diacrs2);
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_SEL(c, s));
saved_errno = errno;
if (RETVAL_INJECTED || c == KDSKBDIACRUC) {
printf("{kb_cnt=%zu, kbdiacruc=[", i);
for (size_t j = 0;
j < MIN(i, MIN(ARRAY_SIZE(diacrs2->kbdiacruc),
DEFAULT_STRLEN)); j++)
printf("%s{diacr=%#x, base=%#x, result=%#x}",
j ? ", " : "",
(unsigned int) (0x80a0c0e0 + j * 3),
(unsigned int) (0x80a0c0e1 + j * 3),
(unsigned int) (0x80a0c0e2 + j * 3));
if (i > MIN(DEFAULT_STRLEN,
ARRAY_SIZE(diacrs2->kbdiacruc)))
printf(", ...");
printf("]}");
} else {
printf("%p", diacrs2);
}
errno = saved_errno;
printf(") = " RETVAL);
}
}
int
main(int argc, char *argv[])
{
static const kernel_ulong_t magic =
(kernel_ulong_t) 0xdeadbeefbadc0dedULL;
static const uint32_t unknown_ioctls[] = {
0xfffffff1, 0xc0007fff, 0xfffb800c, 0xfff8c000,
0xffffffff, 0xffffffff, 0xffffffff, 0xf3ffffff,
};
enum { MAP_ELEM_BIT = sizeof(unknown_ioctls[0]) * CHAR_BIT };
long rc;
#if RETVAL_INJECTED
unsigned long num_skip;
bool locked = false;
if (argc < 2)
error_msg_and_fail("Usage: %s NUM_SKIP", argv[0]);
num_skip = strtoul(argv[1], NULL, 0);
for (unsigned int i = 0; i < num_skip; i++) {
long rc = sys_ioctl(-1, KDGETLED, 0);
printf("ioctl(-1, " XLAT_FMT ", NULL) = %s%s\n",
XLAT_ARGS(KDGETLED), sprintrc(rc),
rc == 42 ? " (INJECTED)" : "");
if (rc != 42)
continue;
locked = true;
break;
}
if (!locked)
error_msg_and_fail("Have not locked on ioctl(-1"
", KDGETLED, NULL) returning 42");
#endif
for (size_t i = 0; i < ARRAY_SIZE(unknown_ioctls); i++) {
for (size_t j = 0; j < MAP_ELEM_BIT; j++) {
if (!((unknown_ioctls[i] >> j) & 1))
continue;
const unsigned int id = i * MAP_ELEM_BIT + j;
sys_ioctl(-1, 'K' << 8 | id, magic);
printf("ioctl(-1, "
NABBR("%#x") VERB(" /* ")
NRAW("_IOC(%s, 0x4b, %#x, 0)") VERB(" */")
", %#lx) = " RETVAL,
#if XLAT_RAW || XLAT_VERBOSE
'K' << 8 | id,
#endif
#if !XLAT_RAW
_IOC_NONE ? "0" : "_IOC_NONE", id,
#endif
(unsigned long) magic);
}
}
/* KIOCSOUND */
sys_ioctl(-1, KIOCSOUND, 0);
printf("ioctl(-1, " XLAT_FMT ", 0" NRAW(" /* off */") ") = " RETVAL,
XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND, 1);
printf("ioctl(-1, " XLAT_FMT ", 1" NRAW(" /* 1193182 Hz */")
") = " RETVAL, XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND, 440);
printf("ioctl(-1, " XLAT_FMT ", 440" NRAW(" /* 2711 Hz */")
") = " RETVAL, XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND, 1193182);
printf("ioctl(-1, " XLAT_FMT ", 1193182" NRAW(" /* 1 Hz */")
") = " RETVAL, XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND, 1193183);
printf("ioctl(-1, " XLAT_FMT ", 1193183" NRAW(" /* off */")
") = " RETVAL, XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND,
(kernel_ulong_t) (0xbadc0ded00000000ULL | 2710));
printf("ioctl(-1, " XLAT_FMT
#if SIZEOF_LONG == 4
", 2710" NRAW(" /* 440 Hz */")
#else
", 13464652297489353366" NRAW(" /* off */")
#endif
") = " RETVAL, XLAT_ARGS(KIOCSOUND));
sys_ioctl(-1, KIOCSOUND, (kernel_ulong_t) 0xbadc0deddeadfaceULL);
printf("ioctl(-1, " XLAT_FMT
#if SIZEOF_LONG == 8
", 13464652301225294542"
#else
", 3735943886"
#endif
NRAW(" /* off */") ") = " RETVAL, XLAT_ARGS(KIOCSOUND));
/* KDMKTONE */
sys_ioctl(-1, KDMKTONE, 0);
printf("ioctl(-1, " XLAT_FMT ", 0" NRAW(" /* off */") ") = " RETVAL,
XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE, 440);
printf("ioctl(-1, " XLAT_FMT ", 440" NRAW(" /* off */") ") = " RETVAL,
XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE, 0xffff);
printf("ioctl(-1, " XLAT_FMT ", 65535" NRAW(" /* off */") ") = " RETVAL,
XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE, 0x10000);
printf("ioctl(-1, " XLAT_FMT ", 1<<16|0" NRAW(" /* off */")
") = " RETVAL, XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE,
(kernel_ulong_t) (0xbadc0ded00000000ULL | 0x10001));
printf("ioctl(-1, " XLAT_FMT ", 1<<16|1" NRAW(" /* 1193182 Hz, 1 ms */")
") = " RETVAL, XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE, 0x1ffff);
printf("ioctl(-1, " XLAT_FMT ", 1<<16|65535" NRAW(" /* 18 Hz, 1 ms */")
") = " RETVAL, XLAT_ARGS(KDMKTONE));
sys_ioctl(-1, KDMKTONE, (kernel_ulong_t) 0xbadc0deddeadfaceULL);
printf("ioctl(-1, " XLAT_FMT ", 57005<<16|64206"
NRAW(" /* 18 Hz, 57005 ms */") ") = " RETVAL,
XLAT_ARGS(KDMKTONE));
/* KDGETLED */
static const struct arg_val led_vecs[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x1, "LED_SCR") },
{ ARG_XLAT_KNOWN(0x7, "LED_SCR|LED_NUM|LED_CAP") },
{ ARG_XLAT_KNOWN(0xfe, "LED_NUM|LED_CAP|0xf8") },
{ (kernel_ulong_t) 0xbadc0dedfeedfaf0ULL,
XLAT_UNKNOWN(0xf0, "LED_???") },
};
unsigned char *leds = tail_alloc(sizeof(*leds));
check_null_invalid(ARG_STR(KDGETLED));
for (size_t i = 0; i < ARRAY_SIZE(led_vecs); i++) {
*leds = led_vecs[i].val;
rc = sys_ioctl(-1, KDGETLED, (uintptr_t) leds);
if (rc >= 0) {
printf("ioctl(-1, " XLAT_FMT ", [%s]) = " RETVAL,
XLAT_ARGS(KDGETLED), led_vecs[i].str);
} else {
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(KDGETLED), leds);
}
}
/* KDSETLED */
for (size_t i = 0; i < ARRAY_SIZE(led_vecs); i++) {
sys_ioctl(-1, KDSETLED, led_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSETLED), led_vecs[i].str);
}
sys_ioctl(-1, KDSETLED, (kernel_ulong_t) 0xdeadc0defeedfaceULL);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSETLED), XLAT_STR(LED_NUM|LED_CAP|0xc8));
/* KDGKBTYPE */
static const struct arg_val kbt_vecs[] = {
{ ARG_XLAT_UNKNOWN(0, "KB_???") },
{ ARG_XLAT_KNOWN(0x1, "KB_84") },
{ ARG_XLAT_KNOWN(0x2, "KB_101") },
{ ARG_XLAT_KNOWN(0x3, "KB_OTHER") },
{ ARG_XLAT_UNKNOWN(0x4, "KB_???") },
{ (kernel_ulong_t) 0xbadc0dedcacafefeULL,
XLAT_UNKNOWN(0xfe, "KB_???") },
};
unsigned char *kbt = tail_alloc(sizeof(*kbt));
check_null_invalid(ARG_STR(KDGKBTYPE));
for (size_t i = 0; i < ARRAY_SIZE(kbt_vecs); i++) {
*kbt = kbt_vecs[i].val;
rc = sys_ioctl(-1, KDGKBTYPE, (uintptr_t) kbt);
if (rc >= 0) {
printf("ioctl(-1, " XLAT_FMT ", [%s]) = " RETVAL,
XLAT_ARGS(KDGKBTYPE), kbt_vecs[i].str);
} else {
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(KDGKBTYPE), kbt);
}
}
/* KDADDIO */
static const struct arg_val iop_vecs[] = {
{ ARG_STR(0) },
{ ARG_STR(0x3b3) },
{ ARG_STR(0x3b4) NRAW(" /* GPFIRST + 0 */") },
{ ARG_STR(0x3c0) NRAW(" /* GPFIRST + 12 */") },
{ ARG_STR(0x3df) NRAW(" /* GPFIRST + 43 */") },
{ ARG_STR(0x3e0) },
{ ARG_STR(0xdeadc0de) },
{ (kernel_ulong_t) 0xbadc0dedfacefeedULL,
#if SIZEOF_LONG > 4
"0xbadc0dedfacefeed"
#else
"0xfacefeed"
#endif
},
};
for (size_t i = 0; i < ARRAY_SIZE(iop_vecs); i++) {
sys_ioctl(-1, KDADDIO, iop_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDADDIO), iop_vecs[i].str);
}
/* KDDELIO */
for (size_t i = 0; i < ARRAY_SIZE(iop_vecs); i++) {
sys_ioctl(-1, KDDELIO, iop_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDDELIO), iop_vecs[i].str);
}
/* KDENABIO */
sys_ioctl(-1, KDENABIO, (kernel_ulong_t) 0xbadc0deddeadface);
printf("ioctl(-1, " XLAT_FMT ") = " RETVAL, XLAT_ARGS(KDENABIO));
/* KDDISABIO */
sys_ioctl(-1, KDDISABIO, (kernel_ulong_t) 0xbadc0deddeadface);
printf("ioctl(-1, " XLAT_FMT ") = " RETVAL, XLAT_ARGS(KDDISABIO));
/* KDSETMODE */
static const struct arg_val mode_vecs[] = {
{ ARG_XLAT_KNOWN(0, "KD_TEXT") },
{ ARG_XLAT_KNOWN(0x1, "KD_GRAPHICS") },
{ ARG_XLAT_KNOWN(0x3, "KD_TEXT1") },
{ ARG_XLAT_UNKNOWN(0x4, "KD_???") },
{ (kernel_ulong_t) 0xbadc0dedcacafefeULL,
"0xcacafefe" NRAW(" /* KD_??? */") },
};
for (size_t i = 0; i < ARRAY_SIZE(mode_vecs); i++) {
sys_ioctl(-1, KDSETMODE, mode_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSETMODE), mode_vecs[i].str);
}
/* KDGETMODE */
unsigned int *mode = tail_alloc(sizeof(*mode));
check_null_invalid(ARG_STR(KDGETMODE));
for (size_t i = 0; i < ARRAY_SIZE(mode_vecs); i++) {
*mode = mode_vecs[i].val;
rc = sys_ioctl(-1, KDGETMODE, (uintptr_t) mode);
if (rc >= 0) {
printf("ioctl(-1, " XLAT_FMT ", [%s]) = " RETVAL,
XLAT_ARGS(KDGETMODE), mode_vecs[i].str);
} else {
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(KDGETMODE), mode);
}
}
/* KDMAPDISP */
sys_ioctl(-1, KDMAPDISP, (kernel_ulong_t) 0xbadc0deddeadface);
printf("ioctl(-1, " XLAT_FMT ") = " RETVAL, XLAT_ARGS(KDMAPDISP));
/* KDUNMAPDISP */
sys_ioctl(-1, KDUNMAPDISP, (kernel_ulong_t) 0xbadc0deddeadface);
printf("ioctl(-1, " XLAT_FMT ") = " RETVAL, XLAT_ARGS(KDUNMAPDISP));
/* GIO_SCRNMAP */
check_scrnmap(ARG_STR(GIO_SCRNMAP));
/* PIO_SCRNMAP */
check_scrnmap(ARG_STR(PIO_SCRNMAP));
/* KDGKBMODE */
static const struct arg_val kbmode_vecs[] = {
{ ARG_XLAT_UNKNOWN(-1, "K_???") },
{ ARG_XLAT_KNOWN(0, "K_RAW") },
{ ARG_XLAT_KNOWN(1, "K_XLATE") },
{ ARG_XLAT_KNOWN(4, "K_OFF") },
{ ARG_XLAT_UNKNOWN(5, "K_???") },
{ (kernel_ulong_t) 0xbadc0dedfeeddeadULL,
XLAT_UNKNOWN(-17965395, "K_???") },
};
check_null_invalid(ARG_STR(KDGKBMODE));
for (size_t i = 0; i < ARRAY_SIZE(kbmode_vecs); i++) {
*mode = kbmode_vecs[i].val;
rc = sys_ioctl(-1, KDGKBMODE, (uintptr_t) mode);
if (rc >= 0) {
printf("ioctl(-1, " XLAT_FMT ", [%s]) = " RETVAL,
XLAT_ARGS(KDGKBMODE), kbmode_vecs[i].str);
} else {
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(KDGKBMODE), mode);
}
}
/* KDSKBMODE */
for (size_t i = 0; i < ARRAY_SIZE(kbmode_vecs); i++) {
sys_ioctl(-1, KDSKBMODE, kbmode_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSKBMODE), kbmode_vecs[i].str);
}
/* KDGKBENT */
check_kbdent(ARG_STR(KDGKBENT));
/* KDSKBENT */
check_kbdent(ARG_STR(KDSKBENT));
/* KDGKBSENT */
check_kbdsent(ARG_STR(KDGKBSENT));
/* KDSKBSENT */
check_kbdsent(ARG_STR(KDSKBSENT));
/* KDGKBDIACR */
check_diacr(ARG_STR(KDGKBDIACR));
/* KDSKBDIACR */
check_diacr(ARG_STR(KDSKBDIACR));
/* KDGETKEYCODE */
check_xetkeycode(ARG_STR(KDGETKEYCODE));
/* KDSETKEYCODE */
check_xetkeycode(ARG_STR(KDSETKEYCODE));
/* KDSIGACCEPT */
static const struct {
kernel_ulong_t val;
const char *str;
} sigaccept_vecs[] = {
{ (kernel_ulong_t) -1ULL,
SIZEOF_LONG == 8 ? "18446744073709551615" : "4294967295" },
{ 0, "0" },
{ ARG_XLAT_KNOWN(SIGHUP, "SIGHUP") },
{ ARG_XLAT_KNOWN(SIGUSR1, "SIGUSR1") },
{ ARG_XLAT_KNOWN(32, "SIGRTMIN") },
{ ARG_XLAT_KNOWN(33, "SIGRT_1") },
{ ARG_STR(128) },
};
for (size_t i = 0; i < ARRAY_SIZE(sigaccept_vecs); i++) {
sys_ioctl(-1, KDSIGACCEPT, sigaccept_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSIGACCEPT), sigaccept_vecs[i].str);
}
/* KDKBDREP */
check_kbdrep(ARG_STR(KDKBDREP));
/* GIO_FONT */
check_font(ARG_STR(GIO_FONT));
/* PIO_FONT */
check_font(ARG_STR(PIO_FONT));
/* KDGKBMETA */
static const struct {
kernel_ulong_t arg;
const char *str;
} meta_vecs[] = {
{ ARG_XLAT_UNKNOWN(0, "K_???") },
{ ARG_XLAT_UNKNOWN(0x1, "K_???") },
{ ARG_XLAT_UNKNOWN(0x2, "K_???") },
{ ARG_XLAT_KNOWN(0x3, "K_METABIT") },
{ ARG_XLAT_KNOWN(0x4, "K_ESCPREFIX") },
{ ARG_XLAT_UNKNOWN(0x5, "K_???") },
{ (kernel_ulong_t) 0xdeadfacebeeffeedULL,
"0xbeeffeed" NRAW(" /* K_??? */") },
};
int *meta = tail_alloc(sizeof(*meta));
check_null_invalid(ARG_STR(KDGKBMETA));
for (size_t i = 0; i < ARRAY_SIZE(meta_vecs); i++) {
*meta = meta_vecs[i].arg;
sys_ioctl(-1, KDGKBMETA, (uintptr_t) meta);
printf("ioctl(-1, " XLAT_FMT ", ", XLAT_ARGS(KDGKBMETA));
#if RETVAL_INJECTED
printf("[%s]", meta_vecs[i].str);
#else
printf("%p", meta);
#endif
printf(") = " RETVAL);
}
/* KDSKBMETA */
for (size_t i = 0; i < ARRAY_SIZE(meta_vecs); i++) {
sys_ioctl(-1, KDSKBMETA, meta_vecs[i].arg);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSKBMETA), meta_vecs[i].str);
}
/* KDGKBLED */
static const struct arg_val kbled_vecs[] = {
{ ARG_STR(0) },
{ ARG_XLAT_KNOWN(0x1, "LED_SCR") },
{ ARG_XLAT_KNOWN(0x7, "LED_SCR|LED_NUM|LED_CAP") },
{ ARG_XLAT_KNOWN(0x10, "LED_SCR<<4") },
{ ARG_XLAT_KNOWN(0x70, "LED_SCR<<4|LED_NUM<<4|LED_CAP<<4") },
{ ARG_XLAT_KNOWN(0xfe, "LED_NUM|LED_CAP|LED_SCR<<4|LED_NUM<<4"
"|LED_CAP<<4|0x88") },
{ (kernel_ulong_t) 0xbadc0dedfeedfa88ULL,
XLAT_UNKNOWN(0x88, "LED_???") },
};
unsigned char *kbleds = tail_alloc(sizeof(*kbleds));
check_null_invalid(ARG_STR(KDGKBLED));
for (size_t i = 0; i < ARRAY_SIZE(kbled_vecs); i++) {
*kbleds = kbled_vecs[i].val;
rc = sys_ioctl(-1, KDGKBLED, (uintptr_t) kbleds);
if (rc >= 0) {
printf("ioctl(-1, " XLAT_FMT ", [%s]) = " RETVAL,
XLAT_ARGS(KDGKBLED), kbled_vecs[i].str);
} else {
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(KDGKBLED), kbleds);
}
}
/* KDSKBLED */
for (size_t i = 0; i < ARRAY_SIZE(kbled_vecs); i++) {
sys_ioctl(-1, KDSKBLED, kbled_vecs[i].val);
printf("ioctl(-1, " XLAT_FMT ", %s) = " RETVAL,
XLAT_ARGS(KDSKBLED), kbled_vecs[i].str);
}
/* GIO_UNIMAP */
check_unimap(ARG_STR(GIO_UNIMAP));
/* PIO_UNIMAP */
check_unimap(ARG_STR(PIO_UNIMAP));
/* PIO_UNIMAPCLR */
struct unimapinit *umi = tail_alloc(sizeof(*umi));
check_null_invalid(ARG_STR(PIO_UNIMAPCLR));
sys_ioctl(-1, PIO_UNIMAPCLR, (uintptr_t) umi + 2);
printf("ioctl(-1, " XLAT_FMT ", %p) = " RETVAL,
XLAT_ARGS(PIO_UNIMAPCLR), (char *) umi + 2);
memset(umi, 0, sizeof(*umi));
sys_ioctl(-1, PIO_UNIMAPCLR, (uintptr_t) umi);
printf("ioctl(-1, " XLAT_FMT ", {advised_hashsize=0"
", advised_hashstep=0, advised_hashlevel=0}) = " RETVAL,
XLAT_ARGS(PIO_UNIMAPCLR));
fill_memory16(umi, sizeof(*umi));
sys_ioctl(-1, PIO_UNIMAPCLR, (uintptr_t) umi);
printf("ioctl(-1, " XLAT_FMT ", {advised_hashsize=32960"
", advised_hashstep=32961, advised_hashlevel=32962}) = " RETVAL,
XLAT_ARGS(PIO_UNIMAPCLR));
/* GIO_UNISCRNMAP */
check_uniscrnmap(ARG_STR(GIO_UNISCRNMAP));
/* PIO_UNISCRNMAP */
check_uniscrnmap(ARG_STR(PIO_UNISCRNMAP));
/* GIO_FONTX */
check_fontx(ARG_STR(GIO_FONTX));
/* PIO_FONTX */
check_fontx(ARG_STR(GIO_FONTX));
/* PIO_FONTRESET */
sys_ioctl(-1, PIO_FONTRESET, (kernel_ulong_t) 0xbadc0deddeadface);
printf("ioctl(-1, " XLAT_FMT ") = " RETVAL, XLAT_ARGS(PIO_FONTRESET));
/* GIO_CMAP */
check_cmap(ARG_STR(GIO_CMAP));
/* PIO_CMAP */
check_cmap(ARG_STR(PIO_CMAP));
/* KDFONTOP */
struct console_font_op *cfo = tail_alloc(sizeof(*cfo));
unsigned char *cfo_data = tail_alloc(2048);
unsigned char *cfo_data_end = cfo_data + 2048;
fill_memory(cfo_data, 2048);
check_null_invalid(ARG_STR(KDFONTOP));
cfo->op = 4;
cfo->flags = 0xdeadbeef;
cfo->width = 0xbadc0ded;
cfo->height = 0xfacecafe;
cfo->charcount = 0xdadfaded;
cfo->data = NULL;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=0x4" NRAW(" /* KD_FONT_OP_??? */")
", flags=" XLAT_KNOWN(0xdeadbeef, "KD_FONT_FLAG_DONT_RECALC"
"|KD_FONT_FLAG_OLD|0x5eadbeee")
", width=3134983661, height=4207856382, charcount=3672092141"
", data=NULL}"
#if RETVAL_INJECTED
" => {width=3134983661, height=4207856382, charcount=3672092141"
", data=NULL}"
#endif
") = " RETVAL, XLAT_ARGS(KDFONTOP));
cfo->op = 0xbeefface;
cfo->flags = 0x5a1ecafe;;
cfo->data = (unsigned char *) cfo;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=0xbeefface"
NRAW(" /* KD_FONT_OP_??? */")
", flags=0x5a1ecafe" NRAW(" /* KD_FONT_FLAG_??? */")
", width=3134983661, height=4207856382, charcount=3672092141"
", data=%p}"
#if RETVAL_INJECTED
" => {width=3134983661, height=4207856382, charcount=3672092141"
", data=%p}"
#endif
") = " RETVAL, XLAT_ARGS(KDFONTOP), cfo
#if RETVAL_INJECTED
, cfo
#endif
);
static const struct strval32 kdfont_ops[] = {
{ ARG_XLAT_KNOWN(0, "KD_FONT_OP_SET") },
{ ARG_XLAT_KNOWN(0x1, "KD_FONT_OP_GET") },
};
for (size_t i = 0; i < ARRAY_SIZE(kdfont_ops); i++) {
cfo->op = kdfont_ops[i].val;
cfo->flags = 1;
cfo->width = 0;
cfo->height = 0;
cfo->charcount = 0;
cfo->data = NULL;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags="
XLAT_FMT ", width=0, height=0, charcount=0, data=NULL}",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str,
XLAT_ARGS(KD_FONT_FLAG_DONT_RECALC));
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf(" => {width=0, height=0, charcount=0"
", data=NULL}");
}
printf(") = " RETVAL);
cfo->data = cfo_data_end;
for (size_t j = 0; j < 2; j++) {
cfo->charcount = j;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags="
XLAT_FMT ", width=0, height=0, charcount=%zu"
", data=",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str,
XLAT_ARGS(KD_FONT_FLAG_DONT_RECALC), j);
if (kdfont_ops[i].val == KD_FONT_OP_SET)
printf("\"\"");
else
printf("%p", cfo_data_end);
#if RETVAL_INJECTED
if (kdfont_ops[i].val == KD_FONT_OP_GET) {
printf("} => {width=0, height=0, charcount=%zu"
", data=\"\"", j);
}
#endif
printf("}) = " RETVAL);
}
cfo->flags = 0;
cfo->width = 1;
cfo->data = cfo_data_end - 31;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags=0, width=1"
", height=0, charcount=1, data=%p}",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str,
cfo_data_end - 31);
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf(" => {width=1, height=0, charcount=1, data=%p}",
cfo_data_end - 31);
}
printf(") = " RETVAL);
cfo->data = cfo_data_end - 32;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags=0, width=1"
", height=0, charcount=1, data=",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str);
if (kdfont_ops[i].val == KD_FONT_OP_SET)
print_quoted_hex(cfo_data_end - 32, 32);
else
printf("%p", cfo_data_end - 32);
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf("} => {width=1, height=0, charcount=1, data=");
print_quoted_hex(cfo_data_end - 32, 32);
}
printf("}) = " RETVAL);
cfo->charcount = 32;
cfo->data = cfo_data_end - 1023;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags=0, width=1"
", height=0, charcount=32, data=",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str);
if (kdfont_ops[i].val == KD_FONT_OP_SET && DEFAULT_STRLEN == 32)
{
print_quoted_hex(cfo_data_end - 1023, 32);
printf("...");
} else {
printf("%p", cfo_data_end - 1023);
}
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf("} => {width=1, height=0, charcount=32, data=");
#if DEFAULT_STRLEN == 32
print_quoted_hex(cfo_data_end - 1023, 32);
printf("...");
#else
printf("%p", cfo_data_end - 1023);
#endif
}
printf("}) = " RETVAL);
cfo->data = cfo_data_end - 1024;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags=0, width=1"
", height=0, charcount=32, data=",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str);
if (kdfont_ops[i].val == KD_FONT_OP_SET) {
print_quoted_hex(cfo_data_end - 1024, DEFAULT_STRLEN);
#if DEFAULT_STRLEN == 32
printf("...");
#endif
} else {
printf("%p", cfo_data_end - 1024);
}
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf("} => {width=1, height=0, charcount=32, data=");
print_quoted_hex(cfo_data_end - 1024, DEFAULT_STRLEN);
#if DEFAULT_STRLEN == 32
printf("...");
#endif
}
printf("}) = " RETVAL);
cfo->charcount = 256;
cfo->data = cfo_data_end - 1025;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=%s, flags=0, width=1"
", height=0, charcount=256, data=",
XLAT_ARGS(KDFONTOP), kdfont_ops[i].str);
if (kdfont_ops[i].val == KD_FONT_OP_SET) {
print_quoted_hex(cfo_data_end - 1025, DEFAULT_STRLEN);
printf("...");
} else {
printf("%p", cfo_data_end - 1025);
}
if (kdfont_ops[i].val == KD_FONT_OP_GET && RETVAL_INJECTED) {
printf("} => {width=1, height=0, charcount=256, data=");
print_quoted_hex(cfo_data_end - 1025, DEFAULT_STRLEN);
printf("...");
}
printf("}) = " RETVAL);
}
cfo->op = 2;
cfo->data = NULL;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=" XLAT_FMT ", width=1, height=0"
", data=NULL}"
#if RETVAL_INJECTED
" => {width=1, height=0}"
#endif
") = " RETVAL,
XLAT_ARGS(KDFONTOP), XLAT_ARGS(KD_FONT_OP_SET_DEFAULT));
cfo->data = cfo_data_end - 1;
cfo->data[0] = '\0';
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=" XLAT_FMT ", width=1, height=0"
", data=\"\"}"
#if RETVAL_INJECTED
" => {width=1, height=0}"
#endif
") = " RETVAL,
XLAT_ARGS(KDFONTOP), XLAT_ARGS(KD_FONT_OP_SET_DEFAULT));
cfo->data[0] = 'x';
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=" XLAT_FMT ", width=1, height=0"
", data=%p}"
#if RETVAL_INJECTED
" => {width=1, height=0}"
#endif
") = " RETVAL,
XLAT_ARGS(KDFONTOP), XLAT_ARGS(KD_FONT_OP_SET_DEFAULT),
cfo_data_end - 1);
cfo->width = 0xcafebeef;
cfo->height = 0xbea7bee5;
cfo->data = cfo_data_end - 32;
strcpy((char *) cfo->data,
"\1\2\3\r\n\t\v\f\\\"OH\377HAI\7\10\02101234567890x");
for (size_t j = 0; j < 2; j++) {
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=" XLAT_FMT
", width=3405692655, height=3198664421, data=\"\\1\\2\\3"
"\\r\\n\\t\\v\\f\\\\\\\"OH\\377HAI\\7\\10\\0210123456789"
"0x\"%s}"
#if RETVAL_INJECTED
" => {width=3405692655, height=3198664421}"
#endif
") = " RETVAL,
XLAT_ARGS(KDFONTOP), XLAT_ARGS(KD_FONT_OP_SET_DEFAULT),
j ? "..." : "");
cfo->data[31] = 'y';
}
cfo->op = 3;
cfo->height = 0;
sys_ioctl(-1, KDFONTOP, (uintptr_t) cfo);
printf("ioctl(-1, " XLAT_FMT ", {op=" XLAT_FMT ", height=0}) = " RETVAL,
XLAT_ARGS(KDFONTOP), XLAT_ARGS(KD_FONT_OP_COPY));
/* KDGKBDIACRUC */
check_diacruc(ARG_STR(KDGKBDIACRUC));
/* KDSKBDIACRUC */
check_diacruc(ARG_STR(KDSKBDIACRUC));
puts("+++ exited with 0 +++");
return 0;
}