selftests/rseq: Remove arm/mips asm goto compiler work-around

Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git

kernel os linux

The arm and mips work-around for asm goto size guess issues are not
properly documented, and lack reference to specific compiler versions,
upstream compiler bug tracker entry, and reproducer.

I can only find a loosely documented patch in my original LKML rseq post
refering to gcc < 7 on ARM, but it does not appear to be sufficient to
track the exact issue. Also, I am not sure MIPS really has the same
limitation.

Therefore, remove the work-around until we can properly document this.

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lore.kernel.org/lkml/20171121141900.18471-17-mathieu.desnoyers@efficios.com/

authored by

Mathieu Desnoyers and committed by

Peter Zijlstra 4 years ago 94c5cf2a d7ed99ad

-74

2 changed files

expand all

tools

testing

selftests

rseq

rseq-arm.h

rseq-mips.h

-37

tools/testing/selftests/rseq/rseq-arm.h

··· 147 147 teardown \ 148 148 "b %l[" __rseq_str(cmpfail_label) "]\n\t" 149 149 150 - #define rseq_workaround_gcc_asm_size_guess() __asm__ __volatile__("") 151 - 152 150 static inline __attribute__((always_inline)) 153 151 int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, int cpu) 154 152 { 155 153 RSEQ_INJECT_C(9) 156 154 157 - rseq_workaround_gcc_asm_size_guess(); 158 155 __asm__ __volatile__ goto ( 159 156 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 160 157 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 195 198 , error1, error2 196 199 #endif 197 200 ); 198 - rseq_workaround_gcc_asm_size_guess(); 199 201 return 0; 200 202 abort: 201 - rseq_workaround_gcc_asm_size_guess(); 202 203 RSEQ_INJECT_FAILED 203 204 return -1; 204 205 cmpfail: 205 - rseq_workaround_gcc_asm_size_guess(); 206 206 return 1; 207 207 #ifdef RSEQ_COMPARE_TWICE 208 208 error1: ··· 215 221 { 216 222 RSEQ_INJECT_C(9) 217 223 218 - rseq_workaround_gcc_asm_size_guess(); 219 224 __asm__ __volatile__ goto ( 220 225 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 221 226 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 263 270 , error1, error2 264 271 #endif 265 272 ); 266 - rseq_workaround_gcc_asm_size_guess(); 267 273 return 0; 268 274 abort: 269 - rseq_workaround_gcc_asm_size_guess(); 270 275 RSEQ_INJECT_FAILED 271 276 return -1; 272 277 cmpfail: 273 - rseq_workaround_gcc_asm_size_guess(); 274 278 return 1; 275 279 #ifdef RSEQ_COMPARE_TWICE 276 280 error1: ··· 282 292 { 283 293 RSEQ_INJECT_C(9) 284 294 285 - rseq_workaround_gcc_asm_size_guess(); 286 295 __asm__ __volatile__ goto ( 287 296 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 288 297 #ifdef RSEQ_COMPARE_TWICE ··· 317 328 , error1 318 329 #endif 319 330 ); 320 - rseq_workaround_gcc_asm_size_guess(); 321 331 return 0; 322 332 abort: 323 - rseq_workaround_gcc_asm_size_guess(); 324 333 RSEQ_INJECT_FAILED 325 334 return -1; 326 335 #ifdef RSEQ_COMPARE_TWICE ··· 334 347 { 335 348 RSEQ_INJECT_C(9) 336 349 337 - rseq_workaround_gcc_asm_size_guess(); 338 350 __asm__ __volatile__ goto ( 339 351 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 340 352 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 384 398 , error1, error2 385 399 #endif 386 400 ); 387 - rseq_workaround_gcc_asm_size_guess(); 388 401 return 0; 389 402 abort: 390 - rseq_workaround_gcc_asm_size_guess(); 391 403 RSEQ_INJECT_FAILED 392 404 return -1; 393 405 cmpfail: 394 - rseq_workaround_gcc_asm_size_guess(); 395 406 return 1; 396 407 #ifdef RSEQ_COMPARE_TWICE 397 408 error1: ··· 405 422 { 406 423 RSEQ_INJECT_C(9) 407 424 408 - rseq_workaround_gcc_asm_size_guess(); 409 425 __asm__ __volatile__ goto ( 410 426 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 411 427 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 456 474 , error1, error2 457 475 #endif 458 476 ); 459 - rseq_workaround_gcc_asm_size_guess(); 460 477 return 0; 461 478 abort: 462 - rseq_workaround_gcc_asm_size_guess(); 463 479 RSEQ_INJECT_FAILED 464 480 return -1; 465 481 cmpfail: 466 - rseq_workaround_gcc_asm_size_guess(); 467 482 return 1; 468 483 #ifdef RSEQ_COMPARE_TWICE 469 484 error1: ··· 477 498 { 478 499 RSEQ_INJECT_C(9) 479 500 480 - rseq_workaround_gcc_asm_size_guess(); 481 501 __asm__ __volatile__ goto ( 482 502 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 483 503 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 532 554 , error1, error2, error3 533 555 #endif 534 556 ); 535 - rseq_workaround_gcc_asm_size_guess(); 536 557 return 0; 537 558 abort: 538 - rseq_workaround_gcc_asm_size_guess(); 539 559 RSEQ_INJECT_FAILED 540 560 return -1; 541 561 cmpfail: 542 - rseq_workaround_gcc_asm_size_guess(); 543 562 return 1; 544 563 #ifdef RSEQ_COMPARE_TWICE 545 564 error1: ··· 557 582 558 583 RSEQ_INJECT_C(9) 559 584 560 - rseq_workaround_gcc_asm_size_guess(); 561 585 __asm__ __volatile__ goto ( 562 586 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 563 587 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 652 678 , error1, error2 653 679 #endif 654 680 ); 655 - rseq_workaround_gcc_asm_size_guess(); 656 681 return 0; 657 682 abort: 658 - rseq_workaround_gcc_asm_size_guess(); 659 683 RSEQ_INJECT_FAILED 660 684 return -1; 661 685 cmpfail: 662 - rseq_workaround_gcc_asm_size_guess(); 663 686 return 1; 664 687 #ifdef RSEQ_COMPARE_TWICE 665 688 error1: 666 - rseq_workaround_gcc_asm_size_guess(); 667 689 rseq_bug("cpu_id comparison failed"); 668 690 error2: 669 - rseq_workaround_gcc_asm_size_guess(); 670 691 rseq_bug("expected value comparison failed"); 671 692 #endif 672 693 } ··· 675 706 676 707 RSEQ_INJECT_C(9) 677 708 678 - rseq_workaround_gcc_asm_size_guess(); 679 709 __asm__ __volatile__ goto ( 680 710 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 681 711 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 771 803 , error1, error2 772 804 #endif 773 805 ); 774 - rseq_workaround_gcc_asm_size_guess(); 775 806 return 0; 776 807 abort: 777 - rseq_workaround_gcc_asm_size_guess(); 778 808 RSEQ_INJECT_FAILED 779 809 return -1; 780 810 cmpfail: 781 - rseq_workaround_gcc_asm_size_guess(); 782 811 return 1; 783 812 #ifdef RSEQ_COMPARE_TWICE 784 813 error1: 785 - rseq_workaround_gcc_asm_size_guess(); 786 814 rseq_bug("cpu_id comparison failed"); 787 815 error2: 788 - rseq_workaround_gcc_asm_size_guess(); 789 816 rseq_bug("expected value comparison failed"); 790 817 #endif 791 818 }

-37

tools/testing/selftests/rseq/rseq-mips.h

··· 154 154 teardown \ 155 155 "b %l[" __rseq_str(cmpfail_label) "]\n\t" 156 156 157 - #define rseq_workaround_gcc_asm_size_guess() __asm__ __volatile__("") 158 - 159 157 static inline __attribute__((always_inline)) 160 158 int rseq_cmpeqv_storev(intptr_t *v, intptr_t expect, intptr_t newv, int cpu) 161 159 { 162 160 RSEQ_INJECT_C(9) 163 161 164 - rseq_workaround_gcc_asm_size_guess(); 165 162 __asm__ __volatile__ goto ( 166 163 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 167 164 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 200 203 , error1, error2 201 204 #endif 202 205 ); 203 - rseq_workaround_gcc_asm_size_guess(); 204 206 return 0; 205 207 abort: 206 - rseq_workaround_gcc_asm_size_guess(); 207 208 RSEQ_INJECT_FAILED 208 209 return -1; 209 210 cmpfail: 210 - rseq_workaround_gcc_asm_size_guess(); 211 211 return 1; 212 212 #ifdef RSEQ_COMPARE_TWICE 213 213 error1: ··· 220 226 { 221 227 RSEQ_INJECT_C(9) 222 228 223 - rseq_workaround_gcc_asm_size_guess(); 224 229 __asm__ __volatile__ goto ( 225 230 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 226 231 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 266 273 , error1, error2 267 274 #endif 268 275 ); 269 - rseq_workaround_gcc_asm_size_guess(); 270 276 return 0; 271 277 abort: 272 - rseq_workaround_gcc_asm_size_guess(); 273 278 RSEQ_INJECT_FAILED 274 279 return -1; 275 280 cmpfail: 276 - rseq_workaround_gcc_asm_size_guess(); 277 281 return 1; 278 282 #ifdef RSEQ_COMPARE_TWICE 279 283 error1: ··· 285 295 { 286 296 RSEQ_INJECT_C(9) 287 297 288 - rseq_workaround_gcc_asm_size_guess(); 289 298 __asm__ __volatile__ goto ( 290 299 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 291 300 #ifdef RSEQ_COMPARE_TWICE ··· 320 331 , error1 321 332 #endif 322 333 ); 323 - rseq_workaround_gcc_asm_size_guess(); 324 334 return 0; 325 335 abort: 326 - rseq_workaround_gcc_asm_size_guess(); 327 336 RSEQ_INJECT_FAILED 328 337 return -1; 329 338 #ifdef RSEQ_COMPARE_TWICE ··· 337 350 { 338 351 RSEQ_INJECT_C(9) 339 352 340 - rseq_workaround_gcc_asm_size_guess(); 341 353 __asm__ __volatile__ goto ( 342 354 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 343 355 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 385 399 , error1, error2 386 400 #endif 387 401 ); 388 - rseq_workaround_gcc_asm_size_guess(); 389 402 return 0; 390 403 abort: 391 - rseq_workaround_gcc_asm_size_guess(); 392 404 RSEQ_INJECT_FAILED 393 405 return -1; 394 406 cmpfail: 395 - rseq_workaround_gcc_asm_size_guess(); 396 407 return 1; 397 408 #ifdef RSEQ_COMPARE_TWICE 398 409 error1: ··· 406 423 { 407 424 RSEQ_INJECT_C(9) 408 425 409 - rseq_workaround_gcc_asm_size_guess(); 410 426 __asm__ __volatile__ goto ( 411 427 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 412 428 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 455 473 , error1, error2 456 474 #endif 457 475 ); 458 - rseq_workaround_gcc_asm_size_guess(); 459 476 return 0; 460 477 abort: 461 - rseq_workaround_gcc_asm_size_guess(); 462 478 RSEQ_INJECT_FAILED 463 479 return -1; 464 480 cmpfail: 465 - rseq_workaround_gcc_asm_size_guess(); 466 481 return 1; 467 482 #ifdef RSEQ_COMPARE_TWICE 468 483 error1: ··· 476 497 { 477 498 RSEQ_INJECT_C(9) 478 499 479 - rseq_workaround_gcc_asm_size_guess(); 480 500 __asm__ __volatile__ goto ( 481 501 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 482 502 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 527 549 , error1, error2, error3 528 550 #endif 529 551 ); 530 - rseq_workaround_gcc_asm_size_guess(); 531 552 return 0; 532 553 abort: 533 - rseq_workaround_gcc_asm_size_guess(); 534 554 RSEQ_INJECT_FAILED 535 555 return -1; 536 556 cmpfail: 537 - rseq_workaround_gcc_asm_size_guess(); 538 557 return 1; 539 558 #ifdef RSEQ_COMPARE_TWICE 540 559 error1: ··· 552 577 553 578 RSEQ_INJECT_C(9) 554 579 555 - rseq_workaround_gcc_asm_size_guess(); 556 580 __asm__ __volatile__ goto ( 557 581 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 558 582 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 644 670 , error1, error2 645 671 #endif 646 672 ); 647 - rseq_workaround_gcc_asm_size_guess(); 648 673 return 0; 649 674 abort: 650 - rseq_workaround_gcc_asm_size_guess(); 651 675 RSEQ_INJECT_FAILED 652 676 return -1; 653 677 cmpfail: 654 - rseq_workaround_gcc_asm_size_guess(); 655 678 return 1; 656 679 #ifdef RSEQ_COMPARE_TWICE 657 680 error1: 658 - rseq_workaround_gcc_asm_size_guess(); 659 681 rseq_bug("cpu_id comparison failed"); 660 682 error2: 661 - rseq_workaround_gcc_asm_size_guess(); 662 683 rseq_bug("expected value comparison failed"); 663 684 #endif 664 685 } ··· 667 698 668 699 RSEQ_INJECT_C(9) 669 700 670 - rseq_workaround_gcc_asm_size_guess(); 671 701 __asm__ __volatile__ goto ( 672 702 RSEQ_ASM_DEFINE_TABLE(9, 1f, 2f, 4f) /* start, commit, abort */ 673 703 RSEQ_ASM_DEFINE_EXIT_POINT(1f, %l[cmpfail]) ··· 760 792 , error1, error2 761 793 #endif 762 794 ); 763 - rseq_workaround_gcc_asm_size_guess(); 764 795 return 0; 765 796 abort: 766 - rseq_workaround_gcc_asm_size_guess(); 767 797 RSEQ_INJECT_FAILED 768 798 return -1; 769 799 cmpfail: 770 - rseq_workaround_gcc_asm_size_guess(); 771 800 return 1; 772 801 #ifdef RSEQ_COMPARE_TWICE 773 802 error1: 774 - rseq_workaround_gcc_asm_size_guess(); 775 803 rseq_bug("cpu_id comparison failed"); 776 804 error2: 777 - rseq_workaround_gcc_asm_size_guess(); 778 805 rseq_bug("expected value comparison failed"); 779 806 #endif 780 807 }