| 227 |
227 |
{
|
| 228 |
228 |
}
|
| 229 |
229 |
|
|
230 |
/* If we have signalfd, we mask out the signals we want to handle and then
|
|
231 |
* use signalfd to listen for them. We rely on whatever the current signal
|
|
232 |
* handler is to dispatch the signals when we receive them.
|
|
233 |
*/
|
|
234 |
static void sigfd_handler(void *opaque)
|
|
235 |
{
|
|
236 |
int fd = (unsigned long) opaque;
|
|
237 |
struct qemu_signalfd_siginfo info;
|
|
238 |
struct sigaction action;
|
|
239 |
ssize_t len;
|
|
240 |
|
|
241 |
while (1) {
|
|
242 |
do {
|
|
243 |
len = read(fd, &info, sizeof(info));
|
|
244 |
} while (len == -1 && errno == EINTR);
|
|
245 |
|
|
246 |
if (len == -1 && errno == EAGAIN) {
|
|
247 |
break;
|
|
248 |
}
|
|
249 |
|
|
250 |
if (len != sizeof(info)) {
|
|
251 |
printf("read from sigfd returned %zd: %m\n", len);
|
|
252 |
return;
|
|
253 |
}
|
|
254 |
|
|
255 |
sigaction(info.ssi_signo, NULL, &action);
|
|
256 |
if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
|
|
257 |
action.sa_sigaction(info.ssi_signo,
|
|
258 |
(siginfo_t *)&info, NULL);
|
|
259 |
} else if (action.sa_handler) {
|
|
260 |
action.sa_handler(info.ssi_signo);
|
|
261 |
}
|
|
262 |
}
|
|
263 |
}
|
|
264 |
|
|
265 |
static int qemu_signalfd_init(sigset_t mask)
|
|
266 |
{
|
|
267 |
int sigfd;
|
|
268 |
|
|
269 |
sigfd = qemu_signalfd(&mask);
|
|
270 |
if (sigfd == -1) {
|
|
271 |
fprintf(stderr, "failed to create signalfd\n");
|
|
272 |
return -errno;
|
|
273 |
}
|
|
274 |
|
|
275 |
fcntl_setfl(sigfd, O_NONBLOCK);
|
|
276 |
|
|
277 |
qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
|
|
278 |
(void *)(unsigned long) sigfd);
|
|
279 |
|
|
280 |
return 0;
|
|
281 |
}
|
|
282 |
|
| 230 |
283 |
static void sigbus_reraise(void);
|
| 231 |
284 |
|
| 232 |
285 |
static void qemu_kvm_eat_signals(CPUState *env)
|
| ... | ... | |
| 330 |
383 |
|
| 331 |
384 |
int qemu_init_main_loop(void)
|
| 332 |
385 |
{
|
|
386 |
#ifndef _WIN32
|
|
387 |
sigset_t blocked_signals;
|
|
388 |
int ret;
|
|
389 |
|
|
390 |
sigemptyset(&blocked_signals);
|
|
391 |
|
|
392 |
ret = qemu_signalfd_init(blocked_signals);
|
|
393 |
if (ret) {
|
|
394 |
return ret;
|
|
395 |
}
|
|
396 |
#endif
|
| 333 |
397 |
cpu_set_debug_excp_handler(cpu_debug_handler);
|
| 334 |
398 |
|
| 335 |
399 |
return qemu_event_init();
|
| ... | ... | |
| 426 |
490 |
static QemuCond qemu_pause_cond;
|
| 427 |
491 |
static QemuCond qemu_work_cond;
|
| 428 |
492 |
|
| 429 |
|
/* If we have signalfd, we mask out the signals we want to handle and then
|
| 430 |
|
* use signalfd to listen for them. We rely on whatever the current signal
|
| 431 |
|
* handler is to dispatch the signals when we receive them.
|
| 432 |
|
*/
|
| 433 |
|
static void sigfd_handler(void *opaque)
|
| 434 |
|
{
|
| 435 |
|
int fd = (unsigned long) opaque;
|
| 436 |
|
struct qemu_signalfd_siginfo info;
|
| 437 |
|
struct sigaction action;
|
| 438 |
|
ssize_t len;
|
| 439 |
|
|
| 440 |
|
while (1) {
|
| 441 |
|
do {
|
| 442 |
|
len = read(fd, &info, sizeof(info));
|
| 443 |
|
} while (len == -1 && errno == EINTR);
|
| 444 |
|
|
| 445 |
|
if (len == -1 && errno == EAGAIN) {
|
| 446 |
|
break;
|
| 447 |
|
}
|
| 448 |
|
|
| 449 |
|
if (len != sizeof(info)) {
|
| 450 |
|
printf("read from sigfd returned %zd: %m\n", len);
|
| 451 |
|
return;
|
| 452 |
|
}
|
| 453 |
|
|
| 454 |
|
sigaction(info.ssi_signo, NULL, &action);
|
| 455 |
|
if ((action.sa_flags & SA_SIGINFO) && action.sa_sigaction) {
|
| 456 |
|
action.sa_sigaction(info.ssi_signo,
|
| 457 |
|
(siginfo_t *)&info, NULL);
|
| 458 |
|
} else if (action.sa_handler) {
|
| 459 |
|
action.sa_handler(info.ssi_signo);
|
| 460 |
|
}
|
| 461 |
|
}
|
| 462 |
|
}
|
| 463 |
|
|
| 464 |
493 |
static void cpu_signal(int sig)
|
| 465 |
494 |
{
|
| 466 |
495 |
if (cpu_single_env) {
|
| ... | ... | |
| 532 |
561 |
return set;
|
| 533 |
562 |
}
|
| 534 |
563 |
|
| 535 |
|
static int qemu_signalfd_init(sigset_t mask)
|
| 536 |
|
{
|
| 537 |
|
int sigfd;
|
| 538 |
|
|
| 539 |
|
sigfd = qemu_signalfd(&mask);
|
| 540 |
|
if (sigfd == -1) {
|
| 541 |
|
fprintf(stderr, "failed to create signalfd\n");
|
| 542 |
|
return -errno;
|
| 543 |
|
}
|
| 544 |
|
|
| 545 |
|
fcntl_setfl(sigfd, O_NONBLOCK);
|
| 546 |
|
|
| 547 |
|
qemu_set_fd_handler2(sigfd, NULL, sigfd_handler, NULL,
|
| 548 |
|
(void *)(unsigned long) sigfd);
|
| 549 |
|
|
| 550 |
|
return 0;
|
| 551 |
|
}
|
| 552 |
|
|
| 553 |
564 |
int qemu_init_main_loop(void)
|
| 554 |
565 |
{
|
| 555 |
566 |
int ret;
|