Merge remote-tracking branch 'remotes/vivier2/tags/linux-user-for-5.0-pull-request' into staging

+21 -1

configure

··· 455 455 guest_agent_msi="" 456 456 vss_win32_sdk="" 457 457 win_sdk="no" 458 - want_tools="yes" 458 + want_tools="" 459 459 libiscsi="" 460 460 libnfs="" 461 461 coroutine="" ··· 2214 2214 fi 2215 2215 2216 2216 ########################################## 2217 + # system tools 2218 + if test -z "$want_tools"; then 2219 + if test "$softmmu" = "no"; then 2220 + want_tools=no 2221 + else 2222 + want_tools=yes 2223 + fi 2224 + fi 2225 + 2226 + ########################################## 2217 2227 # cocoa implies not SDL or GTK 2218 2228 # (the cocoa UI code currently assumes it is always the active UI 2219 2229 # and doesn't interact well with other UI frontend code) ··· 4133 4143 fdt=yes 4134 4144 elif test "$fdt" != "yes" ; then 4135 4145 fdt=no 4146 + fi 4147 + 4148 + # fdt is only required when building softmmu targets 4149 + if test -z "$fdt" -a "$softmmu" != "yes" ; then 4150 + fdt="no" 4136 4151 fi 4137 4152 4138 4153 if test "$fdt" != "no" ; then ··· 6077 6092 6078 6093 ########################################## 6079 6094 # check for slirp 6095 + 6096 + # slirp is only required when building softmmu targets 6097 + if test -z "$slirp" -a "$softmmu" != "yes" ; then 6098 + slirp="no" 6099 + fi 6080 6100 6081 6101 case "$slirp" in 6082 6102 "" | yes)

+2

include/qemu/log.h

··· 62 62 #define CPU_LOG_TB_OP_IND (1 << 16) 63 63 #define CPU_LOG_TB_FPU (1 << 17) 64 64 #define CPU_LOG_PLUGIN (1 << 18) 65 + /* LOG_STRACE is used for user-mode strace logging. */ 66 + #define LOG_STRACE (1 << 19) 65 67 66 68 /* Lock output for a series of related logs. Since this is not needed 67 69 * for a single qemu_log / qemu_log_mask / qemu_log_mask_and_addr, we

+3 -2

linux-user/arm/cpu_loop.c

··· 349 349 env->regs[0] = cpu_get_tls(env); 350 350 break; 351 351 default: 352 - gemu_log("qemu: Unsupported ARM syscall: 0x%x\n", 353 - n); 352 + qemu_log_mask(LOG_UNIMP, 353 + "qemu: Unsupported ARM syscall: 0x%x\n", 354 + n); 354 355 env->regs[0] = -TARGET_ENOSYS; 355 356 break; 356 357 }

+35 -20

linux-user/fd-trans.c

··· 514 514 u32[1] = tswap32(u32[1]); /* optmask */ 515 515 break; 516 516 default: 517 - gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type); 517 + qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BR type %d\n", 518 + nlattr->nla_type); 518 519 break; 519 520 } 520 521 return 0; ··· 577 578 case QEMU_IFLA_BRPORT_BRIDGE_ID: 578 579 break; 579 580 default: 580 - gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type); 581 + qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_BRPORT type %d\n", 582 + nlattr->nla_type); 581 583 break; 582 584 } 583 585 return 0; ··· 605 607 *u32 = tswap32(*u32); 606 608 break; 607 609 default: 608 - gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type); 610 + qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_TUN type %d\n", 611 + nlattr->nla_type); 609 612 break; 610 613 } 611 614 return 0; ··· 652 655 NULL, 653 656 host_to_target_data_tun_nlattr); 654 657 } else { 655 - gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name); 658 + qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_KIND %s\n", 659 + li_context->name); 656 660 } 657 661 break; 658 662 case QEMU_IFLA_INFO_SLAVE_DATA: ··· 663 667 NULL, 664 668 host_to_target_slave_data_bridge_nlattr); 665 669 } else { 666 - gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n", 670 + qemu_log_mask(LOG_UNIMP, "Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n", 667 671 li_context->slave_name); 668 672 } 669 673 break; 670 674 default: 671 - gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type); 675 + qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA_INFO type: %d\n", 676 + nlattr->nla_type); 672 677 break; 673 678 } 674 679 ··· 690 695 } 691 696 break; 692 697 default: 693 - gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type); 698 + qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET type: %d\n", 699 + nlattr->nla_type); 694 700 } 695 701 return 0; 696 702 } ··· 741 747 } 742 748 break; 743 749 default: 744 - gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type); 750 + qemu_log_mask(LOG_UNIMP, "Unknown host AF_INET6 type: %d\n", 751 + nlattr->nla_type); 745 752 } 746 753 return 0; 747 754 } ··· 759 766 NULL, 760 767 host_to_target_data_inet6_nlattr); 761 768 default: 762 - gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type); 769 + qemu_log_mask(LOG_UNIMP, "Unknown host AF_SPEC type: %d\n", 770 + nlattr->nla_type); 763 771 break; 764 772 } 765 773 return 0; ··· 780 788 *u32 = tswap32(*u32); 781 789 break; 782 790 default: 783 - gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type); 791 + qemu_log_mask( 792 + LOG_UNIMP, "Unknown host XDP type: %d\n", nlattr->nla_type); 784 793 break; 785 794 } 786 795 return 0; ··· 920 929 NULL, 921 930 host_to_target_data_xdp_nlattr); 922 931 default: 923 - gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type); 932 + qemu_log_mask(LOG_UNIMP, "Unknown host QEMU_IFLA type: %d\n", 933 + rtattr->rta_type); 924 934 break; 925 935 } 926 936 return 0; ··· 954 964 ci->tstamp = tswap32(ci->tstamp); 955 965 break; 956 966 default: 957 - gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type); 967 + qemu_log_mask( 968 + LOG_UNIMP, "Unknown host IFA type: %d\n", rtattr->rta_type); 958 969 break; 959 970 } 960 971 return 0; ··· 996 1007 #endif 997 1008 break; 998 1009 default: 999 - gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type); 1010 + qemu_log_mask( 1011 + LOG_UNIMP, "Unknown host RTA type: %d\n", rtattr->rta_type); 1000 1012 break; 1001 1013 } 1002 1014 return 0; ··· 1111 1123 { 1112 1124 switch (rtattr->rta_type) { 1113 1125 default: 1114 - gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type); 1126 + qemu_log_mask(LOG_UNIMP, "Unknown target QEMU_IFLA type: %d\n", 1127 + rtattr->rta_type); 1115 1128 break; 1116 1129 } 1117 1130 return 0; ··· 1125 1138 case IFA_ADDRESS: 1126 1139 break; 1127 1140 default: 1128 - gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type); 1141 + qemu_log_mask(LOG_UNIMP, "Unknown target IFA type: %d\n", 1142 + rtattr->rta_type); 1129 1143 break; 1130 1144 } 1131 1145 return 0; ··· 1147 1161 *u32 = tswap32(*u32); 1148 1162 break; 1149 1163 default: 1150 - gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type); 1164 + qemu_log_mask(LOG_UNIMP, "Unknown target RTA type: %d\n", 1165 + rtattr->rta_type); 1151 1166 break; 1152 1167 } 1153 1168 return 0; ··· 1232 1247 { 1233 1248 switch (nlh->nlmsg_type) { 1234 1249 default: 1235 - gemu_log("Unknown host audit message type %d\n", 1236 - nlh->nlmsg_type); 1250 + qemu_log_mask(LOG_UNIMP, "Unknown host audit message type %d\n", 1251 + nlh->nlmsg_type); 1237 1252 return -TARGET_EINVAL; 1238 1253 } 1239 1254 return 0; ··· 1253 1268 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2: 1254 1269 break; 1255 1270 default: 1256 - gemu_log("Unknown target audit message type %d\n", 1257 - nlh->nlmsg_type); 1271 + qemu_log_mask(LOG_UNIMP, "Unknown target audit message type %d\n", 1272 + nlh->nlmsg_type); 1258 1273 return -TARGET_EINVAL; 1259 1274 } 1260 1275

+21

linux-user/ioctls.h

··· 461 461 IOCTL(SOUND_MIXER_WRITE_LOUD, IOC_W, MK_PTR(TYPE_INT)) 462 462 IOCTL(SOUND_MIXER_WRITE_RECSRC, IOC_W, MK_PTR(TYPE_INT)) 463 463 464 + IOCTL(SNDRV_TIMER_IOCTL_PVERSION, IOC_R, MK_PTR(TYPE_INT)) 465 + IOCTL(SNDRV_TIMER_IOCTL_NEXT_DEVICE, IOC_RW, 466 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_id))) 467 + IOCTL(SNDRV_TIMER_IOCTL_GINFO, IOC_RW, 468 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_ginfo))) 469 + IOCTL(SNDRV_TIMER_IOCTL_GPARAMS, IOC_W, 470 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_gparams))) 471 + IOCTL(SNDRV_TIMER_IOCTL_GSTATUS, IOC_RW, 472 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_gstatus))) 473 + IOCTL(SNDRV_TIMER_IOCTL_SELECT, IOC_W, 474 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_select))) 475 + IOCTL(SNDRV_TIMER_IOCTL_INFO, IOC_R, MK_PTR(MK_STRUCT(STRUCT_snd_timer_info))) 476 + IOCTL(SNDRV_TIMER_IOCTL_PARAMS, IOC_W, 477 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_params))) 478 + IOCTL(SNDRV_TIMER_IOCTL_STATUS, IOC_R, 479 + MK_PTR(MK_STRUCT(STRUCT_snd_timer_status))) 480 + IOCTL(SNDRV_TIMER_IOCTL_START, 0, TYPE_NULL) 481 + IOCTL(SNDRV_TIMER_IOCTL_STOP, 0, TYPE_NULL) 482 + IOCTL(SNDRV_TIMER_IOCTL_CONTINUE, 0, TYPE_NULL) 483 + IOCTL(SNDRV_TIMER_IOCTL_PAUSE, 0, TYPE_NULL) 484 + 464 485 IOCTL(HDIO_GETGEO, IOC_R, MK_PTR(MK_STRUCT(STRUCT_hd_geometry))) 465 486 IOCTL(HDIO_GET_UNMASKINTR, IOC_R, MK_PTR(TYPE_INT)) 466 487 IOCTL(HDIO_GET_MULTCOUNT, IOC_R, MK_PTR(TYPE_INT))

+23 -16

linux-user/main.c

··· 61 61 int have_guest_base; 62 62 63 63 /* 64 + * Used to implement backwards-compatibility for the `-strace`, and 65 + * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by 66 + * -strace, or vice versa. 67 + */ 68 + static bool enable_strace; 69 + 70 + /* 71 + * The last log mask given by the user in an environment variable or argument. 72 + * Used to support command line arguments overriding environment variables. 73 + */ 74 + static int last_log_mask; 75 + 76 + /* 64 77 * When running 32-on-64 we should make sure we can fit all of the possible 65 78 * guest address space into a contiguous chunk of virtual host memory. 66 79 * ··· 99 112 by remapping the process stack directly at the right place */ 100 113 unsigned long guest_stack_size = 8 * 1024 * 1024UL; 101 114 102 - void gemu_log(const char *fmt, ...) 103 - { 104 - va_list ap; 105 - 106 - va_start(ap, fmt); 107 - vfprintf(stderr, fmt, ap); 108 - va_end(ap); 109 - } 110 - 111 115 #if defined(TARGET_I386) 112 116 int cpu_get_pic_interrupt(CPUX86State *env) 113 117 { ··· 223 227 224 228 static void handle_arg_log(const char *arg) 225 229 { 226 - int mask; 227 - 228 - mask = qemu_str_to_log_mask(arg); 229 - if (!mask) { 230 + last_log_mask = qemu_str_to_log_mask(arg); 231 + if (!last_log_mask) { 230 232 qemu_print_log_usage(stdout); 231 233 exit(EXIT_FAILURE); 232 234 } 233 - qemu_log_needs_buffers(); 234 - qemu_set_log(mask); 235 235 } 236 236 237 237 static void handle_arg_dfilter(const char *arg) ··· 375 375 376 376 static void handle_arg_strace(const char *arg) 377 377 { 378 - do_strace = 1; 378 + enable_strace = true; 379 379 } 380 380 381 381 static void handle_arg_version(const char *arg) ··· 629 629 int i; 630 630 int ret; 631 631 int execfd; 632 + int log_mask; 632 633 unsigned long max_reserved_va; 633 634 634 635 error_init(argv[0]); ··· 660 661 qemu_plugin_add_opts(); 661 662 662 663 optind = parse_args(argc, argv); 664 + 665 + log_mask = last_log_mask | (enable_strace ? LOG_STRACE : 0); 666 + if (log_mask) { 667 + qemu_log_needs_buffers(); 668 + qemu_set_log(log_mask); 669 + } 663 670 664 671 if (!trace_init_backends()) { 665 672 exit(1);

-2

linux-user/qemu.h

··· 211 211 abi_long arg2, abi_long arg3, abi_long arg4, 212 212 abi_long arg5, abi_long arg6, abi_long arg7, 213 213 abi_long arg8); 214 - void gemu_log(const char *fmt, ...) GCC_FMT_ATTR(1, 2); 215 214 extern __thread CPUState *thread_cpu; 216 215 void cpu_loop(CPUArchState *env); 217 216 const char *target_strerror(int err); ··· 386 385 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} --- 387 386 */ 388 387 void print_taken_signal(int target_signum, const target_siginfo_t *tinfo); 389 - extern int do_strace; 390 388 391 389 /* signal.c */ 392 390 void process_pending_signals(CPUArchState *cpu_env);

+1 -1

linux-user/signal.c

··· 934 934 handler = sa->_sa_handler; 935 935 } 936 936 937 - if (do_strace) { 937 + if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 938 938 print_taken_signal(sig, &k->info); 939 939 } 940 940

+243 -236

linux-user/strace.c

··· 12 12 #include <sched.h> 13 13 #include "qemu.h" 14 14 15 - int do_strace=0; 16 - 17 15 struct syscallname { 18 16 int nr; 19 17 const char *name; ··· 80 78 { 81 79 #define output_cmd(val) \ 82 80 if( cmd == val ) { \ 83 - gemu_log(#val); \ 81 + qemu_log(#val); \ 84 82 return; \ 85 83 } 86 84 ··· 120 118 output_cmd( IPC_RMID ); 121 119 122 120 /* Some value we don't recognize */ 123 - gemu_log("%d",cmd); 121 + qemu_log("%d", cmd); 124 122 } 125 123 126 124 static void ··· 151 149 print_raw_param("%ld", arg, last); 152 150 return; 153 151 } 154 - gemu_log("%s%s", signal_name, get_comma(last)); 152 + qemu_log("%s%s", signal_name, get_comma(last)); 155 153 } 156 154 157 155 static void print_si_code(int arg) ··· 184 182 codename = "SI_TKILL"; 185 183 break; 186 184 default: 187 - gemu_log("%d", arg); 185 + qemu_log("%d", arg); 188 186 return; 189 187 } 190 - gemu_log("%s", codename); 188 + qemu_log("%s", codename); 191 189 } 192 190 193 191 static void get_target_siginfo(target_siginfo_t *tinfo, ··· 288 286 int si_type = extract32(tinfo->si_code, 16, 16); 289 287 int si_code = sextract32(tinfo->si_code, 0, 16); 290 288 291 - gemu_log("{si_signo="); 289 + qemu_log("{si_signo="); 292 290 print_signal(tinfo->si_signo, 1); 293 - gemu_log(", si_code="); 291 + qemu_log(", si_code="); 294 292 print_si_code(si_code); 295 293 296 294 switch (si_type) { 297 295 case QEMU_SI_KILL: 298 - gemu_log(", si_pid=%u, si_uid=%u", 296 + qemu_log(", si_pid=%u, si_uid=%u", 299 297 (unsigned int)tinfo->_sifields._kill._pid, 300 298 (unsigned int)tinfo->_sifields._kill._uid); 301 299 break; 302 300 case QEMU_SI_TIMER: 303 - gemu_log(", si_timer1=%u, si_timer2=%u", 301 + qemu_log(", si_timer1=%u, si_timer2=%u", 304 302 tinfo->_sifields._timer._timer1, 305 303 tinfo->_sifields._timer._timer2); 306 304 break; 307 305 case QEMU_SI_POLL: 308 - gemu_log(", si_band=%d, si_fd=%d", 306 + qemu_log(", si_band=%d, si_fd=%d", 309 307 tinfo->_sifields._sigpoll._band, 310 308 tinfo->_sifields._sigpoll._fd); 311 309 break; 312 310 case QEMU_SI_FAULT: 313 - gemu_log(", si_addr="); 311 + qemu_log(", si_addr="); 314 312 print_pointer(tinfo->_sifields._sigfault._addr, 1); 315 313 break; 316 314 case QEMU_SI_CHLD: 317 - gemu_log(", si_pid=%u, si_uid=%u, si_status=%d" 315 + qemu_log(", si_pid=%u, si_uid=%u, si_status=%d" 318 316 ", si_utime=" TARGET_ABI_FMT_ld 319 317 ", si_stime=" TARGET_ABI_FMT_ld, 320 318 (unsigned int)(tinfo->_sifields._sigchld._pid), ··· 324 322 tinfo->_sifields._sigchld._stime); 325 323 break; 326 324 case QEMU_SI_RT: 327 - gemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld, 325 + qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld, 328 326 (unsigned int)tinfo->_sifields._rt._pid, 329 327 (unsigned int)tinfo->_sifields._rt._uid, 330 328 tinfo->_sifields._rt._sigval.sival_ptr); ··· 332 330 default: 333 331 g_assert_not_reached(); 334 332 } 335 - gemu_log("}"); 333 + qemu_log("}"); 336 334 } 337 335 338 336 static void ··· 349 347 case AF_UNIX: { 350 348 struct target_sockaddr_un *un = (struct target_sockaddr_un *)sa; 351 349 int i; 352 - gemu_log("{sun_family=AF_UNIX,sun_path=\""); 350 + qemu_log("{sun_family=AF_UNIX,sun_path=\""); 353 351 for (i = 0; i < addrlen - 354 352 offsetof(struct target_sockaddr_un, sun_path) && 355 353 un->sun_path[i]; i++) { 356 - gemu_log("%c", un->sun_path[i]); 354 + qemu_log("%c", un->sun_path[i]); 357 355 } 358 - gemu_log("\"}"); 356 + qemu_log("\"}"); 359 357 break; 360 358 } 361 359 case AF_INET: { 362 360 struct target_sockaddr_in *in = (struct target_sockaddr_in *)sa; 363 361 uint8_t *c = (uint8_t *)&in->sin_addr.s_addr; 364 - gemu_log("{sin_family=AF_INET,sin_port=htons(%d),", 362 + qemu_log("{sin_family=AF_INET,sin_port=htons(%d),", 365 363 ntohs(in->sin_port)); 366 - gemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")", 364 + qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")", 367 365 c[0], c[1], c[2], c[3]); 368 - gemu_log("}"); 366 + qemu_log("}"); 369 367 break; 370 368 } 371 369 case AF_PACKET: { 372 370 struct target_sockaddr_ll *ll = (struct target_sockaddr_ll *)sa; 373 371 uint8_t *c = (uint8_t *)&ll->sll_addr; 374 - gemu_log("{sll_family=AF_PACKET," 372 + qemu_log("{sll_family=AF_PACKET," 375 373 "sll_protocol=htons(0x%04x),if%d,pkttype=", 376 374 ntohs(ll->sll_protocol), ll->sll_ifindex); 377 375 switch (ll->sll_pkttype) { 378 376 case PACKET_HOST: 379 - gemu_log("PACKET_HOST"); 377 + qemu_log("PACKET_HOST"); 380 378 break; 381 379 case PACKET_BROADCAST: 382 - gemu_log("PACKET_BROADCAST"); 380 + qemu_log("PACKET_BROADCAST"); 383 381 break; 384 382 case PACKET_MULTICAST: 385 - gemu_log("PACKET_MULTICAST"); 383 + qemu_log("PACKET_MULTICAST"); 386 384 break; 387 385 case PACKET_OTHERHOST: 388 - gemu_log("PACKET_OTHERHOST"); 386 + qemu_log("PACKET_OTHERHOST"); 389 387 break; 390 388 case PACKET_OUTGOING: 391 - gemu_log("PACKET_OUTGOING"); 389 + qemu_log("PACKET_OUTGOING"); 392 390 break; 393 391 default: 394 - gemu_log("%d", ll->sll_pkttype); 392 + qemu_log("%d", ll->sll_pkttype); 395 393 break; 396 394 } 397 - gemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", 395 + qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", 398 396 c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]); 399 - gemu_log("}"); 397 + qemu_log("}"); 400 398 break; 401 399 } 402 400 case AF_NETLINK: { 403 401 struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa; 404 - gemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}", 402 + qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}", 405 403 tswap32(nl->nl_pid), tswap32(nl->nl_groups)); 406 404 break; 407 405 } 408 406 default: 409 - gemu_log("{sa_family=%d, sa_data={", sa->sa_family); 407 + qemu_log("{sa_family=%d, sa_data={", sa->sa_family); 410 408 for (i = 0; i < 13; i++) { 411 - gemu_log("%02x, ", sa->sa_data[i]); 409 + qemu_log("%02x, ", sa->sa_data[i]); 412 410 } 413 - gemu_log("%02x}", sa->sa_data[i]); 414 - gemu_log("}"); 411 + qemu_log("%02x}", sa->sa_data[i]); 412 + qemu_log("}"); 415 413 break; 416 414 } 417 415 unlock_user(sa, addr, 0); 418 416 } else { 419 417 print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0); 420 418 } 421 - gemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last)); 419 + qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last)); 422 420 } 423 421 424 422 static void ··· 426 424 { 427 425 switch (domain) { 428 426 case PF_UNIX: 429 - gemu_log("PF_UNIX"); 427 + qemu_log("PF_UNIX"); 430 428 break; 431 429 case PF_INET: 432 - gemu_log("PF_INET"); 430 + qemu_log("PF_INET"); 433 431 break; 434 432 case PF_NETLINK: 435 - gemu_log("PF_NETLINK"); 433 + qemu_log("PF_NETLINK"); 436 434 break; 437 435 case PF_PACKET: 438 - gemu_log("PF_PACKET"); 436 + qemu_log("PF_PACKET"); 439 437 break; 440 438 default: 441 - gemu_log("%d", domain); 439 + qemu_log("%d", domain); 442 440 break; 443 441 } 444 442 } ··· 448 446 { 449 447 switch (type) { 450 448 case TARGET_SOCK_DGRAM: 451 - gemu_log("SOCK_DGRAM"); 449 + qemu_log("SOCK_DGRAM"); 452 450 break; 453 451 case TARGET_SOCK_STREAM: 454 - gemu_log("SOCK_STREAM"); 452 + qemu_log("SOCK_STREAM"); 455 453 break; 456 454 case TARGET_SOCK_RAW: 457 - gemu_log("SOCK_RAW"); 455 + qemu_log("SOCK_RAW"); 458 456 break; 459 457 case TARGET_SOCK_RDM: 460 - gemu_log("SOCK_RDM"); 458 + qemu_log("SOCK_RDM"); 461 459 break; 462 460 case TARGET_SOCK_SEQPACKET: 463 - gemu_log("SOCK_SEQPACKET"); 461 + qemu_log("SOCK_SEQPACKET"); 464 462 break; 465 463 case TARGET_SOCK_PACKET: 466 - gemu_log("SOCK_PACKET"); 464 + qemu_log("SOCK_PACKET"); 467 465 break; 468 466 } 469 467 } ··· 475 473 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 476 474 switch (protocol) { 477 475 case 0x0003: 478 - gemu_log("ETH_P_ALL"); 476 + qemu_log("ETH_P_ALL"); 479 477 break; 480 478 default: 481 - gemu_log("%d", protocol); 479 + qemu_log("%d", protocol); 482 480 } 483 481 return; 484 482 } ··· 486 484 if (domain == PF_NETLINK) { 487 485 switch (protocol) { 488 486 case NETLINK_ROUTE: 489 - gemu_log("NETLINK_ROUTE"); 487 + qemu_log("NETLINK_ROUTE"); 490 488 break; 491 489 case NETLINK_AUDIT: 492 - gemu_log("NETLINK_AUDIT"); 490 + qemu_log("NETLINK_AUDIT"); 493 491 break; 494 492 case NETLINK_NETFILTER: 495 - gemu_log("NETLINK_NETFILTER"); 493 + qemu_log("NETLINK_NETFILTER"); 496 494 break; 497 495 case NETLINK_KOBJECT_UEVENT: 498 - gemu_log("NETLINK_KOBJECT_UEVENT"); 496 + qemu_log("NETLINK_KOBJECT_UEVENT"); 499 497 break; 500 498 case NETLINK_RDMA: 501 - gemu_log("NETLINK_RDMA"); 499 + qemu_log("NETLINK_RDMA"); 502 500 break; 503 501 case NETLINK_CRYPTO: 504 - gemu_log("NETLINK_CRYPTO"); 502 + qemu_log("NETLINK_CRYPTO"); 505 503 break; 506 504 default: 507 - gemu_log("%d", protocol); 505 + qemu_log("%d", protocol); 508 506 break; 509 507 } 510 508 return; ··· 512 510 513 511 switch (protocol) { 514 512 case IPPROTO_IP: 515 - gemu_log("IPPROTO_IP"); 513 + qemu_log("IPPROTO_IP"); 516 514 break; 517 515 case IPPROTO_TCP: 518 - gemu_log("IPPROTO_TCP"); 516 + qemu_log("IPPROTO_TCP"); 519 517 break; 520 518 case IPPROTO_UDP: 521 - gemu_log("IPPROTO_UDP"); 519 + qemu_log("IPPROTO_UDP"); 522 520 break; 523 521 case IPPROTO_RAW: 524 - gemu_log("IPPROTO_RAW"); 522 + qemu_log("IPPROTO_RAW"); 525 523 break; 526 524 default: 527 - gemu_log("%d", protocol); 525 + qemu_log("%d", protocol); 528 526 break; 529 527 } 530 528 } ··· 536 534 { 537 535 int i; 538 536 539 - gemu_log("["); 537 + qemu_log("["); 540 538 if( target_fds_addr ) { 541 539 abi_long *target_fds; 542 540 ··· 550 548 551 549 for (i=n; i>=0; i--) { 552 550 if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1) 553 - gemu_log("%d,", i ); 551 + qemu_log("%d,", i); 554 552 } 555 553 unlock_user(target_fds, target_fds_addr, 0); 556 554 } 557 - gemu_log("]"); 555 + qemu_log("]"); 558 556 } 559 557 #endif 560 558 ··· 578 576 { 579 577 switch (clockid) { 580 578 case TARGET_CLOCK_REALTIME: 581 - gemu_log("CLOCK_REALTIME"); 579 + qemu_log("CLOCK_REALTIME"); 582 580 break; 583 581 case TARGET_CLOCK_MONOTONIC: 584 - gemu_log("CLOCK_MONOTONIC"); 582 + qemu_log("CLOCK_MONOTONIC"); 585 583 break; 586 584 case TARGET_CLOCK_PROCESS_CPUTIME_ID: 587 - gemu_log("CLOCK_PROCESS_CPUTIME_ID"); 585 + qemu_log("CLOCK_PROCESS_CPUTIME_ID"); 588 586 break; 589 587 case TARGET_CLOCK_THREAD_CPUTIME_ID: 590 - gemu_log("CLOCK_THREAD_CPUTIME_ID"); 588 + qemu_log("CLOCK_THREAD_CPUTIME_ID"); 591 589 break; 592 590 case TARGET_CLOCK_MONOTONIC_RAW: 593 - gemu_log("CLOCK_MONOTONIC_RAW"); 591 + qemu_log("CLOCK_MONOTONIC_RAW"); 594 592 break; 595 593 case TARGET_CLOCK_REALTIME_COARSE: 596 - gemu_log("CLOCK_REALTIME_COARSE"); 594 + qemu_log("CLOCK_REALTIME_COARSE"); 597 595 break; 598 596 case TARGET_CLOCK_MONOTONIC_COARSE: 599 - gemu_log("CLOCK_MONOTONIC_COARSE"); 597 + qemu_log("CLOCK_MONOTONIC_COARSE"); 600 598 break; 601 599 case TARGET_CLOCK_BOOTTIME: 602 - gemu_log("CLOCK_BOOTTIME"); 600 + qemu_log("CLOCK_BOOTTIME"); 603 601 break; 604 602 case TARGET_CLOCK_REALTIME_ALARM: 605 - gemu_log("CLOCK_REALTIME_ALARM"); 603 + qemu_log("CLOCK_REALTIME_ALARM"); 606 604 break; 607 605 case TARGET_CLOCK_BOOTTIME_ALARM: 608 - gemu_log("CLOCK_BOOTTIME_ALARM"); 606 + qemu_log("CLOCK_BOOTTIME_ALARM"); 609 607 break; 610 608 case TARGET_CLOCK_SGI_CYCLE: 611 - gemu_log("CLOCK_SGI_CYCLE"); 609 + qemu_log("CLOCK_SGI_CYCLE"); 612 610 break; 613 611 case TARGET_CLOCK_TAI: 614 - gemu_log("CLOCK_TAI"); 612 + qemu_log("CLOCK_TAI"); 615 613 break; 616 614 default: 617 - gemu_log("%d", clockid); 615 + qemu_log("%d", clockid); 618 616 break; 619 617 } 620 - gemu_log("%s", get_comma(last)); 618 + qemu_log("%s", get_comma(last)); 621 619 } 622 620 #endif 623 621 ··· 638 636 abi_long arg1, abi_long arg2, abi_long arg3, 639 637 abi_long arg4, abi_long arg5, abi_long arg6) 640 638 { 641 - gemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1); 639 + qemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1); 642 640 print_fdset(arg1, arg2); 643 - gemu_log(","); 641 + qemu_log(","); 644 642 print_fdset(arg1, arg3); 645 - gemu_log(","); 643 + qemu_log(","); 646 644 print_fdset(arg1, arg4); 647 - gemu_log(","); 645 + qemu_log(","); 648 646 print_timeval(arg5, 1); 649 - gemu_log(")"); 647 + qemu_log(")"); 650 648 651 649 /* save for use in the return output function below */ 652 650 newselect_arg1=arg1; ··· 663 661 abi_long arg1, abi_long arg2, abi_long arg3, 664 662 abi_long arg4, abi_long arg5, abi_long arg6) 665 663 { 666 - gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2); 664 + qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", 665 + name->name, arg1, arg2); 667 666 print_ipc_cmd(arg3); 668 - gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 667 + qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 669 668 } 670 669 #endif 671 670 ··· 679 678 680 679 if (!(s = lock_user_string(arg1))) 681 680 return; 682 - gemu_log("%s(\"%s\",{", name->name, s); 681 + qemu_log("%s(\"%s\",{", name->name, s); 683 682 unlock_user(s, arg1, 0); 684 683 685 684 for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) { ··· 693 692 if (!arg_addr) 694 693 break; 695 694 if ((s = lock_user_string(arg_addr))) { 696 - gemu_log("\"%s\",", s); 695 + qemu_log("\"%s\",", s); 697 696 unlock_user(s, arg_addr, 0); 698 697 } 699 698 } 700 699 701 - gemu_log("NULL})"); 700 + qemu_log("NULL})"); 702 701 } 703 702 704 703 #ifdef TARGET_NR_ipc ··· 709 708 { 710 709 switch(arg1) { 711 710 case IPCOP_semctl: 712 - gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2); 711 + qemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", 712 + arg1, arg2); 713 713 print_ipc_cmd(arg3); 714 - gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 714 + qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 715 715 break; 716 716 default: 717 - gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")", 717 + qemu_log(("%s(" 718 + TARGET_ABI_FMT_ld "," 719 + TARGET_ABI_FMT_ld "," 720 + TARGET_ABI_FMT_ld "," 721 + TARGET_ABI_FMT_ld 722 + ")"), 718 723 name->name, arg1, arg2, arg3, arg4); 719 724 } 720 725 } ··· 733 738 errstr = target_strerror(-ret); 734 739 } 735 740 if (errstr) { 736 - gemu_log(" = -1 errno=%d (%s)\n", (int)-ret, errstr); 741 + qemu_log(" = -1 errno=%d (%s)\n", (int)-ret, errstr); 737 742 } else { 738 - gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret); 743 + qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret); 739 744 } 740 745 } 741 746 ··· 743 748 static void 744 749 print_syscall_ret_raw(struct syscallname *name, abi_long ret) 745 750 { 746 - gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret); 751 + qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret); 747 752 } 748 753 #endif 749 754 ··· 751 756 static void 752 757 print_syscall_ret_newselect(const struct syscallname *name, abi_long ret) 753 758 { 754 - gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret); 759 + qemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret); 755 760 print_fdset(newselect_arg1,newselect_arg2); 756 - gemu_log(","); 761 + qemu_log(","); 757 762 print_fdset(newselect_arg1,newselect_arg3); 758 - gemu_log(","); 763 + qemu_log(","); 759 764 print_fdset(newselect_arg1,newselect_arg4); 760 - gemu_log(","); 765 + qemu_log(","); 761 766 print_timeval(newselect_arg5, 1); 762 - gemu_log(")\n"); 767 + qemu_log(")\n"); 763 768 } 764 769 #endif 765 770 ··· 775 780 { 776 781 const char *errstr = NULL; 777 782 778 - gemu_log(" = "); 783 + qemu_log(" = "); 779 784 if (ret < 0) { 780 - gemu_log("-1 errno=%d", errno); 785 + qemu_log("-1 errno=%d", errno); 781 786 errstr = target_strerror(-ret); 782 787 if (errstr) { 783 - gemu_log(" (%s)", errstr); 788 + qemu_log(" (%s)", errstr); 784 789 } 785 790 } else { 786 - gemu_log(TARGET_ABI_FMT_ld, ret); 791 + qemu_log(TARGET_ABI_FMT_ld, ret); 787 792 switch (ret) { 788 793 case TARGET_TIME_OK: 789 - gemu_log(" TIME_OK (clock synchronized, no leap second)"); 794 + qemu_log(" TIME_OK (clock synchronized, no leap second)"); 790 795 break; 791 796 case TARGET_TIME_INS: 792 - gemu_log(" TIME_INS (insert leap second)"); 797 + qemu_log(" TIME_INS (insert leap second)"); 793 798 break; 794 799 case TARGET_TIME_DEL: 795 - gemu_log(" TIME_DEL (delete leap second)"); 800 + qemu_log(" TIME_DEL (delete leap second)"); 796 801 break; 797 802 case TARGET_TIME_OOP: 798 - gemu_log(" TIME_OOP (leap second in progress)"); 803 + qemu_log(" TIME_OOP (leap second in progress)"); 799 804 break; 800 805 case TARGET_TIME_WAIT: 801 - gemu_log(" TIME_WAIT (leap second has occurred)"); 806 + qemu_log(" TIME_WAIT (leap second has occurred)"); 802 807 break; 803 808 case TARGET_TIME_ERROR: 804 - gemu_log(" TIME_ERROR (clock not synchronized)"); 809 + qemu_log(" TIME_ERROR (clock not synchronized)"); 805 810 break; 806 811 } 807 812 } 808 813 809 - gemu_log("\n"); 814 + qemu_log("\n"); 810 815 } 811 816 812 817 UNUSED static struct flags access_flags[] = { ··· 1104 1109 int n; 1105 1110 1106 1111 if ((flags == 0) && (f->f_value == 0)) { 1107 - gemu_log("%s%s", f->f_string, get_comma(last)); 1112 + qemu_log("%s%s", f->f_string, get_comma(last)); 1108 1113 return; 1109 1114 } 1110 1115 for (n = 0; f->f_string != NULL; f++) { 1111 1116 if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) { 1112 - gemu_log("%s%s", sep, f->f_string); 1117 + qemu_log("%s%s", sep, f->f_string); 1113 1118 flags &= ~f->f_value; 1114 1119 sep = "|"; 1115 1120 n++; ··· 1119 1124 if (n > 0) { 1120 1125 /* print rest of the flags as numeric */ 1121 1126 if (flags != 0) { 1122 - gemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last)); 1127 + qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last)); 1123 1128 } else { 1124 - gemu_log("%s", get_comma(last)); 1129 + qemu_log("%s", get_comma(last)); 1125 1130 } 1126 1131 } else { 1127 1132 /* no string version of flags found, print them in hex then */ 1128 - gemu_log("%#x%s", (unsigned int)flags, get_comma(last)); 1133 + qemu_log("%#x%s", (unsigned int)flags, get_comma(last)); 1129 1134 } 1130 1135 } 1131 1136 ··· 1134 1139 { 1135 1140 #ifdef AT_FDCWD 1136 1141 if (dirfd == AT_FDCWD) { 1137 - gemu_log("AT_FDCWD%s", get_comma(last)); 1142 + qemu_log("AT_FDCWD%s", get_comma(last)); 1138 1143 return; 1139 1144 } 1140 1145 #endif 1141 - gemu_log("%d%s", (int)dirfd, get_comma(last)); 1146 + qemu_log("%d%s", (int)dirfd, get_comma(last)); 1142 1147 } 1143 1148 1144 1149 static void ··· 1149 1154 1150 1155 for (m = &mode_flags[0]; m->f_string != NULL; m++) { 1151 1156 if ((m->f_value & mode) == m->f_value) { 1152 - gemu_log("%s%s", m->f_string, sep); 1157 + qemu_log("%s%s", m->f_string, sep); 1153 1158 sep = "|"; 1154 1159 mode &= ~m->f_value; 1155 1160 break; ··· 1159 1164 mode &= ~S_IFMT; 1160 1165 /* print rest of the mode as octal */ 1161 1166 if (mode != 0) 1162 - gemu_log("%s%#o", sep, (unsigned int)mode); 1167 + qemu_log("%s%#o", sep, (unsigned int)mode); 1163 1168 1164 - gemu_log("%s", get_comma(last)); 1169 + qemu_log("%s", get_comma(last)); 1165 1170 } 1166 1171 1167 1172 static void ··· 1170 1175 print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1); 1171 1176 flags &= ~TARGET_O_ACCMODE; 1172 1177 if (flags == 0) { 1173 - gemu_log("%s", get_comma(last)); 1178 + qemu_log("%s", get_comma(last)); 1174 1179 return; 1175 1180 } 1176 - gemu_log("|"); 1181 + qemu_log("|"); 1177 1182 print_flags(open_flags, flags, last); 1178 1183 } 1179 1184 1180 1185 static void 1181 1186 print_syscall_prologue(const struct syscallname *sc) 1182 1187 { 1183 - gemu_log("%s(", sc->name); 1188 + qemu_log("%s(", sc->name); 1184 1189 } 1185 1190 1186 1191 /*ARGSUSED*/ ··· 1188 1193 print_syscall_epilogue(const struct syscallname *sc) 1189 1194 { 1190 1195 (void)sc; 1191 - gemu_log(")"); 1196 + qemu_log(")"); 1192 1197 } 1193 1198 1194 1199 static void ··· 1197 1202 char *s; 1198 1203 1199 1204 if ((s = lock_user_string(addr)) != NULL) { 1200 - gemu_log("\"%s\"%s", s, get_comma(last)); 1205 + qemu_log("\"%s\"%s", s, get_comma(last)); 1201 1206 unlock_user(s, addr, 0); 1202 1207 } else { 1203 1208 /* can't get string out of it, so print it as pointer */ ··· 1214 1219 1215 1220 s = lock_user(VERIFY_READ, addr, len, 1); 1216 1221 if (s) { 1217 - gemu_log("\""); 1222 + qemu_log("\""); 1218 1223 for (i = 0; i < MAX_PRINT_BUF && i < len; i++) { 1219 1224 if (isprint(s[i])) { 1220 - gemu_log("%c", s[i]); 1225 + qemu_log("%c", s[i]); 1221 1226 } else { 1222 - gemu_log("\\%o", s[i]); 1227 + qemu_log("\\%o", s[i]); 1223 1228 } 1224 1229 } 1225 - gemu_log("\""); 1230 + qemu_log("\""); 1226 1231 if (i != len) { 1227 - gemu_log("..."); 1232 + qemu_log("..."); 1228 1233 } 1229 1234 if (!last) { 1230 - gemu_log(","); 1235 + qemu_log(","); 1231 1236 } 1232 1237 unlock_user(s, addr, 0); 1233 1238 } else { ··· 1245 1250 char format[64]; 1246 1251 1247 1252 (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last)); 1248 - gemu_log(format, param); 1253 + qemu_log(format, param); 1249 1254 } 1250 1255 1251 1256 static void 1252 1257 print_pointer(abi_long p, int last) 1253 1258 { 1254 1259 if (p == 0) 1255 - gemu_log("NULL%s", get_comma(last)); 1260 + qemu_log("NULL%s", get_comma(last)); 1256 1261 else 1257 - gemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last)); 1262 + qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last)); 1258 1263 } 1259 1264 1260 1265 /* ··· 1265 1270 print_number(abi_long addr, int last) 1266 1271 { 1267 1272 if (addr == 0) { 1268 - gemu_log("NULL%s", get_comma(last)); 1273 + qemu_log("NULL%s", get_comma(last)); 1269 1274 } else { 1270 1275 int num; 1271 1276 1272 1277 get_user_s32(num, addr); 1273 - gemu_log("[%d]%s", num, get_comma(last)); 1278 + qemu_log("[%d]%s", num, get_comma(last)); 1274 1279 } 1275 1280 } 1276 1281 ··· 1285 1290 print_pointer(tv_addr, last); 1286 1291 return; 1287 1292 } 1288 - gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s", 1293 + qemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s", 1289 1294 tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last)); 1290 1295 unlock_user(tv, tv_addr, 0); 1291 1296 } else 1292 - gemu_log("NULL%s", get_comma(last)); 1297 + qemu_log("NULL%s", get_comma(last)); 1293 1298 } 1294 1299 1295 1300 static void ··· 1303 1308 print_pointer(tz_addr, last); 1304 1309 return; 1305 1310 } 1306 - gemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest), 1311 + qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest), 1307 1312 tswap32(tz->tz_dsttime), get_comma(last)); 1308 1313 unlock_user(tz, tz_addr, 0); 1309 1314 } else { 1310 - gemu_log("NULL%s", get_comma(last)); 1315 + qemu_log("NULL%s", get_comma(last)); 1311 1316 } 1312 1317 } 1313 1318 ··· 1515 1520 print_raw_param("%d", arg0, 0); 1516 1521 switch(arg1) { 1517 1522 case TARGET_F_DUPFD: 1518 - gemu_log("F_DUPFD,"); 1523 + qemu_log("F_DUPFD,"); 1519 1524 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 1520 1525 break; 1521 1526 case TARGET_F_GETFD: 1522 - gemu_log("F_GETFD"); 1527 + qemu_log("F_GETFD"); 1523 1528 break; 1524 1529 case TARGET_F_SETFD: 1525 - gemu_log("F_SETFD,"); 1530 + qemu_log("F_SETFD,"); 1526 1531 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 1527 1532 break; 1528 1533 case TARGET_F_GETFL: 1529 - gemu_log("F_GETFL"); 1534 + qemu_log("F_GETFL"); 1530 1535 break; 1531 1536 case TARGET_F_SETFL: 1532 - gemu_log("F_SETFL,"); 1537 + qemu_log("F_SETFL,"); 1533 1538 print_open_flags(arg2, 1); 1534 1539 break; 1535 1540 case TARGET_F_GETLK: 1536 - gemu_log("F_GETLK,"); 1541 + qemu_log("F_GETLK,"); 1537 1542 print_pointer(arg2, 1); 1538 1543 break; 1539 1544 case TARGET_F_SETLK: 1540 - gemu_log("F_SETLK,"); 1545 + qemu_log("F_SETLK,"); 1541 1546 print_pointer(arg2, 1); 1542 1547 break; 1543 1548 case TARGET_F_SETLKW: 1544 - gemu_log("F_SETLKW,"); 1549 + qemu_log("F_SETLKW,"); 1545 1550 print_pointer(arg2, 1); 1546 1551 break; 1547 1552 case TARGET_F_GETOWN: 1548 - gemu_log("F_GETOWN"); 1553 + qemu_log("F_GETOWN"); 1549 1554 break; 1550 1555 case TARGET_F_SETOWN: 1551 - gemu_log("F_SETOWN,"); 1556 + qemu_log("F_SETOWN,"); 1552 1557 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 1553 1558 break; 1554 1559 case TARGET_F_GETSIG: 1555 - gemu_log("F_GETSIG"); 1560 + qemu_log("F_GETSIG"); 1556 1561 break; 1557 1562 case TARGET_F_SETSIG: 1558 - gemu_log("F_SETSIG,"); 1563 + qemu_log("F_SETSIG,"); 1559 1564 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 1560 1565 break; 1561 1566 #if TARGET_ABI_BITS == 32 1562 1567 case TARGET_F_GETLK64: 1563 - gemu_log("F_GETLK64,"); 1568 + qemu_log("F_GETLK64,"); 1564 1569 print_pointer(arg2, 1); 1565 1570 break; 1566 1571 case TARGET_F_SETLK64: 1567 - gemu_log("F_SETLK64,"); 1572 + qemu_log("F_SETLK64,"); 1568 1573 print_pointer(arg2, 1); 1569 1574 break; 1570 1575 case TARGET_F_SETLKW64: 1571 - gemu_log("F_SETLKW64,"); 1576 + qemu_log("F_SETLKW64,"); 1572 1577 print_pointer(arg2, 1); 1573 1578 break; 1574 1579 #endif 1575 1580 case TARGET_F_SETLEASE: 1576 - gemu_log("F_SETLEASE,"); 1581 + qemu_log("F_SETLEASE,"); 1577 1582 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 1578 1583 break; 1579 1584 case TARGET_F_GETLEASE: 1580 - gemu_log("F_GETLEASE"); 1585 + qemu_log("F_GETLEASE"); 1581 1586 break; 1582 1587 case TARGET_F_SETPIPE_SZ: 1583 - gemu_log("F_SETPIPE_SZ,"); 1588 + qemu_log("F_SETPIPE_SZ,"); 1584 1589 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 1585 1590 break; 1586 1591 case TARGET_F_GETPIPE_SZ: 1587 - gemu_log("F_GETPIPE_SZ"); 1592 + qemu_log("F_GETPIPE_SZ"); 1588 1593 break; 1589 1594 case TARGET_F_DUPFD_CLOEXEC: 1590 - gemu_log("F_DUPFD_CLOEXEC,"); 1595 + qemu_log("F_DUPFD_CLOEXEC,"); 1591 1596 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 1592 1597 break; 1593 1598 case TARGET_F_NOTIFY: 1594 - gemu_log("F_NOTIFY,"); 1599 + qemu_log("F_NOTIFY,"); 1595 1600 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 1596 1601 break; 1597 1602 default: ··· 1679 1684 case SEEK_CUR: whence = "SEEK_CUR"; break; 1680 1685 case SEEK_END: whence = "SEEK_END"; break; 1681 1686 } 1682 - gemu_log("%s",whence); 1687 + qemu_log("%s", whence); 1683 1688 print_syscall_epilogue(name); 1684 1689 } 1685 1690 #endif ··· 1694 1699 1695 1700 print_syscall_prologue(name); 1696 1701 print_socket_domain(domain); 1697 - gemu_log(","); 1702 + qemu_log(","); 1698 1703 print_socket_type(type); 1699 - gemu_log(","); 1704 + qemu_log(","); 1700 1705 if (domain == AF_PACKET || 1701 1706 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 1702 1707 protocol = tswap16(protocol); ··· 1728 1733 get_user_ualx(domain, arg1, 0); 1729 1734 get_user_ualx(type, arg1, 1); 1730 1735 get_user_ualx(protocol, arg1, 2); 1731 - gemu_log("%s(", name); 1736 + qemu_log("%s(", name); 1732 1737 print_socket_domain(domain); 1733 - gemu_log(","); 1738 + qemu_log(","); 1734 1739 print_socket_type(type); 1735 - gemu_log(","); 1740 + qemu_log(","); 1736 1741 if (domain == AF_PACKET || 1737 1742 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 1738 1743 protocol = tswap16(protocol); 1739 1744 } 1740 1745 print_socket_protocol(domain, type, protocol); 1741 - gemu_log(")"); 1746 + qemu_log(")"); 1742 1747 } 1743 1748 1744 1749 static void do_print_sockaddr(const char *name, abi_long arg1) ··· 1749 1754 get_user_ualx(addr, arg1, 1); 1750 1755 get_user_ualx(addrlen, arg1, 2); 1751 1756 1752 - gemu_log("%s(", name); 1757 + qemu_log("%s(", name); 1753 1758 print_sockfd(sockfd, 0); 1754 1759 print_sockaddr(addr, addrlen, 0); 1755 - gemu_log(")"); 1760 + qemu_log(")"); 1756 1761 } 1757 1762 1758 1763 static void do_print_listen(const char *name, abi_long arg1) ··· 1762 1767 get_user_ualx(sockfd, arg1, 0); 1763 1768 get_user_ualx(backlog, arg1, 1); 1764 1769 1765 - gemu_log("%s(", name); 1770 + qemu_log("%s(", name); 1766 1771 print_sockfd(sockfd, 0); 1767 1772 print_raw_param(TARGET_ABI_FMT_ld, backlog, 1); 1768 - gemu_log(")"); 1773 + qemu_log(")"); 1769 1774 } 1770 1775 1771 1776 static void do_print_socketpair(const char *name, abi_long arg1) ··· 1777 1782 get_user_ualx(protocol, arg1, 2); 1778 1783 get_user_ualx(tab, arg1, 3); 1779 1784 1780 - gemu_log("%s(", name); 1785 + qemu_log("%s(", name); 1781 1786 print_socket_domain(domain); 1782 - gemu_log(","); 1787 + qemu_log(","); 1783 1788 print_socket_type(type); 1784 - gemu_log(","); 1789 + qemu_log(","); 1785 1790 print_socket_protocol(domain, type, protocol); 1786 - gemu_log(","); 1791 + qemu_log(","); 1787 1792 print_raw_param(TARGET_ABI_FMT_lx, tab, 1); 1788 - gemu_log(")"); 1793 + qemu_log(")"); 1789 1794 } 1790 1795 1791 1796 static void do_print_sendrecv(const char *name, abi_long arg1) ··· 1797 1802 get_user_ualx(len, arg1, 2); 1798 1803 get_user_ualx(flags, arg1, 3); 1799 1804 1800 - gemu_log("%s(", name); 1805 + qemu_log("%s(", name); 1801 1806 print_sockfd(sockfd, 0); 1802 1807 print_buf(msg, len, 0); 1803 1808 print_raw_param(TARGET_ABI_FMT_ld, len, 0); 1804 1809 print_flags(msg_flags, flags, 1); 1805 - gemu_log(")"); 1810 + qemu_log(")"); 1806 1811 } 1807 1812 1808 1813 static void do_print_msgaddr(const char *name, abi_long arg1) ··· 1816 1821 get_user_ualx(addr, arg1, 4); 1817 1822 get_user_ualx(addrlen, arg1, 5); 1818 1823 1819 - gemu_log("%s(", name); 1824 + qemu_log("%s(", name); 1820 1825 print_sockfd(sockfd, 0); 1821 1826 print_buf(msg, len, 0); 1822 1827 print_raw_param(TARGET_ABI_FMT_ld, len, 0); 1823 1828 print_flags(msg_flags, flags, 0); 1824 1829 print_sockaddr(addr, addrlen, 0); 1825 - gemu_log(")"); 1830 + qemu_log(")"); 1826 1831 } 1827 1832 1828 1833 static void do_print_shutdown(const char *name, abi_long arg1) ··· 1832 1837 get_user_ualx(sockfd, arg1, 0); 1833 1838 get_user_ualx(how, arg1, 1); 1834 1839 1835 - gemu_log("shutdown("); 1840 + qemu_log("shutdown("); 1836 1841 print_sockfd(sockfd, 0); 1837 1842 switch (how) { 1838 1843 case SHUT_RD: 1839 - gemu_log("SHUT_RD"); 1844 + qemu_log("SHUT_RD"); 1840 1845 break; 1841 1846 case SHUT_WR: 1842 - gemu_log("SHUT_WR"); 1847 + qemu_log("SHUT_WR"); 1843 1848 break; 1844 1849 case SHUT_RDWR: 1845 - gemu_log("SHUT_RDWR"); 1850 + qemu_log("SHUT_RDWR"); 1846 1851 break; 1847 1852 default: 1848 1853 print_raw_param(TARGET_ABI_FMT_ld, how, 1); 1849 1854 break; 1850 1855 } 1851 - gemu_log(")"); 1856 + qemu_log(")"); 1852 1857 } 1853 1858 1854 1859 static void do_print_msg(const char *name, abi_long arg1) ··· 1859 1864 get_user_ualx(msg, arg1, 1); 1860 1865 get_user_ualx(flags, arg1, 2); 1861 1866 1862 - gemu_log("%s(", name); 1867 + qemu_log("%s(", name); 1863 1868 print_sockfd(sockfd, 0); 1864 1869 print_pointer(msg, 0); 1865 1870 print_flags(msg_flags, flags, 1); 1866 - gemu_log(")"); 1871 + qemu_log(")"); 1867 1872 } 1868 1873 1869 1874 static void do_print_sockopt(const char *name, abi_long arg1) ··· 1876 1881 get_user_ualx(optval, arg1, 3); 1877 1882 get_user_ualx(optlen, arg1, 4); 1878 1883 1879 - gemu_log("%s(", name); 1884 + qemu_log("%s(", name); 1880 1885 print_sockfd(sockfd, 0); 1881 1886 switch (level) { 1882 1887 case SOL_TCP: 1883 - gemu_log("SOL_TCP,"); 1888 + qemu_log("SOL_TCP,"); 1884 1889 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 1885 1890 print_pointer(optval, 0); 1886 1891 break; 1887 1892 case SOL_IP: 1888 - gemu_log("SOL_IP,"); 1893 + qemu_log("SOL_IP,"); 1889 1894 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 1890 1895 print_pointer(optval, 0); 1891 1896 break; 1892 1897 case SOL_RAW: 1893 - gemu_log("SOL_RAW,"); 1898 + qemu_log("SOL_RAW,"); 1894 1899 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 1895 1900 print_pointer(optval, 0); 1896 1901 break; 1897 1902 case TARGET_SOL_SOCKET: 1898 - gemu_log("SOL_SOCKET,"); 1903 + qemu_log("SOL_SOCKET,"); 1899 1904 switch (optname) { 1900 1905 case TARGET_SO_DEBUG: 1901 - gemu_log("SO_DEBUG,"); 1906 + qemu_log("SO_DEBUG,"); 1902 1907 print_optint: 1903 1908 print_number(optval, 0); 1904 1909 break; 1905 1910 case TARGET_SO_REUSEADDR: 1906 - gemu_log("SO_REUSEADDR,"); 1911 + qemu_log("SO_REUSEADDR,"); 1907 1912 goto print_optint; 1908 1913 case TARGET_SO_REUSEPORT: 1909 - gemu_log("SO_REUSEPORT,"); 1914 + qemu_log("SO_REUSEPORT,"); 1910 1915 goto print_optint; 1911 1916 case TARGET_SO_TYPE: 1912 - gemu_log("SO_TYPE,"); 1917 + qemu_log("SO_TYPE,"); 1913 1918 goto print_optint; 1914 1919 case TARGET_SO_ERROR: 1915 - gemu_log("SO_ERROR,"); 1920 + qemu_log("SO_ERROR,"); 1916 1921 goto print_optint; 1917 1922 case TARGET_SO_DONTROUTE: 1918 - gemu_log("SO_DONTROUTE,"); 1923 + qemu_log("SO_DONTROUTE,"); 1919 1924 goto print_optint; 1920 1925 case TARGET_SO_BROADCAST: 1921 - gemu_log("SO_BROADCAST,"); 1926 + qemu_log("SO_BROADCAST,"); 1922 1927 goto print_optint; 1923 1928 case TARGET_SO_SNDBUF: 1924 - gemu_log("SO_SNDBUF,"); 1929 + qemu_log("SO_SNDBUF,"); 1925 1930 goto print_optint; 1926 1931 case TARGET_SO_RCVBUF: 1927 - gemu_log("SO_RCVBUF,"); 1932 + qemu_log("SO_RCVBUF,"); 1928 1933 goto print_optint; 1929 1934 case TARGET_SO_KEEPALIVE: 1930 - gemu_log("SO_KEEPALIVE,"); 1935 + qemu_log("SO_KEEPALIVE,"); 1931 1936 goto print_optint; 1932 1937 case TARGET_SO_OOBINLINE: 1933 - gemu_log("SO_OOBINLINE,"); 1938 + qemu_log("SO_OOBINLINE,"); 1934 1939 goto print_optint; 1935 1940 case TARGET_SO_NO_CHECK: 1936 - gemu_log("SO_NO_CHECK,"); 1941 + qemu_log("SO_NO_CHECK,"); 1937 1942 goto print_optint; 1938 1943 case TARGET_SO_PRIORITY: 1939 - gemu_log("SO_PRIORITY,"); 1944 + qemu_log("SO_PRIORITY,"); 1940 1945 goto print_optint; 1941 1946 case TARGET_SO_BSDCOMPAT: 1942 - gemu_log("SO_BSDCOMPAT,"); 1947 + qemu_log("SO_BSDCOMPAT,"); 1943 1948 goto print_optint; 1944 1949 case TARGET_SO_PASSCRED: 1945 - gemu_log("SO_PASSCRED,"); 1950 + qemu_log("SO_PASSCRED,"); 1946 1951 goto print_optint; 1947 1952 case TARGET_SO_TIMESTAMP: 1948 - gemu_log("SO_TIMESTAMP,"); 1953 + qemu_log("SO_TIMESTAMP,"); 1949 1954 goto print_optint; 1950 1955 case TARGET_SO_RCVLOWAT: 1951 - gemu_log("SO_RCVLOWAT,"); 1956 + qemu_log("SO_RCVLOWAT,"); 1952 1957 goto print_optint; 1953 1958 case TARGET_SO_RCVTIMEO: 1954 - gemu_log("SO_RCVTIMEO,"); 1959 + qemu_log("SO_RCVTIMEO,"); 1955 1960 print_timeval(optval, 0); 1956 1961 break; 1957 1962 case TARGET_SO_SNDTIMEO: 1958 - gemu_log("SO_SNDTIMEO,"); 1963 + qemu_log("SO_SNDTIMEO,"); 1959 1964 print_timeval(optval, 0); 1960 1965 break; 1961 1966 case TARGET_SO_ATTACH_FILTER: { 1962 1967 struct target_sock_fprog *fprog; 1963 1968 1964 - gemu_log("SO_ATTACH_FILTER,"); 1969 + qemu_log("SO_ATTACH_FILTER,"); 1965 1970 1966 1971 if (lock_user_struct(VERIFY_READ, fprog, optval, 0)) { 1967 1972 struct target_sock_filter *filter; 1968 - gemu_log("{"); 1973 + qemu_log("{"); 1969 1974 if (lock_user_struct(VERIFY_READ, filter, 1970 1975 tswapal(fprog->filter), 0)) { 1971 1976 int i; 1972 1977 for (i = 0; i < tswap16(fprog->len) - 1; i++) { 1973 - gemu_log("[%d]{0x%x,%d,%d,0x%x},", 1978 + qemu_log("[%d]{0x%x,%d,%d,0x%x},", 1974 1979 i, tswap16(filter[i].code), 1975 1980 filter[i].jt, filter[i].jf, 1976 1981 tswap32(filter[i].k)); 1977 1982 } 1978 - gemu_log("[%d]{0x%x,%d,%d,0x%x}", 1983 + qemu_log("[%d]{0x%x,%d,%d,0x%x}", 1979 1984 i, tswap16(filter[i].code), 1980 1985 filter[i].jt, filter[i].jf, 1981 1986 tswap32(filter[i].k)); 1982 1987 } else { 1983 - gemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter)); 1988 + qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter)); 1984 1989 } 1985 - gemu_log(",%d},", tswap16(fprog->len)); 1990 + qemu_log(",%d},", tswap16(fprog->len)); 1986 1991 unlock_user(fprog, optval, 0); 1987 1992 } else { 1988 1993 print_pointer(optval, 0); ··· 2002 2007 break; 2003 2008 } 2004 2009 print_raw_param(TARGET_ABI_FMT_ld, optlen, 1); 2005 - gemu_log(")"); 2010 + qemu_log(")"); 2006 2011 } 2007 2012 2008 2013 #define PRINT_SOCKOP(name, func) \ ··· 2164 2169 case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break; 2165 2170 case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break; 2166 2171 } 2167 - gemu_log("%s,",how); 2172 + qemu_log("%s,", how); 2168 2173 print_pointer(arg1, 0); 2169 2174 print_pointer(arg2, 1); 2170 2175 print_syscall_epilogue(name); ··· 2278 2283 return; 2279 2284 } 2280 2285 } 2281 - gemu_log("%s%s", type, get_comma(last)); 2286 + qemu_log("%s%s", type, get_comma(last)); 2282 2287 } 2283 2288 2284 2289 static void ··· 2683 2688 { 2684 2689 #define print_op(val) \ 2685 2690 if( cmd == val ) { \ 2686 - gemu_log(#val); \ 2691 + qemu_log(#val); \ 2687 2692 return; \ 2688 2693 } 2689 2694 2690 2695 int cmd = (int)tflag; 2691 2696 #ifdef FUTEX_PRIVATE_FLAG 2692 2697 if (cmd & FUTEX_PRIVATE_FLAG) { 2693 - gemu_log("FUTEX_PRIVATE_FLAG|"); 2698 + qemu_log("FUTEX_PRIVATE_FLAG|"); 2694 2699 cmd &= ~FUTEX_PRIVATE_FLAG; 2695 2700 } 2696 2701 #endif 2697 2702 #ifdef FUTEX_CLOCK_REALTIME 2698 2703 if (cmd & FUTEX_CLOCK_REALTIME) { 2699 - gemu_log("FUTEX_CLOCK_REALTIME|"); 2704 + qemu_log("FUTEX_CLOCK_REALTIME|"); 2700 2705 cmd &= ~FUTEX_CLOCK_REALTIME; 2701 2706 } 2702 2707 #endif ··· 2716 2721 print_op(FUTEX_WAKE_BITSET) 2717 2722 #endif 2718 2723 /* unknown values */ 2719 - gemu_log("%d",cmd); 2724 + qemu_log("%d", cmd); 2720 2725 } 2721 2726 2722 2727 static void ··· 2812 2817 int i; 2813 2818 const char *format="%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")"; 2814 2819 2815 - gemu_log("%d ", getpid() ); 2820 + qemu_log("%d ", getpid()); 2816 2821 2817 2822 for(i=0;i<nsyscalls;i++) 2818 2823 if( scnames[i].nr == num ) { 2819 2824 if( scnames[i].call != NULL ) { 2820 - scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6); 2825 + scnames[i].call( 2826 + &scnames[i], arg1, arg2, arg3, arg4, arg5, arg6); 2821 2827 } else { 2822 2828 /* XXX: this format system is broken because it uses 2823 2829 host types and host pointers for strings */ 2824 2830 if( scnames[i].format != NULL ) 2825 2831 format = scnames[i].format; 2826 - gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6); 2832 + qemu_log(format, 2833 + scnames[i].name, arg1, arg2, arg3, arg4, arg5, arg6); 2827 2834 } 2828 2835 return; 2829 2836 } 2830 - gemu_log("Unknown syscall %d\n", num); 2837 + qemu_log("Unknown syscall %d\n", num); 2831 2838 } 2832 2839 2833 2840 ··· 2840 2847 for(i=0;i<nsyscalls;i++) 2841 2848 if( scnames[i].nr == num ) { 2842 2849 if( scnames[i].result != NULL ) { 2843 - scnames[i].result(&scnames[i],ret); 2850 + scnames[i].result(&scnames[i], ret); 2844 2851 } else { 2845 2852 if (ret < 0) { 2846 2853 errstr = target_strerror(-ret); 2847 2854 } 2848 2855 if (errstr) { 2849 - gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", 2856 + qemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", 2850 2857 -ret, errstr); 2851 2858 } else { 2852 - gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret); 2859 + qemu_log(" = " TARGET_ABI_FMT_ld "\n", ret); 2853 2860 } 2854 2861 } 2855 2862 break; ··· 2861 2868 /* Print the strace output for a signal being taken: 2862 2869 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} --- 2863 2870 */ 2864 - gemu_log("--- "); 2871 + qemu_log("--- "); 2865 2872 print_signal(target_signum, 1); 2866 - gemu_log(" "); 2873 + qemu_log(" "); 2867 2874 print_siginfo(tinfo); 2868 - gemu_log(" ---\n"); 2875 + qemu_log(" ---\n"); 2869 2876 }

+26 -26

linux-user/strace.list

··· 26 26 { TARGET_NR_afs_syscall, "afs_syscall" , NULL, NULL, NULL }, 27 27 #endif 28 28 #ifdef TARGET_NR_alarm 29 - { TARGET_NR_alarm, "alarm" , NULL, NULL, NULL }, 29 + { TARGET_NR_alarm, "alarm" , "%s(%u)", NULL, NULL }, 30 30 #endif 31 31 #ifdef TARGET_NR_aplib 32 32 { TARGET_NR_aplib, "aplib" , NULL, NULL, NULL }, ··· 116 116 { TARGET_NR_dipc, "dipc" , NULL, NULL, NULL }, 117 117 #endif 118 118 #ifdef TARGET_NR_dup 119 - { TARGET_NR_dup, "dup" , NULL, NULL, NULL }, 119 + { TARGET_NR_dup, "dup" , "%s(%d)", NULL, NULL }, 120 120 #endif 121 121 #ifdef TARGET_NR_dup2 122 - { TARGET_NR_dup2, "dup2" , NULL, NULL, NULL }, 122 + { TARGET_NR_dup2, "dup2" , "%s(%d,%d)", NULL, NULL }, 123 123 #endif 124 124 #ifdef TARGET_NR_dup3 125 - { TARGET_NR_dup3, "dup3" , NULL, NULL, NULL }, 125 + { TARGET_NR_dup3, "dup3" , "%s(%d,%d,%d)", NULL, NULL }, 126 126 #endif 127 127 #ifdef TARGET_NR_epoll_create 128 - { TARGET_NR_epoll_create, "epoll_create" , NULL, NULL, NULL }, 128 + { TARGET_NR_epoll_create, "%s(%d)", NULL, NULL, NULL }, 129 129 #endif 130 130 #ifdef TARGET_NR_epoll_create1 131 - { TARGET_NR_epoll_create1, "epoll_create1" , NULL, NULL, NULL }, 131 + { TARGET_NR_epoll_create1, "%s(%d)", NULL, NULL, NULL }, 132 132 #endif 133 133 #ifdef TARGET_NR_epoll_ctl 134 134 { TARGET_NR_epoll_ctl, "epoll_ctl" , NULL, NULL, NULL }, ··· 146 146 { TARGET_NR_epoll_wait_old, "epoll_wait_old" , NULL, NULL, NULL }, 147 147 #endif 148 148 #ifdef TARGET_NR_eventfd 149 - { TARGET_NR_eventfd, "eventfd" , NULL, NULL, NULL }, 149 + { TARGET_NR_eventfd, "eventfd", "%s(%d)", NULL, NULL }, 150 150 #endif 151 151 #ifdef TARGET_NR_eventfd2 152 - { TARGET_NR_eventfd2, "eventfd2" , NULL, NULL, NULL }, 152 + { TARGET_NR_eventfd2, "eventfd2" , "%s(%d,%d)", NULL, NULL }, 153 153 #endif 154 154 #ifdef TARGET_NR_execv 155 155 { TARGET_NR_execv, "execv" , NULL, print_execv, NULL }, ··· 191 191 { TARGET_NR_fanotify_mark, "fanotify_mark" , NULL, NULL, NULL }, 192 192 #endif 193 193 #ifdef TARGET_NR_fchdir 194 - { TARGET_NR_fchdir, "fchdir" , NULL, NULL, NULL }, 194 + { TARGET_NR_fchdir, "fchdir" , "%s(%d)", NULL, NULL }, 195 195 #endif 196 196 #ifdef TARGET_NR_fchmod 197 197 { TARGET_NR_fchmod, "fchmod" , "%s(%d,%#o)", NULL, NULL }, ··· 287 287 { TARGET_NR_getdtablesize, "getdtablesize" , NULL, NULL, NULL }, 288 288 #endif 289 289 #ifdef TARGET_NR_getegid 290 - { TARGET_NR_getegid, "getegid" , NULL, NULL, NULL }, 290 + { TARGET_NR_getegid, "getegid" , "%s()", NULL, NULL }, 291 291 #endif 292 292 #ifdef TARGET_NR_getegid32 293 293 { TARGET_NR_getegid32, "getegid32" , NULL, NULL, NULL }, ··· 299 299 { TARGET_NR_geteuid32, "geteuid32" , NULL, NULL, NULL }, 300 300 #endif 301 301 #ifdef TARGET_NR_getgid 302 - { TARGET_NR_getgid, "getgid" , NULL, NULL, NULL }, 302 + { TARGET_NR_getgid, "getgid" , "%s()", NULL, NULL }, 303 303 #endif 304 304 #ifdef TARGET_NR_getgid32 305 305 { TARGET_NR_getgid32, "getgid32" , NULL, NULL, NULL }, ··· 329 329 { TARGET_NR_getpeername, "getpeername" , NULL, NULL, NULL }, 330 330 #endif 331 331 #ifdef TARGET_NR_getpgid 332 - { TARGET_NR_getpgid, "getpgid" , NULL, NULL, NULL }, 332 + { TARGET_NR_getpgid, "getpgid" , "%s(%u)", NULL, NULL }, 333 333 #endif 334 334 #ifdef TARGET_NR_getpgrp 335 - { TARGET_NR_getpgrp, "getpgrp" , NULL, NULL, NULL }, 335 + { TARGET_NR_getpgrp, "getpgrp" , "%s()", NULL, NULL }, 336 336 #endif 337 337 #ifdef TARGET_NR_getpid 338 338 { TARGET_NR_getpid, "getpid" , "%s()", NULL, NULL }, ··· 432 432 { TARGET_NR_io_cancel, "io_cancel" , NULL, NULL, NULL }, 433 433 #endif 434 434 #ifdef TARGET_NR_ioctl 435 - { TARGET_NR_ioctl, "ioctl" , NULL, NULL, NULL }, 435 + { TARGET_NR_ioctl, "ioctl" , "%s(%d,%#x,%#x)", NULL, NULL }, 436 436 #endif 437 437 #ifdef TARGET_NR_io_destroy 438 438 { TARGET_NR_io_destroy, "io_destroy" , NULL, NULL, NULL }, ··· 1257 1257 { TARGET_NR_setdomainname, "setdomainname" , NULL, NULL, NULL }, 1258 1258 #endif 1259 1259 #ifdef TARGET_NR_setfsgid 1260 - { TARGET_NR_setfsgid, "setfsgid" , NULL, NULL, NULL }, 1260 + { TARGET_NR_setfsgid, "setfsgid" , "%s(%u)", NULL, NULL }, 1261 1261 #endif 1262 1262 #ifdef TARGET_NR_setfsgid32 1263 - { TARGET_NR_setfsgid32, "setfsgid32" , NULL, NULL, NULL }, 1263 + { TARGET_NR_setfsgid32, "setfsgid32" , "%s(%u)" , NULL, NULL }, 1264 1264 #endif 1265 1265 #ifdef TARGET_NR_setfsuid 1266 - { TARGET_NR_setfsuid, "setfsuid" , NULL, NULL, NULL }, 1266 + { TARGET_NR_setfsuid, "setfsuid" , "%s(%u)" , NULL, NULL }, 1267 1267 #endif 1268 1268 #ifdef TARGET_NR_setfsuid32 1269 1269 { TARGET_NR_setfsuid32, "setfsuid32" , NULL, NULL, NULL }, 1270 1270 #endif 1271 1271 #ifdef TARGET_NR_setgid 1272 - { TARGET_NR_setgid, "setgid" , NULL, NULL, NULL }, 1272 + { TARGET_NR_setgid, "setgid" , "%s(%u)", NULL, NULL }, 1273 1273 #endif 1274 1274 #ifdef TARGET_NR_setgid32 1275 - { TARGET_NR_setgid32, "setgid32" , NULL, NULL, NULL }, 1275 + { TARGET_NR_setgid32, "setgid32" , "%s(%u)", NULL, NULL }, 1276 1276 #endif 1277 1277 #ifdef TARGET_NR_setgroups 1278 1278 { TARGET_NR_setgroups, "setgroups" , NULL, NULL, NULL }, ··· 1296 1296 { TARGET_NR_setns, "setns" , NULL, NULL, NULL }, 1297 1297 #endif 1298 1298 #ifdef TARGET_NR_setpgid 1299 - { TARGET_NR_setpgid, "setpgid" , NULL, NULL, NULL }, 1299 + { TARGET_NR_setpgid, "setpgid" , "%s(%u,%u)", NULL, NULL }, 1300 1300 #endif 1301 1301 #ifdef TARGET_NR_setpgrp 1302 1302 { TARGET_NR_setpgrp, "setpgrp" , NULL, NULL, NULL }, ··· 1311 1311 { TARGET_NR_setregid32, "setregid32" , NULL, NULL, NULL }, 1312 1312 #endif 1313 1313 #ifdef TARGET_NR_setresgid 1314 - { TARGET_NR_setresgid, "setresgid" , NULL, NULL, NULL }, 1314 + { TARGET_NR_setresgid, "setresgid" , "%s(%u,%u,%u)", NULL, NULL }, 1315 1315 #endif 1316 1316 #ifdef TARGET_NR_setresgid32 1317 1317 { TARGET_NR_setresgid32, "setresgid32" , NULL, NULL, NULL }, 1318 1318 #endif 1319 1319 #ifdef TARGET_NR_setresuid 1320 - { TARGET_NR_setresuid, "setresuid" , NULL, NULL, NULL }, 1320 + { TARGET_NR_setresuid, "setresuid" , "%s(%u,%u,%u)", NULL, NULL }, 1321 1321 #endif 1322 1322 #ifdef TARGET_NR_setresuid32 1323 - { TARGET_NR_setresuid32, "setresuid32" , NULL, NULL, NULL }, 1323 + { TARGET_NR_setresuid32, "setresuid32" , "%s(%u,%u,%u)", NULL, NULL }, 1324 1324 #endif 1325 1325 #ifdef TARGET_NR_setreuid 1326 - { TARGET_NR_setreuid, "setreuid" , NULL, NULL, NULL }, 1326 + { TARGET_NR_setreuid, "setreuid" , "%s(%u,%u)", NULL, NULL }, 1327 1327 #endif 1328 1328 #ifdef TARGET_NR_setreuid32 1329 - { TARGET_NR_setreuid32, "setreuid32" , NULL, NULL, NULL }, 1329 + { TARGET_NR_setreuid32, "setreuid32" , "%s(%u,%u)", NULL, NULL }, 1330 1330 #endif 1331 1331 #ifdef TARGET_NR_setrlimit 1332 1332 { TARGET_NR_setrlimit, "setrlimit" , NULL, NULL, NULL }, ··· 1335 1335 { TARGET_NR_set_robust_list, "set_robust_list" , NULL, NULL, NULL }, 1336 1336 #endif 1337 1337 #ifdef TARGET_NR_setsid 1338 - { TARGET_NR_setsid, "setsid" , NULL, NULL, NULL }, 1338 + { TARGET_NR_setsid, "setsid" , "%s()", NULL, NULL }, 1339 1339 #endif 1340 1340 #ifdef TARGET_NR_setsockopt 1341 1341 { TARGET_NR_setsockopt, "setsockopt" , NULL, NULL, NULL },

+71 -21

linux-user/syscall.c

··· 111 111 #include <linux/netlink.h> 112 112 #include <linux/if_alg.h> 113 113 #include <linux/rtc.h> 114 + #include <sound/asound.h> 114 115 #include "linux_loop.h" 115 116 #include "uname.h" 116 117 ··· 333 334 #if defined(TARGET_NR_statx) && defined(__NR_statx) 334 335 _syscall5(int, sys_statx, int, dirfd, const char *, pathname, int, flags, 335 336 unsigned int, mask, struct target_statx *, statxbuf) 337 + #endif 338 + #if defined(TARGET_NR_membarrier) && defined(__NR_membarrier) 339 + _syscall2(int, membarrier, int, cmd, int, flags) 336 340 #endif 337 341 338 342 static bitmask_transtbl fcntl_flags_tbl[] = { ··· 1560 1564 * something more intelligent than "twice the size of the 1561 1565 * target buffer we're reading from". 1562 1566 */ 1563 - gemu_log("Host cmsg overflow\n"); 1567 + qemu_log_mask(LOG_UNIMP, 1568 + ("Unsupported ancillary data %d/%d: " 1569 + "unhandled msg size\n"), 1570 + tswap32(target_cmsg->cmsg_level), 1571 + tswap32(target_cmsg->cmsg_type)); 1564 1572 break; 1565 1573 } 1566 1574 ··· 1590 1598 __get_user(cred->uid, &target_cred->uid); 1591 1599 __get_user(cred->gid, &target_cred->gid); 1592 1600 } else { 1593 - gemu_log("Unsupported ancillary data: %d/%d\n", 1594 - cmsg->cmsg_level, cmsg->cmsg_type); 1601 + qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n", 1602 + cmsg->cmsg_level, cmsg->cmsg_type); 1595 1603 memcpy(data, target_data, len); 1596 1604 } 1597 1605 ··· 1812 1820 1813 1821 default: 1814 1822 unimplemented: 1815 - gemu_log("Unsupported ancillary data: %d/%d\n", 1816 - cmsg->cmsg_level, cmsg->cmsg_type); 1823 + qemu_log_mask(LOG_UNIMP, "Unsupported ancillary data: %d/%d\n", 1824 + cmsg->cmsg_level, cmsg->cmsg_type); 1817 1825 memcpy(target_data, data, MIN(len, tgt_len)); 1818 1826 if (tgt_len > len) { 1819 1827 memset(target_data + len, 0, tgt_len - len); ··· 2288 2296 #endif /* SOL_NETLINK */ 2289 2297 default: 2290 2298 unimplemented: 2291 - gemu_log("Unsupported setsockopt level=%d optname=%d\n", level, optname); 2299 + qemu_log_mask(LOG_UNIMP, "Unsupported setsockopt level=%d optname=%d\n", 2300 + level, optname); 2292 2301 ret = -TARGET_ENOPROTOOPT; 2293 2302 } 2294 2303 return ret; ··· 2307 2316 level = SOL_SOCKET; 2308 2317 switch (optname) { 2309 2318 /* These don't just return a single integer */ 2310 - case TARGET_SO_RCVTIMEO: 2311 - case TARGET_SO_SNDTIMEO: 2312 2319 case TARGET_SO_PEERNAME: 2313 2320 goto unimplemented; 2321 + case TARGET_SO_RCVTIMEO: { 2322 + struct timeval tv; 2323 + socklen_t tvlen; 2324 + 2325 + optname = SO_RCVTIMEO; 2326 + 2327 + get_timeout: 2328 + if (get_user_u32(len, optlen)) { 2329 + return -TARGET_EFAULT; 2330 + } 2331 + if (len < 0) { 2332 + return -TARGET_EINVAL; 2333 + } 2334 + 2335 + tvlen = sizeof(tv); 2336 + ret = get_errno(getsockopt(sockfd, level, optname, 2337 + &tv, &tvlen)); 2338 + if (ret < 0) { 2339 + return ret; 2340 + } 2341 + if (len > sizeof(struct target_timeval)) { 2342 + len = sizeof(struct target_timeval); 2343 + } 2344 + if (copy_to_user_timeval(optval_addr, &tv)) { 2345 + return -TARGET_EFAULT; 2346 + } 2347 + if (put_user_u32(len, optlen)) { 2348 + return -TARGET_EFAULT; 2349 + } 2350 + break; 2351 + } 2352 + case TARGET_SO_SNDTIMEO: 2353 + optname = SO_SNDTIMEO; 2354 + goto get_timeout; 2314 2355 case TARGET_SO_PEERCRED: { 2315 2356 struct ucred cr; 2316 2357 socklen_t crlen; ··· 2663 2704 #endif /* SOL_NETLINK */ 2664 2705 default: 2665 2706 unimplemented: 2666 - gemu_log("getsockopt level=%d optname=%d not yet supported\n", 2667 - level, optname); 2707 + qemu_log_mask(LOG_UNIMP, 2708 + "getsockopt level=%d optname=%d not yet supported\n", 2709 + level, optname); 2668 2710 ret = -TARGET_EOPNOTSUPP; 2669 2711 break; 2670 2712 } ··· 3419 3461 case TARGET_SYS_SENDMMSG: /* sockfd, msgvec, vlen, flags */ 3420 3462 return do_sendrecvmmsg(a[0], a[1], a[2], a[3], 1); 3421 3463 default: 3422 - gemu_log("Unsupported socketcall: %d\n", num); 3464 + qemu_log_mask(LOG_UNIMP, "Unsupported socketcall: %d\n", num); 3423 3465 return -TARGET_EINVAL; 3424 3466 } 3425 3467 } ··· 4330 4372 ret = do_shmctl(first, second, ptr); 4331 4373 break; 4332 4374 default: 4333 - gemu_log("Unsupported ipc call: %d (version %d)\n", call, version); 4375 + qemu_log_mask(LOG_UNIMP, "Unsupported ipc call: %d (version %d)\n", 4376 + call, version); 4334 4377 ret = -TARGET_ENOSYS; 4335 4378 break; 4336 4379 } ··· 5178 5221 ie = ioctl_entries; 5179 5222 for(;;) { 5180 5223 if (ie->target_cmd == 0) { 5181 - gemu_log("Unsupported ioctl: cmd=0x%04lx\n", (long)cmd); 5224 + qemu_log_mask( 5225 + LOG_UNIMP, "Unsupported ioctl: cmd=0x%04lx\n", (long)cmd); 5182 5226 return -TARGET_ENOSYS; 5183 5227 } 5184 5228 if (ie->target_cmd == cmd) ··· 5246 5290 } 5247 5291 break; 5248 5292 default: 5249 - gemu_log("Unsupported ioctl type: cmd=0x%04lx type=%d\n", 5250 - (long)cmd, arg_type[0]); 5293 + qemu_log_mask(LOG_UNIMP, 5294 + "Unsupported ioctl type: cmd=0x%04lx type=%d\n", 5295 + (long)cmd, arg_type[0]); 5251 5296 ret = -TARGET_ENOSYS; 5252 5297 break; 5253 5298 } ··· 12090 12135 unlock_user(p, arg1, 0); 12091 12136 return ret; 12092 12137 #endif 12138 + #if defined TARGET_NR_membarrier && defined __NR_membarrier 12139 + case TARGET_NR_membarrier: 12140 + return get_errno(membarrier(arg1, arg2)); 12141 + #endif 12093 12142 12094 12143 default: 12095 12144 qemu_log_mask(LOG_UNIMP, "Unsupported syscall: %d\n", num); ··· 12123 12172 record_syscall_start(cpu, num, arg1, 12124 12173 arg2, arg3, arg4, arg5, arg6, arg7, arg8); 12125 12174 12126 - if (unlikely(do_strace)) { 12175 + if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 12127 12176 print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6); 12128 - ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4, 12129 - arg5, arg6, arg7, arg8); 12177 + } 12178 + 12179 + ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4, 12180 + arg5, arg6, arg7, arg8); 12181 + 12182 + if (unlikely(qemu_loglevel_mask(LOG_STRACE))) { 12130 12183 print_syscall_ret(num, ret); 12131 - } else { 12132 - ret = do_syscall1(cpu_env, num, arg1, arg2, arg3, arg4, 12133 - arg5, arg6, arg7, arg8); 12134 12184 } 12135 12185 12136 12186 record_syscall_return(cpu, num, ret);

+84

linux-user/syscall_defs.h

··· 2437 2437 2438 2438 #define TARGET_SOUND_MIXER_WRITE_RECSRC TARGET_MIXER_WRITE(SOUND_MIXER_RECSRC) 2439 2439 2440 + struct target_snd_timer_id { 2441 + int dev_class; 2442 + int dev_sclass; 2443 + int card; 2444 + int device; 2445 + int subdevice; 2446 + }; 2447 + 2448 + struct target_snd_timer_ginfo { 2449 + struct target_snd_timer_id tid; 2450 + unsigned int flags; 2451 + int card; 2452 + unsigned char id[64]; 2453 + unsigned char name[80]; 2454 + abi_ulong reserved0; 2455 + abi_ulong resolution; 2456 + abi_ulong resolution_min; 2457 + abi_ulong resolution_max; 2458 + unsigned int clients; 2459 + unsigned char reserved[32]; 2460 + }; 2461 + 2462 + struct target_snd_timer_gparams { 2463 + struct target_snd_timer_id tid; 2464 + abi_ulong period_num; 2465 + abi_ulong period_den; 2466 + unsigned char reserved[32]; 2467 + }; 2468 + 2469 + struct target_snd_timer_gstatus { 2470 + struct target_snd_timer_id tid; 2471 + abi_ulong resolution; 2472 + abi_ulong resolution_num; 2473 + abi_ulong resolution_den; 2474 + unsigned char reserved[32]; 2475 + }; 2476 + 2477 + struct target_snd_timer_select { 2478 + struct target_snd_timer_id id; 2479 + unsigned char reserved[32]; 2480 + }; 2481 + 2482 + struct target_snd_timer_info { 2483 + unsigned int flags; 2484 + int card; 2485 + unsigned char id[64]; 2486 + unsigned char name[80]; 2487 + abi_ulong reserved0; 2488 + abi_ulong resolution; 2489 + unsigned char reserved[64]; 2490 + }; 2491 + 2492 + struct target_snd_timer_status { 2493 + struct target_timespec tstamp; 2494 + unsigned int resolution; 2495 + unsigned int lost; 2496 + unsigned int overrun; 2497 + unsigned int queue; 2498 + unsigned char reserved[64]; 2499 + }; 2500 + 2501 + /* alsa timer ioctls */ 2502 + #define TARGET_SNDRV_TIMER_IOCTL_PVERSION TARGET_IOR('T', 0x00, int) 2503 + #define TARGET_SNDRV_TIMER_IOCTL_NEXT_DEVICE TARGET_IOWR('T', 0x01, \ 2504 + struct snd_timer_id) 2505 + #define TARGET_SNDRV_TIMER_IOCTL_GINFO TARGET_IOWR('T', 0x03, \ 2506 + struct target_snd_timer_ginfo) 2507 + #define TARGET_SNDRV_TIMER_IOCTL_GPARAMS TARGET_IOW('T', 0x04, \ 2508 + struct target_snd_timer_gparams) 2509 + #define TARGET_SNDRV_TIMER_IOCTL_GSTATUS TARGET_IOWR('T', 0x05, \ 2510 + struct target_snd_timer_gstatus) 2511 + #define TARGET_SNDRV_TIMER_IOCTL_SELECT TARGET_IOW('T', 0x10, \ 2512 + struct target_snd_timer_select) 2513 + #define TARGET_SNDRV_TIMER_IOCTL_INFO TARGET_IOR('T', 0x11, \ 2514 + struct target_snd_timer_info) 2515 + #define TARGET_SNDRV_TIMER_IOCTL_PARAMS TARGET_IOW('T', 0x12, \ 2516 + struct snd_timer_params) 2517 + #define TARGET_SNDRV_TIMER_IOCTL_STATUS TARGET_IOR('T', 0x14, \ 2518 + struct target_snd_timer_status) 2519 + #define TARGET_SNDRV_TIMER_IOCTL_START TARGET_IO('T', 0xa0) 2520 + #define TARGET_SNDRV_TIMER_IOCTL_STOP TARGET_IO('T', 0xa1) 2521 + #define TARGET_SNDRV_TIMER_IOCTL_CONTINUE TARGET_IO('T', 0xa2) 2522 + #define TARGET_SNDRV_TIMER_IOCTL_PAUSE TARGET_IO('T', 0xa3) 2523 + 2440 2524 /* vfat ioctls */ 2441 2525 #define TARGET_VFAT_IOCTL_READDIR_BOTH TARGET_IORU('r', 1) 2442 2526 #define TARGET_VFAT_IOCTL_READDIR_SHORT TARGET_IORU('r', 2)

+66

linux-user/syscall_types.h

··· 83 83 STRUCT(mixer_info, 84 84 MK_ARRAY(TYPE_CHAR, 16), MK_ARRAY(TYPE_CHAR, 32), TYPE_INT, MK_ARRAY(TYPE_INT, 10)) 85 85 86 + STRUCT(snd_timer_id, 87 + TYPE_INT, /* dev_class */ 88 + TYPE_INT, /* dev_sclass */ 89 + TYPE_INT, /* card */ 90 + TYPE_INT, /* device */ 91 + TYPE_INT) /* subdevice */ 92 + 93 + STRUCT(snd_timer_ginfo, 94 + MK_STRUCT(STRUCT_snd_timer_id), /* tid */ 95 + TYPE_INT, /* flags */ 96 + TYPE_INT, /* card */ 97 + MK_ARRAY(TYPE_CHAR, 64), /* id */ 98 + MK_ARRAY(TYPE_CHAR, 80), /* name */ 99 + TYPE_ULONG, /* reserved0 */ 100 + TYPE_ULONG, /* resolution */ 101 + TYPE_ULONG, /* resolution_min */ 102 + TYPE_ULONG, /* resolution_max */ 103 + TYPE_INT, /* clients */ 104 + MK_ARRAY(TYPE_CHAR, 32)) /* reserved */ 105 + 106 + STRUCT(snd_timer_gparams, 107 + MK_STRUCT(STRUCT_snd_timer_id), /* tid */ 108 + TYPE_ULONG, /* period_num */ 109 + TYPE_ULONG, /* period_den */ 110 + MK_ARRAY(TYPE_CHAR, 32)) /* reserved */ 111 + 112 + STRUCT(snd_timer_gstatus, 113 + MK_STRUCT(STRUCT_snd_timer_id), /* tid */ 114 + TYPE_ULONG, /* resolution */ 115 + TYPE_ULONG, /* resolution_num */ 116 + TYPE_ULONG, /* resolution_den */ 117 + MK_ARRAY(TYPE_CHAR, 32)) /* reserved */ 118 + 119 + STRUCT(snd_timer_select, 120 + MK_STRUCT(STRUCT_snd_timer_id), /* id */ 121 + MK_ARRAY(TYPE_CHAR, 32)) /* reserved */ 122 + 123 + STRUCT(snd_timer_info, 124 + TYPE_INT, /* flags */ 125 + TYPE_INT, /* card */ 126 + MK_ARRAY(TYPE_CHAR, 64), /* id */ 127 + MK_ARRAY(TYPE_CHAR, 80), /* name */ 128 + TYPE_ULONG, /* reserved0 */ 129 + TYPE_ULONG, /* resolution */ 130 + MK_ARRAY(TYPE_CHAR, 64)) /* reserved */ 131 + 132 + STRUCT(snd_timer_params, 133 + TYPE_INT, /* flags */ 134 + TYPE_INT, /* ticks */ 135 + TYPE_INT, /* queue_size */ 136 + TYPE_INT, /* reserved0 */ 137 + TYPE_INT, /* filter */ 138 + MK_ARRAY(TYPE_CHAR, 60)) /* reserved */ 139 + 140 + STRUCT(timespec, 141 + TYPE_LONG, /* tv_sec */ 142 + TYPE_LONG) /* tv_nsec */ 143 + 144 + STRUCT(snd_timer_status, 145 + MK_STRUCT(STRUCT_timespec), /* tstamp */ 146 + TYPE_INT, /* resolution */ 147 + TYPE_INT, /* lost */ 148 + TYPE_INT, /* overrun */ 149 + TYPE_INT, /* queue */ 150 + MK_ARRAY(TYPE_CHAR, 64)) /* reserved */ 151 + 86 152 /* loop device ioctls */ 87 153 STRUCT(loop_info, 88 154 TYPE_INT, /* lo_number */

+2 -1

linux-user/vm86.c

··· 402 402 case TARGET_VM86_FREE_IRQ: 403 403 case TARGET_VM86_GET_IRQ_BITS: 404 404 case TARGET_VM86_GET_AND_RESET_IRQ: 405 - gemu_log("qemu: unsupported vm86 subfunction (%ld)\n", subfunction); 405 + qemu_log_mask(LOG_UNIMP, "qemu: unsupported vm86 subfunction (%ld)\n", 406 + subfunction); 406 407 ret = -TARGET_EINVAL; 407 408 goto out; 408 409 case TARGET_VM86_PLUS_INSTALL_CHECK:

+2

util/log.c

··· 332 332 #ifdef CONFIG_PLUGIN 333 333 { CPU_LOG_PLUGIN, "plugin", "output from TCG plugins\n"}, 334 334 #endif 335 + { LOG_STRACE, "strace", 336 + "log every user-mode syscall, its input, and its result" }, 335 337 { 0, NULL, NULL }, 336 338 }; 337 339