2 * Syscall implementations for semihosting.
4 * Copyright (c) 2022 Linaro
6 * SPDX-License-Identifier: GPL-2.0-or-later
9 #include "qemu/osdep.h"
10 #include "exec/gdbstub.h"
11 #include "semihosting/guestfd.h"
12 #include "semihosting/syscalls.h"
13 #include "semihosting/console.h"
14 #ifdef CONFIG_USER_ONLY
17 #include "semihosting/softmmu-uaccess.h"
22 * Validate or compute the length of the string (including terminator).
24 static int validate_strlen(CPUState *cs, target_ulong str, target_ulong tlen)
26 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
30 ssize_t slen = target_strlen(str);
35 if (slen >= INT32_MAX) {
40 if (tlen > INT32_MAX) {
43 if (get_user_u8(c, str + tlen - 1)) {
52 static int validate_lock_user_string(char **pstr, CPUState *cs,
53 target_ulong tstr, target_ulong tlen)
55 int ret = validate_strlen(cs, tstr, tlen);
56 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
60 str = lock_user(VERIFY_READ, tstr, ret, true);
61 ret = str ? 0 : -EFAULT;
68 * TODO: Note that gdb always stores the stat structure big-endian.
69 * So far, that's ok, as the only two targets using this are also
70 * big-endian. Until we do something with gdb, also produce the
71 * same big-endian result from the host.
73 static int copy_stat_to_user(CPUState *cs, target_ulong addr,
76 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
79 if (s->st_dev != (uint32_t)s->st_dev ||
80 s->st_ino != (uint32_t)s->st_ino) {
84 p = lock_user(VERIFY_WRITE, addr, sizeof(struct gdb_stat), 0);
89 p->gdb_st_dev = cpu_to_be32(s->st_dev);
90 p->gdb_st_ino = cpu_to_be32(s->st_ino);
91 p->gdb_st_mode = cpu_to_be32(s->st_mode);
92 p->gdb_st_nlink = cpu_to_be32(s->st_nlink);
93 p->gdb_st_uid = cpu_to_be32(s->st_uid);
94 p->gdb_st_gid = cpu_to_be32(s->st_gid);
95 p->gdb_st_rdev = cpu_to_be32(s->st_rdev);
96 p->gdb_st_size = cpu_to_be64(s->st_size);
98 /* Windows stat is missing some fields. */
99 p->gdb_st_blksize = 0;
100 p->gdb_st_blocks = 0;
102 p->gdb_st_blksize = cpu_to_be64(s->st_blksize);
103 p->gdb_st_blocks = cpu_to_be64(s->st_blocks);
105 p->gdb_st_atime = cpu_to_be32(s->st_atime);
106 p->gdb_st_mtime = cpu_to_be32(s->st_mtime);
107 p->gdb_st_ctime = cpu_to_be32(s->st_ctime);
109 unlock_user(p, addr, sizeof(struct gdb_stat));
114 * GDB semihosting syscall implementations.
117 static gdb_syscall_complete_cb gdb_open_complete;
119 static void gdb_open_cb(CPUState *cs, uint64_t ret, int err)
122 int guestfd = alloc_guestfd();
123 associate_guestfd(guestfd, ret);
126 gdb_open_complete(cs, ret, err);
129 static void gdb_open(CPUState *cs, gdb_syscall_complete_cb complete,
130 target_ulong fname, target_ulong fname_len,
131 int gdb_flags, int mode)
133 int len = validate_strlen(cs, fname, fname_len);
135 complete(cs, -1, -len);
139 gdb_open_complete = complete;
140 gdb_do_syscall(gdb_open_cb, "open,%s,%x,%x",
141 fname, len, (target_ulong)gdb_flags, (target_ulong)mode);
144 static void gdb_close(CPUState *cs, gdb_syscall_complete_cb complete,
147 gdb_do_syscall(complete, "close,%x", (target_ulong)gf->hostfd);
150 static void gdb_read(CPUState *cs, gdb_syscall_complete_cb complete,
151 GuestFD *gf, target_ulong buf, target_ulong len)
153 gdb_do_syscall(complete, "read,%x,%x,%x",
154 (target_ulong)gf->hostfd, buf, len);
157 static void gdb_write(CPUState *cs, gdb_syscall_complete_cb complete,
158 GuestFD *gf, target_ulong buf, target_ulong len)
160 gdb_do_syscall(complete, "write,%x,%x,%x",
161 (target_ulong)gf->hostfd, buf, len);
164 static void gdb_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
165 GuestFD *gf, int64_t off, int gdb_whence)
167 gdb_do_syscall(complete, "lseek,%x,%lx,%x",
168 (target_ulong)gf->hostfd, off, (target_ulong)gdb_whence);
171 static void gdb_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
174 gdb_do_syscall(complete, "isatty,%x", (target_ulong)gf->hostfd);
177 static void gdb_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
178 GuestFD *gf, target_ulong addr)
180 gdb_do_syscall(complete, "fstat,%x,%x", (target_ulong)gf->hostfd, addr);
183 static void gdb_stat(CPUState *cs, gdb_syscall_complete_cb complete,
184 target_ulong fname, target_ulong fname_len,
187 int len = validate_strlen(cs, fname, fname_len);
189 complete(cs, -1, -len);
193 gdb_do_syscall(complete, "stat,%s,%x", fname, len, addr);
196 static void gdb_remove(CPUState *cs, gdb_syscall_complete_cb complete,
197 target_ulong fname, target_ulong fname_len)
199 int len = validate_strlen(cs, fname, fname_len);
201 complete(cs, -1, -len);
205 gdb_do_syscall(complete, "unlink,%s", fname, len);
208 static void gdb_rename(CPUState *cs, gdb_syscall_complete_cb complete,
209 target_ulong oname, target_ulong oname_len,
210 target_ulong nname, target_ulong nname_len)
214 olen = validate_strlen(cs, oname, oname_len);
216 complete(cs, -1, -olen);
219 nlen = validate_strlen(cs, nname, nname_len);
221 complete(cs, -1, -nlen);
225 gdb_do_syscall(complete, "rename,%s,%s", oname, olen, nname, nlen);
228 static void gdb_system(CPUState *cs, gdb_syscall_complete_cb complete,
229 target_ulong cmd, target_ulong cmd_len)
231 int len = validate_strlen(cs, cmd, cmd_len);
233 complete(cs, -1, -len);
237 gdb_do_syscall(complete, "system,%s", cmd, len);
240 static void gdb_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
241 target_ulong tv_addr, target_ulong tz_addr)
243 gdb_do_syscall(complete, "gettimeofday,%x,%x", tv_addr, tz_addr);
247 * Host semihosting syscall implementations.
250 static void host_open(CPUState *cs, gdb_syscall_complete_cb complete,
251 target_ulong fname, target_ulong fname_len,
252 int gdb_flags, int mode)
254 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
258 ret = validate_lock_user_string(&p, cs, fname, fname_len);
260 complete(cs, -1, -ret);
264 if (gdb_flags & GDB_O_WRONLY) {
265 host_flags = O_WRONLY;
266 } else if (gdb_flags & GDB_O_RDWR) {
269 host_flags = O_RDONLY;
271 if (gdb_flags & GDB_O_CREAT) {
272 host_flags |= O_CREAT;
274 if (gdb_flags & GDB_O_TRUNC) {
275 host_flags |= O_TRUNC;
277 if (gdb_flags & GDB_O_EXCL) {
278 host_flags |= O_EXCL;
281 ret = open(p, host_flags, mode);
283 complete(cs, -1, errno);
285 int guestfd = alloc_guestfd();
286 associate_guestfd(guestfd, ret);
287 complete(cs, guestfd, 0);
289 unlock_user(p, fname, 0);
292 static void host_close(CPUState *cs, gdb_syscall_complete_cb complete,
296 * Only close the underlying host fd if it's one we opened on behalf
297 * of the guest in SYS_OPEN.
299 if (gf->hostfd != STDIN_FILENO &&
300 gf->hostfd != STDOUT_FILENO &&
301 gf->hostfd != STDERR_FILENO &&
302 close(gf->hostfd) < 0) {
303 complete(cs, -1, errno);
309 static void host_read(CPUState *cs, gdb_syscall_complete_cb complete,
310 GuestFD *gf, target_ulong buf, target_ulong len)
312 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
313 void *ptr = lock_user(VERIFY_WRITE, buf, len, 0);
317 complete(cs, -1, EFAULT);
321 ret = read(gf->hostfd, ptr, len);
322 } while (ret == -1 && errno == EINTR);
324 complete(cs, -1, errno);
325 unlock_user(ptr, buf, 0);
327 complete(cs, ret, 0);
328 unlock_user(ptr, buf, ret);
332 static void host_write(CPUState *cs, gdb_syscall_complete_cb complete,
333 GuestFD *gf, target_ulong buf, target_ulong len)
335 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
336 void *ptr = lock_user(VERIFY_READ, buf, len, 1);
340 complete(cs, -1, EFAULT);
343 ret = write(gf->hostfd, ptr, len);
344 complete(cs, ret, ret == -1 ? errno : 0);
345 unlock_user(ptr, buf, 0);
348 static void host_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
349 GuestFD *gf, int64_t off, int whence)
351 /* So far, all hosts use the same values. */
352 QEMU_BUILD_BUG_ON(GDB_SEEK_SET != SEEK_SET);
353 QEMU_BUILD_BUG_ON(GDB_SEEK_CUR != SEEK_CUR);
354 QEMU_BUILD_BUG_ON(GDB_SEEK_END != SEEK_END);
360 ret = lseek(gf->hostfd, ret, whence);
368 complete(cs, ret, err);
371 static void host_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
374 int ret = isatty(gf->hostfd);
375 complete(cs, ret, ret ? 0 : errno);
378 static void host_flen(CPUState *cs, gdb_syscall_complete_cb complete,
383 if (fstat(gf->hostfd, &buf) < 0) {
384 complete(cs, -1, errno);
386 complete(cs, buf.st_size, 0);
390 static void host_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
391 GuestFD *gf, target_ulong addr)
396 ret = fstat(gf->hostfd, &buf);
398 complete(cs, -1, errno);
401 ret = copy_stat_to_user(cs, addr, &buf);
402 complete(cs, ret ? -1 : 0, ret ? -ret : 0);
405 static void host_stat(CPUState *cs, gdb_syscall_complete_cb complete,
406 target_ulong fname, target_ulong fname_len,
409 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
414 ret = validate_lock_user_string(&name, cs, fname, fname_len);
416 complete(cs, -1, -ret);
420 ret = stat(name, &buf);
424 ret = copy_stat_to_user(cs, addr, &buf);
431 complete(cs, ret, err);
432 unlock_user(name, fname, 0);
435 static void host_remove(CPUState *cs, gdb_syscall_complete_cb complete,
436 target_ulong fname, target_ulong fname_len)
438 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
442 ret = validate_lock_user_string(&p, cs, fname, fname_len);
444 complete(cs, -1, -ret);
449 complete(cs, ret, ret ? errno : 0);
450 unlock_user(p, fname, 0);
453 static void host_rename(CPUState *cs, gdb_syscall_complete_cb complete,
454 target_ulong oname, target_ulong oname_len,
455 target_ulong nname, target_ulong nname_len)
457 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
461 ret = validate_lock_user_string(&ostr, cs, oname, oname_len);
463 complete(cs, -1, -ret);
466 ret = validate_lock_user_string(&nstr, cs, nname, nname_len);
468 unlock_user(ostr, oname, 0);
469 complete(cs, -1, -ret);
473 ret = rename(ostr, nstr);
474 complete(cs, ret, ret ? errno : 0);
475 unlock_user(ostr, oname, 0);
476 unlock_user(nstr, nname, 0);
479 static void host_system(CPUState *cs, gdb_syscall_complete_cb complete,
480 target_ulong cmd, target_ulong cmd_len)
482 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
486 ret = validate_lock_user_string(&p, cs, cmd, cmd_len);
488 complete(cs, -1, -ret);
493 complete(cs, ret, ret == -1 ? errno : 0);
494 unlock_user(p, cmd, 0);
497 static void host_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
498 target_ulong tv_addr, target_ulong tz_addr)
500 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
501 struct gdb_timeval *p;
504 /* GDB fails on non-null TZ, so be consistent. */
506 complete(cs, -1, EINVAL);
510 p = lock_user(VERIFY_WRITE, tv_addr, sizeof(struct gdb_timeval), 0);
512 complete(cs, -1, EFAULT);
516 /* TODO: Like stat, gdb always produces big-endian results; match it. */
517 rt = g_get_real_time();
518 p->tv_sec = cpu_to_be32(rt / G_USEC_PER_SEC);
519 p->tv_usec = cpu_to_be64(rt % G_USEC_PER_SEC);
520 unlock_user(p, tv_addr, sizeof(struct gdb_timeval));
523 #ifndef CONFIG_USER_ONLY
524 static void host_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
525 GuestFD *gf, GIOCondition cond, int timeout)
528 * Since this is only used by xtensa in system mode, and stdio is
529 * handled through GuestFDConsole, and there are no semihosting
530 * system calls for sockets and the like, that means this descriptor
531 * must be a normal file. Normal files never block and are thus
534 complete(cs, cond & (G_IO_IN | G_IO_OUT), 0);
539 * Static file semihosting syscall implementations.
542 static void staticfile_read(CPUState *cs, gdb_syscall_complete_cb complete,
543 GuestFD *gf, target_ulong buf, target_ulong len)
545 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
546 target_ulong rest = gf->staticfile.len - gf->staticfile.off;
552 ptr = lock_user(VERIFY_WRITE, buf, len, 0);
554 complete(cs, -1, EFAULT);
557 memcpy(ptr, gf->staticfile.data + gf->staticfile.off, len);
558 gf->staticfile.off += len;
559 complete(cs, len, 0);
560 unlock_user(ptr, buf, len);
563 static void staticfile_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
564 GuestFD *gf, int64_t off, int gdb_whence)
568 switch (gdb_whence) {
573 ret = gf->staticfile.off + off;
576 ret = gf->staticfile.len + off;
582 if (ret >= 0 && ret <= gf->staticfile.len) {
583 gf->staticfile.off = ret;
584 complete(cs, ret, 0);
586 complete(cs, -1, EINVAL);
590 static void staticfile_flen(CPUState *cs, gdb_syscall_complete_cb complete,
593 complete(cs, gf->staticfile.len, 0);
597 * Console semihosting syscall implementations.
600 static void console_read(CPUState *cs, gdb_syscall_complete_cb complete,
601 GuestFD *gf, target_ulong buf, target_ulong len)
603 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
607 ptr = lock_user(VERIFY_WRITE, buf, len, 0);
609 complete(cs, -1, EFAULT);
612 ret = qemu_semihosting_console_read(cs, ptr, len);
613 complete(cs, ret, 0);
614 unlock_user(ptr, buf, ret);
617 static void console_write(CPUState *cs, gdb_syscall_complete_cb complete,
618 GuestFD *gf, target_ulong buf, target_ulong len)
620 CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
621 char *ptr = lock_user(VERIFY_READ, buf, len, 1);
625 complete(cs, -1, EFAULT);
628 ret = qemu_semihosting_console_write(ptr, len);
629 complete(cs, ret ? ret : -1, ret ? 0 : EIO);
630 unlock_user(ptr, buf, ret);
633 static void console_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
634 GuestFD *gf, target_ulong addr)
636 static const struct stat tty_buf = {
637 .st_mode = 020666, /* S_IFCHR, ugo+rw */
638 .st_rdev = 5, /* makedev(5, 0) -- linux /dev/tty */
642 ret = copy_stat_to_user(cs, addr, &tty_buf);
643 complete(cs, ret ? -1 : 0, ret ? -ret : 0);
646 #ifndef CONFIG_USER_ONLY
647 static void console_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
648 GuestFD *gf, GIOCondition cond, int timeout)
650 /* The semihosting console does not support urgent data or errors. */
651 cond &= G_IO_IN | G_IO_OUT;
654 * Since qemu_semihosting_console_write never blocks, we can
655 * consider output always ready -- leave G_IO_OUT alone.
656 * All that remains is to conditionally signal input ready.
657 * Since output ready causes an immediate return, only block
660 * TODO: Implement proper timeout. For now, only support
661 * indefinite wait or immediate poll.
663 if (cond == G_IO_IN && timeout < 0) {
664 qemu_semihosting_console_block_until_ready(cs);
665 /* We returned -- input must be ready. */
666 } else if ((cond & G_IO_IN) && !qemu_semihosting_console_ready()) {
670 complete(cs, cond, 0);
675 * Syscall entry points.
678 void semihost_sys_open(CPUState *cs, gdb_syscall_complete_cb complete,
679 target_ulong fname, target_ulong fname_len,
680 int gdb_flags, int mode)
682 if (use_gdb_syscalls()) {
683 gdb_open(cs, complete, fname, fname_len, gdb_flags, mode);
685 host_open(cs, complete, fname, fname_len, gdb_flags, mode);
689 void semihost_sys_close(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
691 GuestFD *gf = get_guestfd(fd);
694 complete(cs, -1, EBADF);
699 gdb_close(cs, complete, gf);
702 host_close(cs, complete, gf);
709 g_assert_not_reached();
714 void semihost_sys_read_gf(CPUState *cs, gdb_syscall_complete_cb complete,
715 GuestFD *gf, target_ulong buf, target_ulong len)
718 * Bound length for 64-bit guests on 32-bit hosts, not overlowing ssize_t.
719 * Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
720 * idea to do this unconditionally.
722 if (len > INT32_MAX) {
727 gdb_read(cs, complete, gf, buf, len);
730 host_read(cs, complete, gf, buf, len);
733 staticfile_read(cs, complete, gf, buf, len);
736 console_read(cs, complete, gf, buf, len);
739 g_assert_not_reached();
743 void semihost_sys_read(CPUState *cs, gdb_syscall_complete_cb complete,
744 int fd, target_ulong buf, target_ulong len)
746 GuestFD *gf = get_guestfd(fd);
749 semihost_sys_read_gf(cs, complete, gf, buf, len);
751 complete(cs, -1, EBADF);
755 void semihost_sys_write_gf(CPUState *cs, gdb_syscall_complete_cb complete,
756 GuestFD *gf, target_ulong buf, target_ulong len)
759 * Bound length for 64-bit guests on 32-bit hosts, not overlowing ssize_t.
760 * Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
761 * idea to do this unconditionally.
763 if (len > INT32_MAX) {
768 gdb_write(cs, complete, gf, buf, len);
771 host_write(cs, complete, gf, buf, len);
774 console_write(cs, complete, gf, buf, len);
777 /* Static files are never open for writing: EBADF. */
778 complete(cs, -1, EBADF);
781 g_assert_not_reached();
785 void semihost_sys_write(CPUState *cs, gdb_syscall_complete_cb complete,
786 int fd, target_ulong buf, target_ulong len)
788 GuestFD *gf = get_guestfd(fd);
791 semihost_sys_write_gf(cs, complete, gf, buf, len);
793 complete(cs, -1, EBADF);
797 void semihost_sys_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
798 int fd, int64_t off, int gdb_whence)
800 GuestFD *gf = get_guestfd(fd);
803 complete(cs, -1, EBADF);
808 gdb_lseek(cs, complete, gf, off, gdb_whence);
811 host_lseek(cs, complete, gf, off, gdb_whence);
814 staticfile_lseek(cs, complete, gf, off, gdb_whence);
817 complete(cs, -1, ESPIPE);
820 g_assert_not_reached();
824 void semihost_sys_isatty(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
826 GuestFD *gf = get_guestfd(fd);
829 complete(cs, 0, EBADF);
834 gdb_isatty(cs, complete, gf);
837 host_isatty(cs, complete, gf);
840 complete(cs, 0, ENOTTY);
846 g_assert_not_reached();
850 void semihost_sys_flen(CPUState *cs, gdb_syscall_complete_cb fstat_cb,
851 gdb_syscall_complete_cb flen_cb, int fd,
852 target_ulong fstat_addr)
854 GuestFD *gf = get_guestfd(fd);
857 flen_cb(cs, -1, EBADF);
862 gdb_fstat(cs, fstat_cb, gf, fstat_addr);
865 host_flen(cs, flen_cb, gf);
868 staticfile_flen(cs, flen_cb, gf);
872 g_assert_not_reached();
876 void semihost_sys_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
877 int fd, target_ulong addr)
879 GuestFD *gf = get_guestfd(fd);
882 complete(cs, -1, EBADF);
887 gdb_fstat(cs, complete, gf, addr);
890 host_fstat(cs, complete, gf, addr);
893 console_fstat(cs, complete, gf, addr);
897 g_assert_not_reached();
901 void semihost_sys_stat(CPUState *cs, gdb_syscall_complete_cb complete,
902 target_ulong fname, target_ulong fname_len,
905 if (use_gdb_syscalls()) {
906 gdb_stat(cs, complete, fname, fname_len, addr);
908 host_stat(cs, complete, fname, fname_len, addr);
912 void semihost_sys_remove(CPUState *cs, gdb_syscall_complete_cb complete,
913 target_ulong fname, target_ulong fname_len)
915 if (use_gdb_syscalls()) {
916 gdb_remove(cs, complete, fname, fname_len);
918 host_remove(cs, complete, fname, fname_len);
922 void semihost_sys_rename(CPUState *cs, gdb_syscall_complete_cb complete,
923 target_ulong oname, target_ulong oname_len,
924 target_ulong nname, target_ulong nname_len)
926 if (use_gdb_syscalls()) {
927 gdb_rename(cs, complete, oname, oname_len, nname, nname_len);
929 host_rename(cs, complete, oname, oname_len, nname, nname_len);
933 void semihost_sys_system(CPUState *cs, gdb_syscall_complete_cb complete,
934 target_ulong cmd, target_ulong cmd_len)
936 if (use_gdb_syscalls()) {
937 gdb_system(cs, complete, cmd, cmd_len);
939 host_system(cs, complete, cmd, cmd_len);
943 void semihost_sys_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
944 target_ulong tv_addr, target_ulong tz_addr)
946 if (use_gdb_syscalls()) {
947 gdb_gettimeofday(cs, complete, tv_addr, tz_addr);
949 host_gettimeofday(cs, complete, tv_addr, tz_addr);
953 #ifndef CONFIG_USER_ONLY
954 void semihost_sys_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
955 int fd, GIOCondition cond, int timeout)
957 GuestFD *gf = get_guestfd(fd);
960 complete(cs, G_IO_NVAL, 1);
965 complete(cs, G_IO_NVAL, 1);
968 host_poll_one(cs, complete, gf, cond, timeout);
971 console_poll_one(cs, complete, gf, cond, timeout);
975 g_assert_not_reached();