arch/alpha/kernel/entry.S

   1 /*
   2  * arch/alpha/kernel/entry.S
   3  *
   4  * Kernel entry-points.
   5  */
   6
   7 #include <linux/config.h>
   8 #include <asm/asm-offsets.h>
   9 #include <asm/thread_info.h>
  10 #include <asm/pal.h>
  11 #include <asm/errno.h>
  12 #include <asm/unistd.h>
  13
  14         .text
  15         .set noat
  16
  17 /* Stack offsets.  */
  18 #define SP_OFF                  184
  19 #define SWITCH_STACK_SIZE       320
  20
  21 /*
  22  * This defines the normal kernel pt-regs layout.
  23  *
  24  * regs 9-15 preserved by C code
  25  * regs 16-18 saved by PAL-code
  26  * regs 29-30 saved and set up by PAL-code
  27  * JRP - Save regs 16-18 in a special area of the stack, so that
  28  * the palcode-provided values are available to the signal handler.
  29  */
  30
  31 #define SAVE_ALL                        \
  32         subq    $sp, SP_OFF, $sp;       \
  33         stq     $0, 0($sp);             \
  34         stq     $1, 8($sp);             \
  35         stq     $2, 16($sp);            \
  36         stq     $3, 24($sp);            \
  37         stq     $4, 32($sp);            \
  38         stq     $28, 144($sp);          \
  39         lda     $2, alpha_mv;           \
  40         stq     $5, 40($sp);            \
  41         stq     $6, 48($sp);            \
  42         stq     $7, 56($sp);            \
  43         stq     $8, 64($sp);            \
  44         stq     $19, 72($sp);           \
  45         stq     $20, 80($sp);           \
  46         stq     $21, 88($sp);           \
  47         ldq     $2, HAE_CACHE($2);      \
  48         stq     $22, 96($sp);           \
  49         stq     $23, 104($sp);          \
  50         stq     $24, 112($sp);          \
  51         stq     $25, 120($sp);          \
  52         stq     $26, 128($sp);          \
  53         stq     $27, 136($sp);          \
  54         stq     $2, 152($sp);           \
  55         stq     $16, 160($sp);          \
  56         stq     $17, 168($sp);          \
  57         stq     $18, 176($sp)
  58
  59 #define RESTORE_ALL                     \
  60         lda     $19, alpha_mv;          \
  61         ldq     $0, 0($sp);             \
  62         ldq     $1, 8($sp);             \
  63         ldq     $2, 16($sp);            \
  64         ldq     $3, 24($sp);            \
  65         ldq     $21, 152($sp);          \
  66         ldq     $20, HAE_CACHE($19);    \
  67         ldq     $4, 32($sp);            \
  68         ldq     $5, 40($sp);            \
  69         ldq     $6, 48($sp);            \
  70         ldq     $7, 56($sp);            \
  71         subq    $20, $21, $20;          \
  72         ldq     $8, 64($sp);            \
  73         beq     $20, 99f;               \
  74         ldq     $20, HAE_REG($19);      \
  75         stq     $21, HAE_CACHE($19);    \
  76         stq     $21, 0($20);            \
  77         ldq     $0, 0($sp);             \
  78         ldq     $1, 8($sp);             \
  79 99:;                                    \
  80         ldq     $19, 72($sp);           \
  81         ldq     $20, 80($sp);           \
  82         ldq     $21, 88($sp);           \
  83         ldq     $22, 96($sp);           \
  84         ldq     $23, 104($sp);          \
  85         ldq     $24, 112($sp);          \
  86         ldq     $25, 120($sp);          \
  87         ldq     $26, 128($sp);          \
  88         ldq     $27, 136($sp);          \
  89         ldq     $28, 144($sp);          \
  90         addq    $sp, SP_OFF, $sp
  91
  92 /*
  93  * Non-syscall kernel entry points.
  94  */
  95
  96         .align  4
  97         .globl  entInt
  98         .ent    entInt
  99 entInt:
 100         SAVE_ALL
 101         lda     $8, 0x3fff
 102         lda     $26, ret_from_sys_call
 103         bic     $sp, $8, $8
 104         mov     $sp, $19
 105         jsr     $31, do_entInt
 106 .end entInt
 107
 108         .align  4
 109         .globl  entArith
 110         .ent    entArith
 111 entArith:
 112         SAVE_ALL
 113         lda     $8, 0x3fff
 114         lda     $26, ret_from_sys_call
 115         bic     $sp, $8, $8
 116         mov     $sp, $18
 117         jsr     $31, do_entArith
 118 .end entArith
 119
 120         .align  4
 121         .globl  entMM
 122         .ent    entMM
 123 entMM:
 124         SAVE_ALL
 125 /* save $9 - $15 so the inline exception code can manipulate them.  */
 126         subq    $sp, 56, $sp
 127         stq     $9, 0($sp)
 128         stq     $10, 8($sp)
 129         stq     $11, 16($sp)
 130         stq     $12, 24($sp)
 131         stq     $13, 32($sp)
 132         stq     $14, 40($sp)
 133         stq     $15, 48($sp)
 134         addq    $sp, 56, $19
 135 /* handle the fault */
 136         lda     $8, 0x3fff
 137         bic     $sp, $8, $8
 138         jsr     $26, do_page_fault
 139 /* reload the registers after the exception code played.  */
 140         ldq     $9, 0($sp)
 141         ldq     $10, 8($sp)
 142         ldq     $11, 16($sp)
 143         ldq     $12, 24($sp)
 144         ldq     $13, 32($sp)
 145         ldq     $14, 40($sp)
 146         ldq     $15, 48($sp)
 147         addq    $sp, 56, $sp
 148 /* finish up the syscall as normal.  */
 149         br      ret_from_sys_call
 150 .end entMM
 151
 152         .align  4
 153         .globl  entIF
 154         .ent    entIF
 155 entIF:
 156         SAVE_ALL
 157         lda     $8, 0x3fff
 158         lda     $26, ret_from_sys_call
 159         bic     $sp, $8, $8
 160         mov     $sp, $17
 161         jsr     $31, do_entIF
 162 .end entIF
 163
 164         .align  4
 165         .globl  entUna
 166         .ent    entUna
 167 entUna:
 168         lda     $sp, -256($sp)
 169         stq     $0, 0($sp)
 170         ldq     $0, 256($sp)    /* get PS */
 171         stq     $1, 8($sp)
 172         stq     $2, 16($sp)
 173         stq     $3, 24($sp)
 174         and     $0, 8, $0               /* user mode? */
 175         stq     $4, 32($sp)
 176         bne     $0, entUnaUser  /* yup -> do user-level unaligned fault */
 177         stq     $5, 40($sp)
 178         stq     $6, 48($sp)
 179         stq     $7, 56($sp)
 180         stq     $8, 64($sp)
 181         stq     $9, 72($sp)
 182         stq     $10, 80($sp)
 183         stq     $11, 88($sp)
 184         stq     $12, 96($sp)
 185         stq     $13, 104($sp)
 186         stq     $14, 112($sp)
 187         stq     $15, 120($sp)
 188         /* 16-18 PAL-saved */
 189         stq     $19, 152($sp)
 190         stq     $20, 160($sp)
 191         stq     $21, 168($sp)
 192         stq     $22, 176($sp)
 193         stq     $23, 184($sp)
 194         stq     $24, 192($sp)
 195         stq     $25, 200($sp)
 196         stq     $26, 208($sp)
 197         stq     $27, 216($sp)
 198         stq     $28, 224($sp)
 199         mov     $sp, $19
 200         stq     $gp, 232($sp)
 201         lda     $8, 0x3fff
 202         stq     $31, 248($sp)
 203         bic     $sp, $8, $8
 204         jsr     $26, do_entUna
 205         ldq     $0, 0($sp)
 206         ldq     $1, 8($sp)
 207         ldq     $2, 16($sp)
 208         ldq     $3, 24($sp)
 209         ldq     $4, 32($sp)
 210         ldq     $5, 40($sp)
 211         ldq     $6, 48($sp)
 212         ldq     $7, 56($sp)
 213         ldq     $8, 64($sp)
 214         ldq     $9, 72($sp)
 215         ldq     $10, 80($sp)
 216         ldq     $11, 88($sp)
 217         ldq     $12, 96($sp)
 218         ldq     $13, 104($sp)
 219         ldq     $14, 112($sp)
 220         ldq     $15, 120($sp)
 221         /* 16-18 PAL-saved */
 222         ldq     $19, 152($sp)
 223         ldq     $20, 160($sp)
 224         ldq     $21, 168($sp)
 225         ldq     $22, 176($sp)
 226         ldq     $23, 184($sp)
 227         ldq     $24, 192($sp)
 228         ldq     $25, 200($sp)
 229         ldq     $26, 208($sp)
 230         ldq     $27, 216($sp)
 231         ldq     $28, 224($sp)
 232         ldq     $gp, 232($sp)
 233         lda     $sp, 256($sp)
 234         call_pal PAL_rti
 235 .end entUna
 236
 237         .align  4
 238         .ent    entUnaUser
 239 entUnaUser:
 240         ldq     $0, 0($sp)      /* restore original $0 */
 241         lda     $sp, 256($sp)   /* pop entUna's stack frame */
 242         SAVE_ALL                /* setup normal kernel stack */
 243         lda     $sp, -56($sp)
 244         stq     $9, 0($sp)
 245         stq     $10, 8($sp)
 246         stq     $11, 16($sp)
 247         stq     $12, 24($sp)
 248         stq     $13, 32($sp)
 249         stq     $14, 40($sp)
 250         stq     $15, 48($sp)
 251         lda     $8, 0x3fff
 252         addq    $sp, 56, $19
 253         bic     $sp, $8, $8
 254         jsr     $26, do_entUnaUser
 255         ldq     $9, 0($sp)
 256         ldq     $10, 8($sp)
 257         ldq     $11, 16($sp)
 258         ldq     $12, 24($sp)
 259         ldq     $13, 32($sp)
 260         ldq     $14, 40($sp)
 261         ldq     $15, 48($sp)
 262         lda     $sp, 56($sp)
 263         br      ret_from_sys_call
 264 .end entUnaUser
 265
 266         .align  4
 267         .globl  entDbg
 268         .ent    entDbg
 269 entDbg:
 270         SAVE_ALL
 271         lda     $8, 0x3fff
 272         lda     $26, ret_from_sys_call
 273         bic     $sp, $8, $8
 274         mov     $sp, $16
 275         jsr     $31, do_entDbg
 276 .end entDbg
 277 \f
 278 /*
 279  * The system call entry point is special.  Most importantly, it looks
 280  * like a function call to userspace as far as clobbered registers.  We
 281  * do preserve the argument registers (for syscall restarts) and $26
 282  * (for leaf syscall functions).
 283  *
 284  * So much for theory.  We don't take advantage of this yet.
 285  *
 286  * Note that a0-a2 are not saved by PALcode as with the other entry points.
 287  */
 288
 289         .align  4
 290         .globl  entSys
 291         .globl  ret_from_sys_call
 292         .ent    entSys
 293 entSys:
 294         SAVE_ALL
 295         lda     $8, 0x3fff
 296         bic     $sp, $8, $8
 297         lda     $4, NR_SYSCALLS($31)
 298         stq     $16, SP_OFF+24($sp)
 299         lda     $5, sys_call_table
 300         lda     $27, sys_ni_syscall
 301         cmpult  $0, $4, $4
 302         ldl     $3, TI_FLAGS($8)
 303         stq     $17, SP_OFF+32($sp)
 304         s8addq  $0, $5, $5
 305         stq     $18, SP_OFF+40($sp)
 306         blbs    $3, strace
 307         beq     $4, 1f
 308         ldq     $27, 0($5)
 309 1:      jsr     $26, ($27), alpha_ni_syscall
 310         ldgp    $gp, 0($26)
 311         blt     $0, $syscall_error      /* the call failed */
 312         stq     $0, 0($sp)
 313         stq     $31, 72($sp)            /* a3=0 => no error */
 314
 315         .align  4
 316 ret_from_sys_call:
 317         cmovne  $26, 0, $19             /* $19 = 0 => non-restartable */
 318         ldq     $0, SP_OFF($sp)
 319         and     $0, 8, $0
 320         beq     $0, restore_all
 321 ret_from_reschedule:
 322         /* Make sure need_resched and sigpending don't change between
 323                 sampling and the rti.  */
 324         lda     $16, 7
 325         call_pal PAL_swpipl
 326         ldl     $5, TI_FLAGS($8)
 327         and     $5, _TIF_WORK_MASK, $2
 328         bne     $5, work_pending
 329 restore_all:
 330         RESTORE_ALL
 331         call_pal PAL_rti
 332
 333         .align 3
 334 $syscall_error:
 335         /*
 336          * Some system calls (e.g., ptrace) can return arbitrary
 337          * values which might normally be mistaken as error numbers.
 338          * Those functions must zero $0 (v0) directly in the stack
 339          * frame to indicate that a negative return value wasn't an
 340          * error number..
 341          */
 342         ldq     $19, 0($sp)     /* old syscall nr (zero if success) */
 343         beq     $19, $ret_success
 344
 345         ldq     $20, 72($sp)    /* .. and this a3 */
 346         subq    $31, $0, $0     /* with error in v0 */
 347         addq    $31, 1, $1      /* set a3 for errno return */
 348         stq     $0, 0($sp)
 349         mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
 350         stq     $1, 72($sp)     /* a3 for return */
 351         br      ret_from_sys_call
 352
 353 $ret_success:
 354         stq     $0, 0($sp)
 355         stq     $31, 72($sp)    /* a3=0 => no error */
 356         br      ret_from_sys_call
 357 .end entSys
 358
 359 /*
 360  * Do all cleanup when returning from all interrupts and system calls.
 361  *
 362  * Arguments:
 363  *       $5: TI_FLAGS.
 364  *       $8: current.
 365  *      $19: The old syscall number, or zero if this is not a return
 366  *           from a syscall that errored and is possibly restartable.
 367  *      $20: Error indication.
 368  */
 369
 370         .align  4
 371         .ent    work_pending
 372 work_pending:
 373         and     $5, _TIF_NEED_RESCHED, $2
 374         beq     $2, $work_notifysig
 375
 376 $work_resched:
 377         subq    $sp, 16, $sp
 378         stq     $19, 0($sp)              /* save syscall nr */
 379         stq     $20, 8($sp)              /* and error indication (a3) */
 380         jsr     $26, schedule
 381         ldq     $19, 0($sp)
 382         ldq     $20, 8($sp)
 383         addq    $sp, 16, $sp
 384         /* Make sure need_resched and sigpending don't change between
 385                 sampling and the rti.  */
 386         lda     $16, 7
 387         call_pal PAL_swpipl
 388         ldl     $5, TI_FLAGS($8)
 389         and     $5, _TIF_WORK_MASK, $2
 390         beq     $2, restore_all
 391         and     $5, _TIF_NEED_RESCHED, $2
 392         bne     $2, $work_resched
 393
 394 $work_notifysig:
 395         mov     $sp, $17
 396         br      $1, do_switch_stack
 397         mov     $5, $21
 398         mov     $sp, $18
 399         mov     $31, $16
 400         jsr     $26, do_notify_resume
 401         bsr     $1, undo_switch_stack
 402         br      restore_all
 403 .end work_pending
 404
 405 /*
 406  * PTRACE syscall handler
 407  */
 408
 409         .align  4
 410         .ent    strace
 411 strace:
 412         /* set up signal stack, call syscall_trace */
 413         bsr     $1, do_switch_stack
 414         jsr     $26, syscall_trace
 415         bsr     $1, undo_switch_stack
 416
 417         /* get the system call number and the arguments back.. */
 418         ldq     $0, 0($sp)
 419         ldq     $16, SP_OFF+24($sp)
 420         ldq     $17, SP_OFF+32($sp)
 421         ldq     $18, SP_OFF+40($sp)
 422         ldq     $19, 72($sp)
 423         ldq     $20, 80($sp)
 424         ldq     $21, 88($sp)
 425
 426         /* get the system call pointer.. */
 427         lda     $1, NR_SYSCALLS($31)
 428         lda     $2, sys_call_table
 429         lda     $27, alpha_ni_syscall
 430         cmpult  $0, $1, $1
 431         s8addq  $0, $2, $2
 432         beq     $1, 1f
 433         ldq     $27, 0($2)
 434 1:      jsr     $26, ($27), sys_gettimeofday
 435         ldgp    $gp, 0($26)
 436
 437         /* check return.. */
 438         blt     $0, $strace_error       /* the call failed */
 439         stq     $31, 72($sp)            /* a3=0 => no error */
 440 $strace_success:
 441         stq     $0, 0($sp)              /* save return value */
 442
 443         bsr     $1, do_switch_stack
 444         jsr     $26, syscall_trace
 445         bsr     $1, undo_switch_stack
 446         br      $31, ret_from_sys_call
 447
 448         .align  3
 449 $strace_error:
 450         ldq     $19, 0($sp)     /* old syscall nr (zero if success) */
 451         beq     $19, $strace_success
 452         ldq     $20, 72($sp)    /* .. and this a3 */
 453
 454         subq    $31, $0, $0     /* with error in v0 */
 455         addq    $31, 1, $1      /* set a3 for errno return */
 456         stq     $0, 0($sp)
 457         stq     $1, 72($sp)     /* a3 for return */
 458
 459         bsr     $1, do_switch_stack
 460         mov     $19, $9         /* save old syscall number */
 461         mov     $20, $10        /* save old a3 */
 462         jsr     $26, syscall_trace
 463         mov     $9, $19
 464         mov     $10, $20
 465         bsr     $1, undo_switch_stack
 466
 467         mov     $31, $26        /* tell "ret_from_sys_call" we can restart */
 468         br      ret_from_sys_call
 469 .end strace
 470 \f
 471 /*
 472  * Save and restore the switch stack -- aka the balance of the user context.
 473  */
 474
 475         .align  4
 476         .ent    do_switch_stack
 477 do_switch_stack:
 478         lda     $sp, -SWITCH_STACK_SIZE($sp)
 479         stq     $9, 0($sp)
 480         stq     $10, 8($sp)
 481         stq     $11, 16($sp)
 482         stq     $12, 24($sp)
 483         stq     $13, 32($sp)
 484         stq     $14, 40($sp)
 485         stq     $15, 48($sp)
 486         stq     $26, 56($sp)
 487         stt     $f0, 64($sp)
 488         stt     $f1, 72($sp)
 489         stt     $f2, 80($sp)
 490         stt     $f3, 88($sp)
 491         stt     $f4, 96($sp)
 492         stt     $f5, 104($sp)
 493         stt     $f6, 112($sp)
 494         stt     $f7, 120($sp)
 495         stt     $f8, 128($sp)
 496         stt     $f9, 136($sp)
 497         stt     $f10, 144($sp)
 498         stt     $f11, 152($sp)
 499         stt     $f12, 160($sp)
 500         stt     $f13, 168($sp)
 501         stt     $f14, 176($sp)
 502         stt     $f15, 184($sp)
 503         stt     $f16, 192($sp)
 504         stt     $f17, 200($sp)
 505         stt     $f18, 208($sp)
 506         stt     $f19, 216($sp)
 507         stt     $f20, 224($sp)
 508         stt     $f21, 232($sp)
 509         stt     $f22, 240($sp)
 510         stt     $f23, 248($sp)
 511         stt     $f24, 256($sp)
 512         stt     $f25, 264($sp)
 513         stt     $f26, 272($sp)
 514         stt     $f27, 280($sp)
 515         mf_fpcr $f0             # get fpcr
 516         stt     $f28, 288($sp)
 517         stt     $f29, 296($sp)
 518         stt     $f30, 304($sp)
 519         stt     $f0, 312($sp)   # save fpcr in slot of $f31
 520         ldt     $f0, 64($sp)    # dont let "do_switch_stack" change fp state.
 521         ret     $31, ($1), 1
 522 .end do_switch_stack
 523
 524         .align  4
 525         .ent    undo_switch_stack
 526 undo_switch_stack:
 527         ldq     $9, 0($sp)
 528         ldq     $10, 8($sp)
 529         ldq     $11, 16($sp)
 530         ldq     $12, 24($sp)
 531         ldq     $13, 32($sp)
 532         ldq     $14, 40($sp)
 533         ldq     $15, 48($sp)
 534         ldq     $26, 56($sp)
 535         ldt     $f30, 312($sp)  # get saved fpcr
 536         ldt     $f0, 64($sp)
 537         ldt     $f1, 72($sp)
 538         ldt     $f2, 80($sp)
 539         ldt     $f3, 88($sp)
 540         mt_fpcr $f30            # install saved fpcr
 541         ldt     $f4, 96($sp)
 542         ldt     $f5, 104($sp)
 543         ldt     $f6, 112($sp)
 544         ldt     $f7, 120($sp)
 545         ldt     $f8, 128($sp)
 546         ldt     $f9, 136($sp)
 547         ldt     $f10, 144($sp)
 548         ldt     $f11, 152($sp)
 549         ldt     $f12, 160($sp)
 550         ldt     $f13, 168($sp)
 551         ldt     $f14, 176($sp)
 552         ldt     $f15, 184($sp)
 553         ldt     $f16, 192($sp)
 554         ldt     $f17, 200($sp)
 555         ldt     $f18, 208($sp)
 556         ldt     $f19, 216($sp)
 557         ldt     $f20, 224($sp)
 558         ldt     $f21, 232($sp)
 559         ldt     $f22, 240($sp)
 560         ldt     $f23, 248($sp)
 561         ldt     $f24, 256($sp)
 562         ldt     $f25, 264($sp)
 563         ldt     $f26, 272($sp)
 564         ldt     $f27, 280($sp)
 565         ldt     $f28, 288($sp)
 566         ldt     $f29, 296($sp)
 567         ldt     $f30, 304($sp)
 568         lda     $sp, SWITCH_STACK_SIZE($sp)
 569         ret     $31, ($1), 1
 570 .end undo_switch_stack
 571 \f
 572 /*
 573  * The meat of the context switch code.
 574  */
 575
 576         .align  4
 577         .globl  alpha_switch_to
 578         .ent    alpha_switch_to
 579 alpha_switch_to:
 580         .prologue 0
 581         bsr     $1, do_switch_stack
 582         call_pal PAL_swpctx
 583         lda     $8, 0x3fff
 584         bsr     $1, undo_switch_stack
 585         bic     $sp, $8, $8
 586         mov     $17, $0
 587         ret
 588 .end alpha_switch_to
 589
 590 /*
 591  * New processes begin life here.
 592  */
 593
 594         .globl  ret_from_fork
 595         .align  4
 596         .ent    ret_from_fork
 597 ret_from_fork:
 598         lda     $26, ret_from_sys_call
 599         mov     $17, $16
 600         jmp     $31, schedule_tail
 601 .end ret_from_fork
 602
 603 /*
 604  * kernel_thread(fn, arg, clone_flags)
 605  */
 606         .align 4
 607         .globl  kernel_thread
 608         .ent    kernel_thread
 609 kernel_thread:
 610         /* We can be called from a module.  */
 611         ldgp    $gp, 0($27)
 612         .prologue 1
 613         subq    $sp, SP_OFF+6*8, $sp
 614         br      $1, 2f          /* load start address */
 615
 616         /* We've now "returned" from a fake system call.  */
 617         unop
 618         blt     $0, 1f          /* error?  */
 619         ldi     $1, 0x3fff
 620         beq     $20, 1f         /* parent or child?  */
 621
 622         bic     $sp, $1, $8     /* in child.  */
 623         jsr     $26, ($27)
 624         ldgp    $gp, 0($26)
 625         mov     $0, $16
 626         mov     $31, $26
 627         jmp     $31, sys_exit
 628
 629 1:      ret                     /* in parent.  */
 630
 631         .align 4
 632 2:      /* Fake a system call stack frame, as we can't do system calls
 633            from kernel space.  Note that we store FN and ARG as they
 634            need to be set up in the child for the call.  Also store $8
 635            and $26 for use in the parent.  */
 636         stq     $31, SP_OFF($sp)        /* ps */
 637         stq     $1, SP_OFF+8($sp)       /* pc */
 638         stq     $gp, SP_OFF+16($sp)     /* gp */
 639         stq     $16, 136($sp)           /* $27; FN for child */
 640         stq     $17, SP_OFF+24($sp)     /* $16; ARG for child */
 641         stq     $8, 64($sp)             /* $8 */
 642         stq     $26, 128($sp)           /* $26 */
 643         /* Avoid the HAE being gratuitously wrong, to avoid restoring it.  */
 644         ldq     $2, alpha_mv+HAE_CACHE
 645         stq     $2, 152($sp)            /* HAE */
 646
 647         /* Shuffle FLAGS to the front; add CLONE_VM.  */
 648         ldi     $1, CLONE_VM|CLONE_UNTRACED
 649         or      $18, $1, $16
 650         bsr     $26, sys_clone
 651
 652         /* We don't actually care for a3 success widgetry in the kernel.
 653            Not for positive errno values.  */
 654         stq     $0, 0($sp)              /* $0 */
 655         br      restore_all
 656 .end kernel_thread
 657
 658 /*
 659  * execve(path, argv, envp)
 660  */
 661         .align  4
 662         .globl  execve
 663         .ent    execve
 664 execve:
 665         /* We can be called from a module.  */
 666         ldgp    $gp, 0($27)
 667         lda     $sp, -(32+SIZEOF_PT_REGS+8)($sp)
 668         .frame  $sp, 32+SIZEOF_PT_REGS+8, $26, 0
 669         stq     $26, 0($sp)
 670         stq     $16, 8($sp)
 671         stq     $17, 16($sp)
 672         stq     $18, 24($sp)
 673         .prologue 1
 674
 675         lda     $16, 32($sp)
 676         lda     $17, 0
 677         lda     $18, SIZEOF_PT_REGS
 678         bsr     $26, memset             !samegp
 679
 680         /* Avoid the HAE being gratuitously wrong, which would cause us
 681            to do the whole turn off interrupts thing and restore it.  */
 682         ldq     $2, alpha_mv+HAE_CACHE
 683         stq     $2, 152+32($sp)
 684
 685         ldq     $16, 8($sp)
 686         ldq     $17, 16($sp)
 687         ldq     $18, 24($sp)
 688         lda     $19, 32($sp)
 689         bsr     $26, do_execve          !samegp
 690
 691         ldq     $26, 0($sp)
 692         bne     $0, 1f                  /* error! */
 693
 694         /* Move the temporary pt_regs struct from its current location
 695            to the top of the kernel stack frame.  See copy_thread for
 696            details for a normal process.  */
 697         lda     $16, 0x4000 - SIZEOF_PT_REGS($8)
 698         lda     $17, 32($sp)
 699         lda     $18, SIZEOF_PT_REGS
 700         bsr     $26, memmove            !samegp
 701
 702         /* Take that over as our new stack frame and visit userland!  */
 703         lda     $sp, 0x4000 - SIZEOF_PT_REGS($8)
 704         br      $31, ret_from_sys_call
 705
 706 1:      lda     $sp, 32+SIZEOF_PT_REGS+8($sp)
 707         ret
 708 .end execve
 709
 710 \f
 711 /*
 712  * Special system calls.  Most of these are special in that they either
 713  * have to play switch_stack games or in some way use the pt_regs struct.
 714  */
 715         .align  4
 716         .globl  sys_fork
 717         .ent    sys_fork
 718 sys_fork:
 719         .prologue 0
 720         mov     $sp, $21
 721         bsr     $1, do_switch_stack
 722         bis     $31, SIGCHLD, $16
 723         mov     $31, $17
 724         mov     $31, $18
 725         mov     $31, $19
 726         mov     $31, $20
 727         jsr     $26, alpha_clone
 728         bsr     $1, undo_switch_stack
 729         ret
 730 .end sys_fork
 731
 732         .align  4
 733         .globl  sys_clone
 734         .ent    sys_clone
 735 sys_clone:
 736         .prologue 0
 737         mov     $sp, $21
 738         bsr     $1, do_switch_stack
 739         /* $16, $17, $18, $19, $20 come from the user.  */
 740         jsr     $26, alpha_clone
 741         bsr     $1, undo_switch_stack
 742         ret
 743 .end sys_clone
 744
 745         .align  4
 746         .globl  sys_vfork
 747         .ent    sys_vfork
 748 sys_vfork:
 749         .prologue 0
 750         mov     $sp, $16
 751         bsr     $1, do_switch_stack
 752         jsr     $26, alpha_vfork
 753         bsr     $1, undo_switch_stack
 754         ret
 755 .end sys_vfork
 756
 757         .align  4
 758         .globl  sys_sigreturn
 759         .ent    sys_sigreturn
 760 sys_sigreturn:
 761         .prologue 0
 762         mov     $sp, $17
 763         lda     $18, -SWITCH_STACK_SIZE($sp)
 764         lda     $sp, -SWITCH_STACK_SIZE($sp)
 765         jsr     $26, do_sigreturn
 766         br      $1, undo_switch_stack
 767         br      ret_from_sys_call
 768 .end sys_sigreturn
 769
 770         .align  4
 771         .globl  sys_rt_sigreturn
 772         .ent    sys_rt_sigreturn
 773 sys_rt_sigreturn:
 774         .prologue 0
 775         mov     $sp, $17
 776         lda     $18, -SWITCH_STACK_SIZE($sp)
 777         lda     $sp, -SWITCH_STACK_SIZE($sp)
 778         jsr     $26, do_rt_sigreturn
 779         br      $1, undo_switch_stack
 780         br      ret_from_sys_call
 781 .end sys_rt_sigreturn
 782
 783         .align  4
 784         .globl  sys_sigsuspend
 785         .ent    sys_sigsuspend
 786 sys_sigsuspend:
 787         .prologue 0
 788         mov     $sp, $17
 789         br      $1, do_switch_stack
 790         mov     $sp, $18
 791         subq    $sp, 16, $sp
 792         stq     $26, 0($sp)
 793         jsr     $26, do_sigsuspend
 794         ldq     $26, 0($sp)
 795         lda     $sp, SWITCH_STACK_SIZE+16($sp)
 796         ret
 797 .end sys_sigsuspend
 798
 799         .align  4
 800         .globl  sys_rt_sigsuspend
 801         .ent    sys_rt_sigsuspend
 802 sys_rt_sigsuspend:
 803         .prologue 0
 804         mov     $sp, $18
 805         br      $1, do_switch_stack
 806         mov     $sp, $19
 807         subq    $sp, 16, $sp
 808         stq     $26, 0($sp)
 809         jsr     $26, do_rt_sigsuspend
 810         ldq     $26, 0($sp)
 811         lda     $sp, SWITCH_STACK_SIZE+16($sp)
 812         ret
 813 .end sys_rt_sigsuspend
 814
 815         .align  4
 816         .globl  sys_sethae
 817         .ent    sys_sethae
 818 sys_sethae:
 819         .prologue 0
 820         stq     $16, 152($sp)
 821         ret
 822 .end sys_sethae
 823
 824         .align  4
 825         .globl  osf_getpriority
 826         .ent    osf_getpriority
 827 osf_getpriority:
 828         lda     $sp, -16($sp)
 829         stq     $26, 0($sp)
 830         .prologue 0
 831
 832         jsr     $26, sys_getpriority
 833
 834         ldq     $26, 0($sp)
 835         blt     $0, 1f
 836
 837         /* Return value is the unbiased priority, i.e. 20 - prio.
 838            This does result in negative return values, so signal
 839            no error by writing into the R0 slot.  */
 840         lda     $1, 20
 841         stq     $31, 16($sp)
 842         subl    $1, $0, $0
 843         unop
 844
 845 1:      lda     $sp, 16($sp)
 846         ret
 847 .end osf_getpriority
 848
 849         .align  4
 850         .globl  sys_getxuid
 851         .ent    sys_getxuid
 852 sys_getxuid:
 853         .prologue 0
 854         ldq     $2, TI_TASK($8)
 855         ldl     $0, TASK_UID($2)
 856         ldl     $1, TASK_EUID($2)
 857         stq     $1, 80($sp)
 858         ret
 859 .end sys_getxuid
 860
 861         .align  4
 862         .globl  sys_getxgid
 863         .ent    sys_getxgid
 864 sys_getxgid:
 865         .prologue 0
 866         ldq     $2, TI_TASK($8)
 867         ldl     $0, TASK_GID($2)
 868         ldl     $1, TASK_EGID($2)
 869         stq     $1, 80($sp)
 870         ret
 871 .end sys_getxgid
 872
 873         .align  4
 874         .globl  sys_getxpid
 875         .ent    sys_getxpid
 876 sys_getxpid:
 877         .prologue 0
 878         ldq     $2, TI_TASK($8)
 879
 880         /* See linux/kernel/timer.c sys_getppid for discussion
 881            about this loop.  */
 882         ldq     $3, TASK_GROUP_LEADER($2)
 883         ldq     $4, TASK_REAL_PARENT($3)
 884         ldl     $0, TASK_TGID($2)
 885 1:      ldl     $1, TASK_TGID($4)
 886 #ifdef CONFIG_SMP
 887         mov     $4, $5
 888         mb
 889         ldq     $3, TASK_GROUP_LEADER($2)
 890         ldq     $4, TASK_REAL_PARENT($3)
 891         cmpeq   $4, $5, $5
 892         beq     $5, 1b
 893 #endif
 894         stq     $1, 80($sp)
 895         ret
 896 .end sys_getxpid
 897
 898         .align  4
 899         .globl  sys_pipe
 900         .ent    sys_pipe
 901 sys_pipe:
 902         lda     $sp, -16($sp)
 903         stq     $26, 0($sp)
 904         .prologue 0
 905
 906         lda     $16, 8($sp)
 907         jsr     $26, do_pipe
 908
 909         ldq     $26, 0($sp)
 910         bne     $0, 1f
 911
 912         /* The return values are in $0 and $20.  */
 913         ldl     $1, 12($sp)
 914         ldl     $0, 8($sp)
 915
 916         stq     $1, 80+16($sp)
 917 1:      lda     $sp, 16($sp)
 918         ret
 919 .end sys_pipe
 920
 921         .align  4
 922         .globl  sys_ptrace
 923         .ent    sys_ptrace
 924 sys_ptrace:
 925         .prologue 0
 926         mov     $sp, $20
 927         jmp     $31, do_sys_ptrace
 928 .end sys_ptrace
 929
 930         .align  4
 931         .globl  sys_execve
 932         .ent    sys_execve
 933 sys_execve:
 934         .prologue 0
 935         mov     $sp, $19
 936         jmp     $31, do_sys_execve
 937 .end sys_execve
 938
 939         .align  4
 940         .globl  osf_sigprocmask
 941         .ent    osf_sigprocmask
 942 osf_sigprocmask:
 943         .prologue 0
 944         mov     $sp, $18
 945         jmp     $31, do_osf_sigprocmask
 946 .end osf_sigprocmask
 947
 948         .align  4
 949         .globl  alpha_ni_syscall
 950         .ent    alpha_ni_syscall
 951 alpha_ni_syscall:
 952         .prologue 0
 953         /* Special because it also implements overflow handling via
 954            syscall number 0.  And if you recall, zero is a special
 955            trigger for "not an error".  Store large non-zero there.  */
 956         lda     $0, -ENOSYS
 957         unop
 958         stq     $0, 0($sp)
 959         ret
 960 .end alpha_ni_syscall