FILE
signal.c
File preview with syntax highlighting.
linux-6.19.14/arch/loongarch/kernel/signal.c
1// SPDX-License-Identifier: GPL-2.0+ 2/* 3 * Author: Hanlu Li <lihanlu@loongson.cn> 4 * Huacai Chen <chenhuacai@loongson.cn> 5 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited 6 * 7 * Derived from MIPS: 8 * Copyright (C) 1991, 1992 Linus Torvalds 9 * Copyright (C) 1994 - 2000 Ralf Baechle 10 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 11 * Copyright (C) 2014, Imagination Technologies Ltd. 12 */ 13#include <linux/audit.h> 14#include <linux/cache.h> 15#include <linux/context_tracking.h> 16#include <linux/entry-common.h> 17#include <linux/irqflags.h> 18#include <linux/rseq.h> 19#include <linux/sched.h> 20#include <linux/mm.h> 21#include <linux/personality.h> 22#include <linux/smp.h> 23#include <linux/kernel.h> 24#include <linux/signal.h> 25#include <linux/errno.h> 26#include <linux/wait.h> 27#include <linux/ptrace.h> 28#include <linux/unistd.h> 29#include <linux/compiler.h> 30#include <linux/syscalls.h> 31#include <linux/uaccess.h> 32 33#include <asm/asm.h> 34#include <asm/cacheflush.h> 35#include <asm/cpu-features.h> 36#include <asm/fpu.h> 37#include <asm/lbt.h> 38#include <asm/sigframe.h> 39#include <asm/ucontext.h> 40#include <asm/vdso.h> 41 42#ifdef DEBUG_SIG 43# define DEBUGP(fmt, args...) printk("%s: " fmt, __func__, ##args) 44#else 45# define DEBUGP(fmt, args...) 46#endif 47 48/* Make sure we will not lose FPU ownership */ 49#define lock_fpu_owner() ({ preempt_disable(); pagefault_disable(); }) 50#define unlock_fpu_owner() ({ pagefault_enable(); preempt_enable(); }) 51/* Make sure we will not lose LBT ownership */ 52#define lock_lbt_owner() ({ preempt_disable(); pagefault_disable(); }) 53#define unlock_lbt_owner() ({ pagefault_enable(); preempt_enable(); }) 54 55struct _ctx_layout { 56 struct sctx_info *addr; 57 unsigned int size; 58}; 59 60struct extctx_layout { 61 unsigned long size; 62 unsigned int flags; 63 struct _ctx_layout fpu; 64 struct _ctx_layout lsx; 65 struct _ctx_layout lasx; 66 struct _ctx_layout lbt; 67 struct _ctx_layout end; 68}; 69 70static void __user *get_ctx_through_ctxinfo(struct sctx_info *info) 71{ 72 return (void __user *)((char *)info + sizeof(struct sctx_info)); 73} 74 75/* 76 * Thread saved context copy to/from a signal context presumed to be on the 77 * user stack, and therefore accessed with appropriate macros from uaccess.h. 78 */ 79static int copy_fpu_to_sigcontext(struct fpu_context __user *ctx) 80{ 81 int i; 82 int err = 0; 83 uint64_t __user *regs = (uint64_t *)&ctx->regs; 84 uint64_t __user *fcc = &ctx->fcc; 85 uint32_t __user *fcsr = &ctx->fcsr; 86 87 for (i = 0; i < NUM_FPU_REGS; i++) { 88 err |= 89 __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0), 90 ®s[i]); 91 } 92 err |= __put_user(current->thread.fpu.fcc, fcc); 93 err |= __put_user(current->thread.fpu.fcsr, fcsr); 94 95 return err; 96} 97 98static int copy_fpu_from_sigcontext(struct fpu_context __user *ctx) 99{ 100 int i; 101 int err = 0; 102 u64 fpr_val; 103 uint64_t __user *regs = (uint64_t *)&ctx->regs; 104 uint64_t __user *fcc = &ctx->fcc; 105 uint32_t __user *fcsr = &ctx->fcsr; 106 107 for (i = 0; i < NUM_FPU_REGS; i++) { 108 err |= __get_user(fpr_val, ®s[i]); 109 set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val); 110 } 111 err |= __get_user(current->thread.fpu.fcc, fcc); 112 err |= __get_user(current->thread.fpu.fcsr, fcsr); 113 114 return err; 115} 116 117static int copy_lsx_to_sigcontext(struct lsx_context __user *ctx) 118{ 119 int i; 120 int err = 0; 121 uint64_t __user *regs = (uint64_t *)&ctx->regs; 122 uint64_t __user *fcc = &ctx->fcc; 123 uint32_t __user *fcsr = &ctx->fcsr; 124 125 for (i = 0; i < NUM_FPU_REGS; i++) { 126 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0), 127 ®s[2*i]); 128 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 1), 129 ®s[2*i+1]); 130 } 131 err |= __put_user(current->thread.fpu.fcc, fcc); 132 err |= __put_user(current->thread.fpu.fcsr, fcsr); 133 134 return err; 135} 136 137static int copy_lsx_from_sigcontext(struct lsx_context __user *ctx) 138{ 139 int i; 140 int err = 0; 141 u64 fpr_val; 142 uint64_t __user *regs = (uint64_t *)&ctx->regs; 143 uint64_t __user *fcc = &ctx->fcc; 144 uint32_t __user *fcsr = &ctx->fcsr; 145 146 for (i = 0; i < NUM_FPU_REGS; i++) { 147 err |= __get_user(fpr_val, ®s[2*i]); 148 set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val); 149 err |= __get_user(fpr_val, ®s[2*i+1]); 150 set_fpr64(¤t->thread.fpu.fpr[i], 1, fpr_val); 151 } 152 err |= __get_user(current->thread.fpu.fcc, fcc); 153 err |= __get_user(current->thread.fpu.fcsr, fcsr); 154 155 return err; 156} 157 158static int copy_lasx_to_sigcontext(struct lasx_context __user *ctx) 159{ 160 int i; 161 int err = 0; 162 uint64_t __user *regs = (uint64_t *)&ctx->regs; 163 uint64_t __user *fcc = &ctx->fcc; 164 uint32_t __user *fcsr = &ctx->fcsr; 165 166 for (i = 0; i < NUM_FPU_REGS; i++) { 167 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 0), 168 ®s[4*i]); 169 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 1), 170 ®s[4*i+1]); 171 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 2), 172 ®s[4*i+2]); 173 err |= __put_user(get_fpr64(¤t->thread.fpu.fpr[i], 3), 174 ®s[4*i+3]); 175 } 176 err |= __put_user(current->thread.fpu.fcc, fcc); 177 err |= __put_user(current->thread.fpu.fcsr, fcsr); 178 179 return err; 180} 181 182static int copy_lasx_from_sigcontext(struct lasx_context __user *ctx) 183{ 184 int i; 185 int err = 0; 186 u64 fpr_val; 187 uint64_t __user *regs = (uint64_t *)&ctx->regs; 188 uint64_t __user *fcc = &ctx->fcc; 189 uint32_t __user *fcsr = &ctx->fcsr; 190 191 for (i = 0; i < NUM_FPU_REGS; i++) { 192 err |= __get_user(fpr_val, ®s[4*i]); 193 set_fpr64(¤t->thread.fpu.fpr[i], 0, fpr_val); 194 err |= __get_user(fpr_val, ®s[4*i+1]); 195 set_fpr64(¤t->thread.fpu.fpr[i], 1, fpr_val); 196 err |= __get_user(fpr_val, ®s[4*i+2]); 197 set_fpr64(¤t->thread.fpu.fpr[i], 2, fpr_val); 198 err |= __get_user(fpr_val, ®s[4*i+3]); 199 set_fpr64(¤t->thread.fpu.fpr[i], 3, fpr_val); 200 } 201 err |= __get_user(current->thread.fpu.fcc, fcc); 202 err |= __get_user(current->thread.fpu.fcsr, fcsr); 203 204 return err; 205} 206 207#ifdef CONFIG_CPU_HAS_LBT 208static int copy_lbt_to_sigcontext(struct lbt_context __user *ctx) 209{ 210 int err = 0; 211 uint64_t __user *regs = (uint64_t *)&ctx->regs; 212 uint32_t __user *eflags = (uint32_t *)&ctx->eflags; 213 214 err |= __put_user(current->thread.lbt.scr0, ®s[0]); 215 err |= __put_user(current->thread.lbt.scr1, ®s[1]); 216 err |= __put_user(current->thread.lbt.scr2, ®s[2]); 217 err |= __put_user(current->thread.lbt.scr3, ®s[3]); 218 err |= __put_user(current->thread.lbt.eflags, eflags); 219 220 return err; 221} 222 223static int copy_lbt_from_sigcontext(struct lbt_context __user *ctx) 224{ 225 int err = 0; 226 uint64_t __user *regs = (uint64_t *)&ctx->regs; 227 uint32_t __user *eflags = (uint32_t *)&ctx->eflags; 228 229 err |= __get_user(current->thread.lbt.scr0, ®s[0]); 230 err |= __get_user(current->thread.lbt.scr1, ®s[1]); 231 err |= __get_user(current->thread.lbt.scr2, ®s[2]); 232 err |= __get_user(current->thread.lbt.scr3, ®s[3]); 233 err |= __get_user(current->thread.lbt.eflags, eflags); 234 235 return err; 236} 237 238static int copy_ftop_to_sigcontext(struct lbt_context __user *ctx) 239{ 240 uint32_t __user *ftop = &ctx->ftop; 241 242 return __put_user(current->thread.fpu.ftop, ftop); 243} 244 245static int copy_ftop_from_sigcontext(struct lbt_context __user *ctx) 246{ 247 uint32_t __user *ftop = &ctx->ftop; 248 249 return __get_user(current->thread.fpu.ftop, ftop); 250} 251#endif 252 253/* 254 * Wrappers for the assembly _{save,restore}_fp_context functions. 255 */ 256static int save_hw_fpu_context(struct fpu_context __user *ctx) 257{ 258 uint64_t __user *regs = (uint64_t *)&ctx->regs; 259 uint64_t __user *fcc = &ctx->fcc; 260 uint32_t __user *fcsr = &ctx->fcsr; 261 262 return _save_fp_context(regs, fcc, fcsr); 263} 264 265static int restore_hw_fpu_context(struct fpu_context __user *ctx) 266{ 267 uint64_t __user *regs = (uint64_t *)&ctx->regs; 268 uint64_t __user *fcc = &ctx->fcc; 269 uint32_t __user *fcsr = &ctx->fcsr; 270 271 return _restore_fp_context(regs, fcc, fcsr); 272} 273 274static int save_hw_lsx_context(struct lsx_context __user *ctx) 275{ 276 uint64_t __user *regs = (uint64_t *)&ctx->regs; 277 uint64_t __user *fcc = &ctx->fcc; 278 uint32_t __user *fcsr = &ctx->fcsr; 279 280 return _save_lsx_context(regs, fcc, fcsr); 281} 282 283static int restore_hw_lsx_context(struct lsx_context __user *ctx) 284{ 285 uint64_t __user *regs = (uint64_t *)&ctx->regs; 286 uint64_t __user *fcc = &ctx->fcc; 287 uint32_t __user *fcsr = &ctx->fcsr; 288 289 return _restore_lsx_context(regs, fcc, fcsr); 290} 291 292static int save_hw_lasx_context(struct lasx_context __user *ctx) 293{ 294 uint64_t __user *regs = (uint64_t *)&ctx->regs; 295 uint64_t __user *fcc = &ctx->fcc; 296 uint32_t __user *fcsr = &ctx->fcsr; 297 298 return _save_lasx_context(regs, fcc, fcsr); 299} 300 301static int restore_hw_lasx_context(struct lasx_context __user *ctx) 302{ 303 uint64_t __user *regs = (uint64_t *)&ctx->regs; 304 uint64_t __user *fcc = &ctx->fcc; 305 uint32_t __user *fcsr = &ctx->fcsr; 306 307 return _restore_lasx_context(regs, fcc, fcsr); 308} 309 310/* 311 * Wrappers for the assembly _{save,restore}_lbt_context functions. 312 */ 313#ifdef CONFIG_CPU_HAS_LBT 314static int save_hw_lbt_context(struct lbt_context __user *ctx) 315{ 316 uint64_t __user *regs = (uint64_t *)&ctx->regs; 317 uint32_t __user *eflags = (uint32_t *)&ctx->eflags; 318 319 return _save_lbt_context(regs, eflags); 320} 321 322static int restore_hw_lbt_context(struct lbt_context __user *ctx) 323{ 324 uint64_t __user *regs = (uint64_t *)&ctx->regs; 325 uint32_t __user *eflags = (uint32_t *)&ctx->eflags; 326 327 return _restore_lbt_context(regs, eflags); 328} 329 330static int save_hw_ftop_context(struct lbt_context __user *ctx) 331{ 332 uint32_t __user *ftop = &ctx->ftop; 333 334 return _save_ftop_context(ftop); 335} 336 337static int restore_hw_ftop_context(struct lbt_context __user *ctx) 338{ 339 uint32_t __user *ftop = &ctx->ftop; 340 341 return _restore_ftop_context(ftop); 342} 343#endif 344 345static int fcsr_pending(unsigned int __user *fcsr) 346{ 347 int err, sig = 0; 348 unsigned int csr, enabled; 349 350 err = __get_user(csr, fcsr); 351 enabled = ((csr & FPU_CSR_ALL_E) << 24); 352 /* 353 * If the signal handler set some FPU exceptions, clear it and 354 * send SIGFPE. 355 */ 356 if (csr & enabled) { 357 csr &= ~enabled; 358 err |= __put_user(csr, fcsr); 359 sig = SIGFPE; 360 } 361 return err ?: sig; 362} 363 364/* 365 * Helper routines 366 */ 367static int protected_save_fpu_context(struct extctx_layout *extctx) 368{ 369 int err = 0; 370 struct sctx_info __user *info = extctx->fpu.addr; 371 struct fpu_context __user *fpu_ctx = (struct fpu_context *)get_ctx_through_ctxinfo(info); 372 uint64_t __user *regs = (uint64_t *)&fpu_ctx->regs; 373 uint64_t __user *fcc = &fpu_ctx->fcc; 374 uint32_t __user *fcsr = &fpu_ctx->fcsr; 375 376 while (1) { 377 lock_fpu_owner(); 378 if (is_fpu_owner()) 379 err = save_hw_fpu_context(fpu_ctx); 380 else 381 err = copy_fpu_to_sigcontext(fpu_ctx); 382 unlock_fpu_owner(); 383 384 err |= __put_user(FPU_CTX_MAGIC, &info->magic); 385 err |= __put_user(extctx->fpu.size, &info->size); 386 387 if (likely(!err)) 388 break; 389 /* Touch the FPU context and try again */ 390 err = __put_user(0, ®s[0]) | 391 __put_user(0, ®s[31]) | 392 __put_user(0, fcc) | 393 __put_user(0, fcsr); 394 if (err) 395 return err; /* really bad sigcontext */ 396 } 397 398 return err; 399} 400 401static int protected_restore_fpu_context(struct extctx_layout *extctx) 402{ 403 int err = 0, sig = 0, tmp __maybe_unused; 404 struct sctx_info __user *info = extctx->fpu.addr; 405 struct fpu_context __user *fpu_ctx = (struct fpu_context *)get_ctx_through_ctxinfo(info); 406 uint64_t __user *regs = (uint64_t *)&fpu_ctx->regs; 407 uint64_t __user *fcc = &fpu_ctx->fcc; 408 uint32_t __user *fcsr = &fpu_ctx->fcsr; 409 410 err = sig = fcsr_pending(fcsr); 411 if (err < 0) 412 return err; 413 414 while (1) { 415 lock_fpu_owner(); 416 if (is_fpu_owner()) 417 err = restore_hw_fpu_context(fpu_ctx); 418 else 419 err = copy_fpu_from_sigcontext(fpu_ctx); 420 unlock_fpu_owner(); 421 422 if (likely(!err)) 423 break; 424 /* Touch the FPU context and try again */ 425 err = __get_user(tmp, ®s[0]) | 426 __get_user(tmp, ®s[31]) | 427 __get_user(tmp, fcc) | 428 __get_user(tmp, fcsr); 429 if (err) 430 break; /* really bad sigcontext */ 431 } 432 433 return err ?: sig; 434} 435 436static int protected_save_lsx_context(struct extctx_layout *extctx) 437{ 438 int err = 0; 439 struct sctx_info __user *info = extctx->lsx.addr; 440 struct lsx_context __user *lsx_ctx = (struct lsx_context *)get_ctx_through_ctxinfo(info); 441 uint64_t __user *regs = (uint64_t *)&lsx_ctx->regs; 442 uint64_t __user *fcc = &lsx_ctx->fcc; 443 uint32_t __user *fcsr = &lsx_ctx->fcsr; 444 445 while (1) { 446 lock_fpu_owner(); 447 if (is_lsx_enabled()) 448 err = save_hw_lsx_context(lsx_ctx); 449 else { 450 if (is_fpu_owner()) 451 save_fp(current); 452 err = copy_lsx_to_sigcontext(lsx_ctx); 453 } 454 unlock_fpu_owner(); 455 456 err |= __put_user(LSX_CTX_MAGIC, &info->magic); 457 err |= __put_user(extctx->lsx.size, &info->size); 458 459 if (likely(!err)) 460 break; 461 /* Touch the LSX context and try again */ 462 err = __put_user(0, ®s[0]) | 463 __put_user(0, ®s[32*2-1]) | 464 __put_user(0, fcc) | 465 __put_user(0, fcsr); 466 if (err) 467 return err; /* really bad sigcontext */ 468 } 469 470 return err; 471} 472 473static int protected_restore_lsx_context(struct extctx_layout *extctx) 474{ 475 int err = 0, sig = 0, tmp __maybe_unused; 476 struct sctx_info __user *info = extctx->lsx.addr; 477 struct lsx_context __user *lsx_ctx = (struct lsx_context *)get_ctx_through_ctxinfo(info); 478 uint64_t __user *regs = (uint64_t *)&lsx_ctx->regs; 479 uint64_t __user *fcc = &lsx_ctx->fcc; 480 uint32_t __user *fcsr = &lsx_ctx->fcsr; 481 482 err = sig = fcsr_pending(fcsr); 483 if (err < 0) 484 return err; 485 486 while (1) { 487 lock_fpu_owner(); 488 if (is_lsx_enabled()) 489 err = restore_hw_lsx_context(lsx_ctx); 490 else { 491 err = copy_lsx_from_sigcontext(lsx_ctx); 492 if (is_fpu_owner()) 493 restore_fp(current); 494 } 495 unlock_fpu_owner(); 496 497 if (likely(!err)) 498 break; 499 /* Touch the LSX context and try again */ 500 err = __get_user(tmp, ®s[0]) | 501 __get_user(tmp, ®s[32*2-1]) | 502 __get_user(tmp, fcc) | 503 __get_user(tmp, fcsr); 504 if (err) 505 break; /* really bad sigcontext */ 506 } 507 508 return err ?: sig; 509} 510 511static int protected_save_lasx_context(struct extctx_layout *extctx) 512{ 513 int err = 0; 514 struct sctx_info __user *info = extctx->lasx.addr; 515 struct lasx_context __user *lasx_ctx = 516 (struct lasx_context *)get_ctx_through_ctxinfo(info); 517 uint64_t __user *regs = (uint64_t *)&lasx_ctx->regs; 518 uint64_t __user *fcc = &lasx_ctx->fcc; 519 uint32_t __user *fcsr = &lasx_ctx->fcsr; 520 521 while (1) { 522 lock_fpu_owner(); 523 if (is_lasx_enabled()) 524 err = save_hw_lasx_context(lasx_ctx); 525 else { 526 if (is_lsx_enabled()) 527 save_lsx(current); 528 else if (is_fpu_owner()) 529 save_fp(current); 530 err = copy_lasx_to_sigcontext(lasx_ctx); 531 } 532 unlock_fpu_owner(); 533 534 err |= __put_user(LASX_CTX_MAGIC, &info->magic); 535 err |= __put_user(extctx->lasx.size, &info->size); 536 537 if (likely(!err)) 538 break; 539 /* Touch the LASX context and try again */ 540 err = __put_user(0, ®s[0]) | 541 __put_user(0, ®s[32*4-1]) | 542 __put_user(0, fcc) | 543 __put_user(0, fcsr); 544 if (err) 545 return err; /* really bad sigcontext */ 546 } 547 548 return err; 549} 550 551static int protected_restore_lasx_context(struct extctx_layout *extctx) 552{ 553 int err = 0, sig = 0, tmp __maybe_unused; 554 struct sctx_info __user *info = extctx->lasx.addr; 555 struct lasx_context __user *lasx_ctx = 556 (struct lasx_context *)get_ctx_through_ctxinfo(info); 557 uint64_t __user *regs = (uint64_t *)&lasx_ctx->regs; 558 uint64_t __user *fcc = &lasx_ctx->fcc; 559 uint32_t __user *fcsr = &lasx_ctx->fcsr; 560 561 err = sig = fcsr_pending(fcsr); 562 if (err < 0) 563 return err; 564 565 while (1) { 566 lock_fpu_owner(); 567 if (is_lasx_enabled()) 568 err = restore_hw_lasx_context(lasx_ctx); 569 else { 570 err = copy_lasx_from_sigcontext(lasx_ctx); 571 if (is_lsx_enabled()) 572 restore_lsx(current); 573 else if (is_fpu_owner()) 574 restore_fp(current); 575 } 576 unlock_fpu_owner(); 577 578 if (likely(!err)) 579 break; 580 /* Touch the LASX context and try again */ 581 err = __get_user(tmp, ®s[0]) | 582 __get_user(tmp, ®s[32*4-1]) | 583 __get_user(tmp, fcc) | 584 __get_user(tmp, fcsr); 585 if (err) 586 break; /* really bad sigcontext */ 587 } 588 589 return err ?: sig; 590} 591 592#ifdef CONFIG_CPU_HAS_LBT 593static int protected_save_lbt_context(struct extctx_layout *extctx) 594{ 595 int err = 0; 596 struct sctx_info __user *info = extctx->lbt.addr; 597 struct lbt_context __user *lbt_ctx = 598 (struct lbt_context *)get_ctx_through_ctxinfo(info); 599 uint64_t __user *regs = (uint64_t *)&lbt_ctx->regs; 600 uint32_t __user *eflags = (uint32_t *)&lbt_ctx->eflags; 601 602 while (1) { 603 lock_lbt_owner(); 604 if (is_lbt_owner()) 605 err |= save_hw_lbt_context(lbt_ctx); 606 else 607 err |= copy_lbt_to_sigcontext(lbt_ctx); 608 if (is_fpu_owner()) 609 err |= save_hw_ftop_context(lbt_ctx); 610 else 611 err |= copy_ftop_to_sigcontext(lbt_ctx); 612 unlock_lbt_owner(); 613 614 err |= __put_user(LBT_CTX_MAGIC, &info->magic); 615 err |= __put_user(extctx->lbt.size, &info->size); 616 617 if (likely(!err)) 618 break; 619 /* Touch the LBT context and try again */ 620 err = __put_user(0, ®s[0]) | __put_user(0, eflags); 621 622 if (err) 623 return err; 624 } 625 626 return err; 627} 628 629static int protected_restore_lbt_context(struct extctx_layout *extctx) 630{ 631 int err = 0, tmp __maybe_unused; 632 struct sctx_info __user *info = extctx->lbt.addr; 633 struct lbt_context __user *lbt_ctx = 634 (struct lbt_context *)get_ctx_through_ctxinfo(info); 635 uint64_t __user *regs = (uint64_t *)&lbt_ctx->regs; 636 uint32_t __user *eflags = (uint32_t *)&lbt_ctx->eflags; 637 638 while (1) { 639 lock_lbt_owner(); 640 if (is_lbt_owner()) 641 err |= restore_hw_lbt_context(lbt_ctx); 642 else 643 err |= copy_lbt_from_sigcontext(lbt_ctx); 644 if (is_fpu_owner()) 645 err |= restore_hw_ftop_context(lbt_ctx); 646 else 647 err |= copy_ftop_from_sigcontext(lbt_ctx); 648 unlock_lbt_owner(); 649 650 if (likely(!err)) 651 break; 652 /* Touch the LBT context and try again */ 653 err = __get_user(tmp, ®s[0]) | __get_user(tmp, eflags); 654 655 if (err) 656 return err; 657 } 658 659 return err; 660} 661#endif 662 663static int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, 664 struct extctx_layout *extctx) 665{ 666 int i, err = 0; 667 struct sctx_info __user *info; 668 669 err |= __put_user(regs->csr_era, &sc->sc_pc); 670 err |= __put_user(extctx->flags, &sc->sc_flags); 671 672 err |= __put_user(0, &sc->sc_regs[0]); 673 for (i = 1; i < 32; i++) 674 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 675 676#ifdef CONFIG_CPU_HAS_LBT 677 if (extctx->lbt.addr) 678 err |= protected_save_lbt_context(extctx); 679#endif 680 681 if (extctx->lasx.addr) 682 err |= protected_save_lasx_context(extctx); 683 else if (extctx->lsx.addr) 684 err |= protected_save_lsx_context(extctx); 685 else if (extctx->fpu.addr) 686 err |= protected_save_fpu_context(extctx); 687 688 /* Set the "end" magic */ 689 info = (struct sctx_info *)extctx->end.addr; 690 err |= __put_user(0, &info->magic); 691 err |= __put_user(0, &info->size); 692 693 return err; 694} 695 696static int parse_extcontext(struct sigcontext __user *sc, struct extctx_layout *extctx) 697{ 698 int err = 0; 699 unsigned int magic, size; 700 struct sctx_info __user *info = (struct sctx_info __user *)&sc->sc_extcontext; 701 702 while(1) { 703 err |= __get_user(magic, &info->magic); 704 err |= __get_user(size, &info->size); 705 if (err) 706 return err; 707 708 switch (magic) { 709 case 0: /* END */ 710 goto done; 711 712 case FPU_CTX_MAGIC: 713 if (size < (sizeof(struct sctx_info) + 714 sizeof(struct fpu_context))) 715 goto invalid; 716 extctx->fpu.addr = info; 717 break; 718 719 case LSX_CTX_MAGIC: 720 if (size < (sizeof(struct sctx_info) + 721 sizeof(struct lsx_context))) 722 goto invalid; 723 extctx->lsx.addr = info; 724 break; 725 726 case LASX_CTX_MAGIC: 727 if (size < (sizeof(struct sctx_info) + 728 sizeof(struct lasx_context))) 729 goto invalid; 730 extctx->lasx.addr = info; 731 break; 732 733 case LBT_CTX_MAGIC: 734 if (size < (sizeof(struct sctx_info) + 735 sizeof(struct lbt_context))) 736 goto invalid; 737 extctx->lbt.addr = info; 738 break; 739 740 default: 741 goto invalid; 742 } 743 744 info = (struct sctx_info *)((char *)info + size); 745 } 746 747done: 748 return 0; 749 750invalid: 751 return -EINVAL; 752} 753 754static int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) 755{ 756 int i, err = 0; 757 struct extctx_layout extctx; 758 759 memset(&extctx, 0, sizeof(struct extctx_layout)); 760 761 err = __get_user(extctx.flags, &sc->sc_flags); 762 if (err) 763 goto bad; 764 765 err = parse_extcontext(sc, &extctx); 766 if (err) 767 goto bad; 768 769 conditional_used_math(extctx.flags & SC_USED_FP); 770 771 /* 772 * The signal handler may have used FPU; give it up if the program 773 * doesn't want it following sigreturn. 774 */ 775 if (!(extctx.flags & SC_USED_FP)) 776 lose_fpu(0); 777 778 /* Always make any pending restarted system calls return -EINTR */ 779 current->restart_block.fn = do_no_restart_syscall; 780 781 err |= __get_user(regs->csr_era, &sc->sc_pc); 782 for (i = 1; i < 32; i++) 783 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 784 785 if (extctx.lasx.addr) 786 err |= protected_restore_lasx_context(&extctx); 787 else if (extctx.lsx.addr) 788 err |= protected_restore_lsx_context(&extctx); 789 else if (extctx.fpu.addr) 790 err |= protected_restore_fpu_context(&extctx); 791 792#ifdef CONFIG_CPU_HAS_LBT 793 if (extctx.lbt.addr) 794 err |= protected_restore_lbt_context(&extctx); 795#endif 796 797bad: 798 return err; 799} 800 801static unsigned int handle_flags(void) 802{ 803 unsigned int flags = 0; 804 805 flags = used_math() ? SC_USED_FP : 0; 806 807 switch (current->thread.error_code) { 808 case 1: 809 flags |= SC_ADDRERR_RD; 810 break; 811 case 2: 812 flags |= SC_ADDRERR_WR; 813 break; 814 } 815 816 return flags; 817} 818 819static unsigned long extframe_alloc(struct extctx_layout *extctx, 820 struct _ctx_layout *layout, 821 size_t size, unsigned int align, unsigned long base) 822{ 823 unsigned long new_base = base - size; 824 825 new_base = round_down(new_base, (align < 16 ? 16 : align)); 826 new_base -= sizeof(struct sctx_info); 827 828 layout->addr = (void *)new_base; 829 layout->size = (unsigned int)(base - new_base); 830 extctx->size += layout->size; 831 832 return new_base; 833} 834 835static unsigned long setup_extcontext(struct extctx_layout *extctx, unsigned long sp) 836{ 837 unsigned long new_sp = sp; 838 839 memset(extctx, 0, sizeof(struct extctx_layout)); 840 841 extctx->flags = handle_flags(); 842 843 /* Grow down, alloc "end" context info first. */ 844 new_sp -= sizeof(struct sctx_info); 845 extctx->end.addr = (void *)new_sp; 846 extctx->end.size = (unsigned int)sizeof(struct sctx_info); 847 extctx->size += extctx->end.size; 848 849 if (extctx->flags & SC_USED_FP) { 850 if (cpu_has_lasx && thread_lasx_context_live()) 851 new_sp = extframe_alloc(extctx, &extctx->lasx, 852 sizeof(struct lasx_context), LASX_CTX_ALIGN, new_sp); 853 else if (cpu_has_lsx && thread_lsx_context_live()) 854 new_sp = extframe_alloc(extctx, &extctx->lsx, 855 sizeof(struct lsx_context), LSX_CTX_ALIGN, new_sp); 856 else if (cpu_has_fpu) 857 new_sp = extframe_alloc(extctx, &extctx->fpu, 858 sizeof(struct fpu_context), FPU_CTX_ALIGN, new_sp); 859 } 860 861#ifdef CONFIG_CPU_HAS_LBT 862 if (cpu_has_lbt && thread_lbt_context_live()) { 863 new_sp = extframe_alloc(extctx, &extctx->lbt, 864 sizeof(struct lbt_context), LBT_CTX_ALIGN, new_sp); 865 } 866#endif 867 868 return new_sp; 869} 870 871static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, 872 struct extctx_layout *extctx) 873{ 874 unsigned long sp; 875 876 /* Default to using normal stack */ 877 sp = regs->regs[3]; 878 879 /* 880 * If we are on the alternate signal stack and would overflow it, don't. 881 * Return an always-bogus address instead so we will die with SIGSEGV. 882 */ 883 if (on_sig_stack(sp) && 884 !likely(on_sig_stack(sp - sizeof(struct rt_sigframe)))) 885 return (void __user __force *)(-1UL); 886 887 sp = sigsp(sp, ksig); 888 sp = round_down(sp, 16); 889 sp = setup_extcontext(extctx, sp); 890 sp -= sizeof(struct rt_sigframe); 891 892 if (!IS_ALIGNED(sp, 16)) 893 BUG(); 894 895 return (void __user *)sp; 896} 897 898/* 899 * Atomically swap in the new signal mask, and wait for a signal. 900 */ 901 902SYSCALL_DEFINE0(rt_sigreturn) 903{ 904 int sig; 905 sigset_t set; 906 struct pt_regs *regs; 907 struct rt_sigframe __user *frame; 908 909 regs = current_pt_regs(); 910 frame = (struct rt_sigframe __user *)regs->regs[3]; 911 if (!access_ok(frame, sizeof(*frame))) 912 goto badframe; 913 if (__copy_from_user(&set, &frame->rs_uctx.uc_sigmask, sizeof(set))) 914 goto badframe; 915 916 set_current_blocked(&set); 917 918 sig = restore_sigcontext(regs, &frame->rs_uctx.uc_mcontext); 919 if (sig < 0) 920 goto badframe; 921 else if (sig) 922 force_sig(sig); 923 924 regs->regs[0] = 0; /* No syscall restarting */ 925 if (restore_altstack(&frame->rs_uctx.uc_stack)) 926 goto badframe; 927 928 return regs->regs[4]; 929 930badframe: 931 force_sig(SIGSEGV); 932 return 0; 933} 934 935static int setup_rt_frame(void *sig_return, struct ksignal *ksig, 936 struct pt_regs *regs, sigset_t *set) 937{ 938 int err = 0; 939 struct extctx_layout extctx; 940 struct rt_sigframe __user *frame; 941 942 frame = get_sigframe(ksig, regs, &extctx); 943 if (!access_ok(frame, sizeof(*frame) + extctx.size)) 944 return -EFAULT; 945 946 /* Create siginfo. */ 947 err |= copy_siginfo_to_user(&frame->rs_info, &ksig->info); 948 949 /* Create the ucontext. */ 950 err |= __put_user(0, &frame->rs_uctx.uc_flags); 951 err |= __put_user(NULL, &frame->rs_uctx.uc_link); 952 err |= __save_altstack(&frame->rs_uctx.uc_stack, regs->regs[3]); 953 err |= setup_sigcontext(regs, &frame->rs_uctx.uc_mcontext, &extctx); 954 err |= __copy_to_user(&frame->rs_uctx.uc_sigmask, set, sizeof(*set)); 955 956 if (err) 957 return -EFAULT; 958 959 /* 960 * Arguments to signal handler: 961 * 962 * a0 = signal number 963 * a1 = pointer to siginfo 964 * a2 = pointer to ucontext 965 * 966 * c0_era point to the signal handler, $r3 (sp) points to 967 * the struct rt_sigframe. 968 */ 969 regs->regs[4] = ksig->sig; 970 regs->regs[5] = (unsigned long) &frame->rs_info; 971 regs->regs[6] = (unsigned long) &frame->rs_uctx; 972 regs->regs[3] = (unsigned long) frame; 973 regs->regs[1] = (unsigned long) sig_return; 974 regs->csr_era = (unsigned long) ksig->ka.sa.sa_handler; 975 976 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 977 current->comm, current->pid, 978 frame, regs->csr_era, regs->regs[1]); 979 980 return 0; 981} 982 983static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) 984{ 985 int ret; 986 sigset_t *oldset = sigmask_to_save(); 987 void *vdso = current->mm->context.vdso; 988 989 /* Are we from a system call? */ 990 if (regs->regs[0]) { 991 switch (regs->regs[4]) { 992 case -ERESTART_RESTARTBLOCK: 993 case -ERESTARTNOHAND: 994 regs->regs[4] = -EINTR; 995 break; 996 case -ERESTARTSYS: 997 if (!(ksig->ka.sa.sa_flags & SA_RESTART)) { 998 regs->regs[4] = -EINTR; 999 break; 1000 } 1001 fallthrough; 1002 case -ERESTARTNOINTR: 1003 regs->regs[4] = regs->orig_a0; 1004 regs->csr_era -= 4; 1005 } 1006 1007 regs->regs[0] = 0; /* Don't deal with this again. */ 1008 } 1009 1010 rseq_signal_deliver(ksig, regs); 1011 1012 ret = setup_rt_frame(vdso + current->thread.vdso->offset_sigreturn, ksig, regs, oldset); 1013 1014 signal_setup_done(ret, ksig, 0); 1015} 1016 1017void arch_do_signal_or_restart(struct pt_regs *regs) 1018{ 1019 struct ksignal ksig; 1020 1021 if (get_signal(&ksig)) { 1022 /* Whee! Actually deliver the signal. */ 1023 handle_signal(&ksig, regs); 1024 return; 1025 } 1026 1027 /* Are we from a system call? */ 1028 if (regs->regs[0]) { 1029 switch (regs->regs[4]) { 1030 case -ERESTARTNOHAND: 1031 case -ERESTARTSYS: 1032 case -ERESTARTNOINTR: 1033 regs->regs[4] = regs->orig_a0; 1034 regs->csr_era -= 4; 1035 break; 1036 1037 case -ERESTART_RESTARTBLOCK: 1038 regs->regs[4] = regs->orig_a0; 1039 regs->regs[11] = __NR_restart_syscall; 1040 regs->csr_era -= 4; 1041 break; 1042 } 1043 regs->regs[0] = 0; /* Don't deal with this again. */ 1044 } 1045 1046 /* 1047 * If there's no signal to deliver, we just put the saved sigmask 1048 * back 1049 */ 1050 restore_saved_sigmask(); 1051}
~/
Read-only file preview.