tree: https://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux.git kprobes/kretprobe-stackfix head: 6e2b8966c87adc1be0fb4a386fb24ae438f4cb79 commit: 3f16730e94371a16e7c5490095b089cb198440e6 [9/10] x86/unwind/orc,kprobes: Fixup kretprobe trampoline entry config: x86_64-randconfig-m001-20210316 (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0 reproduce (this is a W=1 build): # https://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux.git/commit... git remote add mhiramat https://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux.git git fetch --no-tags mhiramat kprobes/kretprobe-stackfix git checkout 3f16730e94371a16e7c5490095b089cb198440e6 # save the attached .config to linux build tree make W=1 ARCH=x86_64 If you fix the issue, kindly add following tag as appropriate Reported-by: kernel test robot <lkp(a)intel.com&gt; All errors (new ones prefixed by >>): arch/x86/kernel/unwind_orc.c: In function 'unwind_next_frame': 547 | &state->kr_iter); | ^~ vim +547 arch/x86/kernel/unwind_orc.c 417 418 bool unwind_next_frame(struct unwind_state *state) 419 { 420 unsigned long ip_p, sp, tmp, orig_ip = state->ip, prev_sp = state->sp; 421 enum stack_type prev_type = state->stack_info.type; 422 struct orc_entry *orc; 423 bool indirect = false; 424 425 if (unwind_done(state)) 426 return false; 427 428 /* Don't let modules unload while we're reading their ORC data. */ 429 preempt_disable(); 430 431 /* End-of-stack check for user tasks: */ 432 if (state->regs && user_mode(state->regs)) 433 goto the_end; 434 435 /* 436 * Find the orc_entry associated with the text address. 437 * 438 * For a call frame (as opposed to a signal frame), state->ip points to 439 * the instruction after the call. That instruction's stack layout 440 * could be different from the call instruction's layout, for example 441 * if the call was to a noreturn function. So get the ORC data for the 442 * call instruction itself. 443 */ 444 orc = orc_find(state->signal ? state->ip : state->ip - 1); 445 if (!orc) { 446 /* 447 * As a fallback, try to assume this code uses a frame pointer. 448 * This is useful for generated code, like BPF, which ORC 449 * doesn't know about. This is just a guess, so the rest of 450 * the unwind is no longer considered reliable. 451 */ 452 orc = &orc_fp_entry; 453 state->error = true; 454 } 455 456 /* End-of-stack check for kernel threads: */ 457 if (orc->sp_reg == ORC_REG_UNDEFINED) { 458 if (!orc->end) 459 goto err; 460 461 goto the_end; 462 } 463 464 /* Find the previous frame's stack: */ 465 switch (orc->sp_reg) { 466 case ORC_REG_SP: 467 sp = state->sp + orc->sp_offset; 468 break; 469 470 case ORC_REG_BP: 471 sp = state->bp + orc->sp_offset; 472 break; 473 474 case ORC_REG_SP_INDIRECT: 475 sp = state->sp; 476 indirect = true; 477 break; 478 479 case ORC_REG_BP_INDIRECT: 480 sp = state->bp + orc->sp_offset; 481 indirect = true; 482 break; 483 484 case ORC_REG_R10: 485 if (!get_reg(state, offsetof(struct pt_regs, r10), &sp)) { 486 orc_warn_current("missing R10 value at %pB\n", 487 (void *)state->ip); 488 goto err; 489 } 490 break; 491 492 case ORC_REG_R13: 493 if (!get_reg(state, offsetof(struct pt_regs, r13), &sp)) { 494 orc_warn_current("missing R13 value at %pB\n", 495 (void *)state->ip); 496 goto err; 497 } 498 break; 499 500 case ORC_REG_DI: 501 if (!get_reg(state, offsetof(struct pt_regs, di), &sp)) { 502 orc_warn_current("missing RDI value at %pB\n", 503 (void *)state->ip); 504 goto err; 505 } 506 break; 507 508 case ORC_REG_DX: 509 if (!get_reg(state, offsetof(struct pt_regs, dx), &sp)) { 510 orc_warn_current("missing DX value at %pB\n", 511 (void *)state->ip); 512 goto err; 513 } 514 break; 515 516 default: 517 orc_warn("unknown SP base reg %d at %pB\n", 518 orc->sp_reg, (void *)state->ip); 519 goto err; 520 } 521 522 if (indirect) { 523 if (!deref_stack_reg(state, sp, &sp)) 524 goto err; 525 526 if (orc->sp_reg == ORC_REG_SP_INDIRECT) 527 sp += orc->sp_offset; 528 } 529 530 /* Find IP, SP and possibly regs: */ 531 switch (orc->type) { 532 case UNWIND_HINT_TYPE_CALL: 533 ip_p = sp - sizeof(long); 534 535 if (!deref_stack_reg(state, ip_p, &state->ip)) 536 goto err; 537 538 state->ip = ftrace_graph_ret_addr(state->task, &state->graph_idx, 539 state->ip, (void *)ip_p); 540 /* 541 * When the unwinder finds the kretprobe_trampoline instead of 542 * the real return address on stack, find the correct return 543 * address from task->kretprobe_instances list. 544 */ 545 if (is_kretprobe_trampoline(state->ip)) 546 state->ip = kretprobe_find_ret_addr(state->task, 548 549 state->sp = sp; 550 state->regs = NULL; 551 state->prev_regs = NULL; 552 state->signal = false; 553 break; 554 555 case UNWIND_HINT_TYPE_REGS: 556 if (!deref_stack_regs(state, sp, &state->ip, &state->sp)) { 557 orc_warn_current("can't access registers at %pB\n", 558 (void *)orig_ip); 559 goto err; 560 } 561 562 state->regs = (struct pt_regs *)sp; 563 state->prev_regs = NULL; 564 state->full_regs = true; 565 state->signal = true; 566 break; 567 568 case UNWIND_HINT_TYPE_REGS_PARTIAL: 569 if (!deref_stack_iret_regs(state, sp, &state->ip, &state->sp)) { 570 orc_warn_current("can't access iret registers at %pB\n", 571 (void *)orig_ip); 572 goto err; 573 } 574 575 if (state->full_regs) 576 state->prev_regs = state->regs; 577 state->regs = (void *)sp - IRET_FRAME_OFFSET; 578 state->full_regs = false; 579 state->signal = true; 580 break; 581 582 default: 583 orc_warn("unknown .orc_unwind entry type %d at %pB\n", 584 orc->type, (void *)orig_ip); 585 goto err; 586 } 587 588 /* Find BP: */ 589 switch (orc->bp_reg) { 590 case ORC_REG_UNDEFINED: 591 if (get_reg(state, offsetof(struct pt_regs, bp), &tmp)) 592 state->bp = tmp; 593 break; 594 595 case ORC_REG_PREV_SP: 596 if (!deref_stack_reg(state, sp + orc->bp_offset, &state->bp)) 597 goto err; 598 break; 599 600 case ORC_REG_BP: 601 if (!deref_stack_reg(state, state->bp + orc->bp_offset, &state->bp)) 602 goto err; 603 break; 604 605 default: 606 orc_warn("unknown BP base reg %d for ip %pB\n", 607 orc->bp_reg, (void *)orig_ip); 608 goto err; 609 } 610 611 /* Prevent a recursive loop due to bad ORC data: */ 612 if (state->stack_info.type == prev_type && 613 on_stack(&state->stack_info, (void *)state->sp, sizeof(long)) && 614 state->sp <= prev_sp) { 615 orc_warn_current("stack going in the wrong direction? at %pB\n", 616 (void *)orig_ip); 617 goto err; 618 } 619 620 preempt_enable(); 621 return true; 622 623 err: 624 state->error = true; 625 626 the_end: 627 preempt_enable(); 628 state->stack_info.type = STACK_TYPE_UNKNOWN; 629 return false; 630 } 631 EXPORT_SYMBOL_GPL(unwind_next_frame); 632 --- 0-DAY CI Kernel Test Service, Intel Corporation https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org