1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * S390 version 4 * Copyright IBM Corp. 1999 5 * Author(s): Hartmut Penner (hp@de.ibm.com) 6 * Ulrich Weigand (uweigand@de.ibm.com) 7 * 8 * Derived from "arch/i386/mm/fault.c" 9 * Copyright (C) 1995 Linus Torvalds 10 */ 11 12 #include <linux/kernel_stat.h> 13 #include <linux/perf_event.h> 14 #include <linux/signal.h> 15 #include <linux/sched.h> 16 #include <linux/sched/debug.h> 17 #include <linux/kernel.h> 18 #include <linux/errno.h> 19 #include <linux/string.h> 20 #include <linux/types.h> 21 #include <linux/ptrace.h> 22 #include <linux/mman.h> 23 #include <linux/mm.h> 24 #include <linux/compat.h> 25 #include <linux/smp.h> 26 #include <linux/kdebug.h> 27 #include <linux/init.h> 28 #include <linux/console.h> 29 #include <linux/extable.h> 30 #include <linux/hardirq.h> 31 #include <linux/kprobes.h> 32 #include <linux/uaccess.h> 33 #include <linux/hugetlb.h> 34 #include <linux/kfence.h> 35 #include <asm/asm-extable.h> 36 #include <asm/asm-offsets.h> 37 #include <asm/diag.h> 38 #include <asm/gmap.h> 39 #include <asm/irq.h> 40 #include <asm/mmu_context.h> 41 #include <asm/facility.h> 42 #include <asm/uv.h> 43 #include "../kernel/entry.h" 44 45 #define __FAIL_ADDR_MASK -4096L 46 47 /* 48 * Allocate private vm_fault_reason from top. Please make sure it won't 49 * collide with vm_fault_reason. 50 */ 51 #define VM_FAULT_BADCONTEXT ((__force vm_fault_t)0x80000000) 52 #define VM_FAULT_BADMAP ((__force vm_fault_t)0x40000000) 53 #define VM_FAULT_BADACCESS ((__force vm_fault_t)0x20000000) 54 #define VM_FAULT_SIGNAL ((__force vm_fault_t)0x10000000) 55 #define VM_FAULT_PFAULT ((__force vm_fault_t)0x8000000) 56 57 enum fault_type { 58 KERNEL_FAULT, 59 USER_FAULT, 60 GMAP_FAULT, 61 }; 62 63 static unsigned long store_indication __read_mostly; 64 65 static int __init fault_init(void) 66 { 67 if (test_facility(75)) 68 store_indication = 0xc00; 69 return 0; 70 } 71 early_initcall(fault_init); 72 73 /* 74 * Find out which address space caused the exception. 75 */ 76 static enum fault_type get_fault_type(struct pt_regs *regs) 77 { 78 unsigned long trans_exc_code; 79 80 trans_exc_code = regs->int_parm_long & 3; 81 if (likely(trans_exc_code == 0)) { 82 /* primary space exception */ 83 if (user_mode(regs)) 84 return USER_FAULT; 85 if (!IS_ENABLED(CONFIG_PGSTE)) 86 return KERNEL_FAULT; 87 if (test_pt_regs_flag(regs, PIF_GUEST_FAULT)) 88 return GMAP_FAULT; 89 return KERNEL_FAULT; 90 } 91 if (trans_exc_code == 2) 92 return USER_FAULT; 93 if (trans_exc_code == 1) { 94 /* access register mode, not used in the kernel */ 95 return USER_FAULT; 96 } 97 /* home space exception -> access via kernel ASCE */ 98 return KERNEL_FAULT; 99 } 100 101 static unsigned long get_fault_address(struct pt_regs *regs) 102 { 103 unsigned long trans_exc_code = regs->int_parm_long; 104 105 return trans_exc_code & __FAIL_ADDR_MASK; 106 } 107 108 static bool fault_is_write(struct pt_regs *regs) 109 { 110 unsigned long trans_exc_code = regs->int_parm_long; 111 112 return (trans_exc_code & store_indication) == 0x400; 113 } 114 115 static int bad_address(void *p) 116 { 117 unsigned long dummy; 118 119 return get_kernel_nofault(dummy, (unsigned long *)p); 120 } 121 122 static void dump_pagetable(unsigned long asce, unsigned long address) 123 { 124 unsigned long *table = __va(asce & _ASCE_ORIGIN); 125 126 pr_alert("AS:%016lx ", asce); 127 switch (asce & _ASCE_TYPE_MASK) { 128 case _ASCE_TYPE_REGION1: 129 table += (address & _REGION1_INDEX) >> _REGION1_SHIFT; 130 if (bad_address(table)) 131 goto bad; 132 pr_cont("R1:%016lx ", *table); 133 if (*table & _REGION_ENTRY_INVALID) 134 goto out; 135 table = __va(*table & _REGION_ENTRY_ORIGIN); 136 fallthrough; 137 case _ASCE_TYPE_REGION2: 138 table += (address & _REGION2_INDEX) >> _REGION2_SHIFT; 139 if (bad_address(table)) 140 goto bad; 141 pr_cont("R2:%016lx ", *table); 142 if (*table & _REGION_ENTRY_INVALID) 143 goto out; 144 table = __va(*table & _REGION_ENTRY_ORIGIN); 145 fallthrough; 146 case _ASCE_TYPE_REGION3: 147 table += (address & _REGION3_INDEX) >> _REGION3_SHIFT; 148 if (bad_address(table)) 149 goto bad; 150 pr_cont("R3:%016lx ", *table); 151 if (*table & (_REGION_ENTRY_INVALID | _REGION3_ENTRY_LARGE)) 152 goto out; 153 table = __va(*table & _REGION_ENTRY_ORIGIN); 154 fallthrough; 155 case _ASCE_TYPE_SEGMENT: 156 table += (address & _SEGMENT_INDEX) >> _SEGMENT_SHIFT; 157 if (bad_address(table)) 158 goto bad; 159 pr_cont("S:%016lx ", *table); 160 if (*table & (_SEGMENT_ENTRY_INVALID | _SEGMENT_ENTRY_LARGE)) 161 goto out; 162 table = __va(*table & _SEGMENT_ENTRY_ORIGIN); 163 } 164 table += (address & _PAGE_INDEX) >> _PAGE_SHIFT; 165 if (bad_address(table)) 166 goto bad; 167 pr_cont("P:%016lx ", *table); 168 out: 169 pr_cont("\n"); 170 return; 171 bad: 172 pr_cont("BAD\n"); 173 } 174 175 static void dump_fault_info(struct pt_regs *regs) 176 { 177 unsigned long asce; 178 179 pr_alert("Failing address: %016lx TEID: %016lx\n", 180 regs->int_parm_long & __FAIL_ADDR_MASK, regs->int_parm_long); 181 pr_alert("Fault in "); 182 switch (regs->int_parm_long & 3) { 183 case 3: 184 pr_cont("home space "); 185 break; 186 case 2: 187 pr_cont("secondary space "); 188 break; 189 case 1: 190 pr_cont("access register "); 191 break; 192 case 0: 193 pr_cont("primary space "); 194 break; 195 } 196 pr_cont("mode while using "); 197 switch (get_fault_type(regs)) { 198 case USER_FAULT: 199 asce = S390_lowcore.user_asce; 200 pr_cont("user "); 201 break; 202 case GMAP_FAULT: 203 asce = ((struct gmap *) S390_lowcore.gmap)->asce; 204 pr_cont("gmap "); 205 break; 206 case KERNEL_FAULT: 207 asce = S390_lowcore.kernel_asce; 208 pr_cont("kernel "); 209 break; 210 default: 211 unreachable(); 212 } 213 pr_cont("ASCE.\n"); 214 dump_pagetable(asce, regs->int_parm_long & __FAIL_ADDR_MASK); 215 } 216 217 int show_unhandled_signals = 1; 218 219 void report_user_fault(struct pt_regs *regs, long signr, int is_mm_fault) 220 { 221 if ((task_pid_nr(current) > 1) && !show_unhandled_signals) 222 return; 223 if (!unhandled_signal(current, signr)) 224 return; 225 if (!printk_ratelimit()) 226 return; 227 printk(KERN_ALERT "User process fault: interruption code %04x ilc:%d ", 228 regs->int_code & 0xffff, regs->int_code >> 17); 229 print_vma_addr(KERN_CONT "in ", regs->psw.addr); 230 printk(KERN_CONT "\n"); 231 if (is_mm_fault) 232 dump_fault_info(regs); 233 show_regs(regs); 234 } 235 236 /* 237 * Send SIGSEGV to task. This is an external routine 238 * to keep the stack usage of do_page_fault small. 239 */ 240 static noinline void do_sigsegv(struct pt_regs *regs, int si_code) 241 { 242 report_user_fault(regs, SIGSEGV, 1); 243 force_sig_fault(SIGSEGV, si_code, 244 (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK)); 245 } 246 247 static noinline void do_no_context(struct pt_regs *regs, vm_fault_t fault) 248 { 249 enum fault_type fault_type; 250 unsigned long address; 251 bool is_write; 252 253 if (fixup_exception(regs)) 254 return; 255 fault_type = get_fault_type(regs); 256 if ((fault_type == KERNEL_FAULT) && (fault == VM_FAULT_BADCONTEXT)) { 257 address = get_fault_address(regs); 258 is_write = fault_is_write(regs); 259 if (kfence_handle_page_fault(address, is_write, regs)) 260 return; 261 } 262 /* 263 * Oops. The kernel tried to access some bad page. We'll have to 264 * terminate things with extreme prejudice. 265 */ 266 if (fault_type == KERNEL_FAULT) 267 printk(KERN_ALERT "Unable to handle kernel pointer dereference" 268 " in virtual kernel address space\n"); 269 else 270 printk(KERN_ALERT "Unable to handle kernel paging request" 271 " in virtual user address space\n"); 272 dump_fault_info(regs); 273 die(regs, "Oops"); 274 } 275 276 static noinline void do_low_address(struct pt_regs *regs) 277 { 278 /* Low-address protection hit in kernel mode means 279 NULL pointer write access in kernel mode. */ 280 if (regs->psw.mask & PSW_MASK_PSTATE) { 281 /* Low-address protection hit in user mode 'cannot happen'. */ 282 die (regs, "Low-address protection"); 283 } 284 285 do_no_context(regs, VM_FAULT_BADACCESS); 286 } 287 288 static noinline void do_sigbus(struct pt_regs *regs) 289 { 290 /* 291 * Send a sigbus, regardless of whether we were in kernel 292 * or user mode. 293 */ 294 force_sig_fault(SIGBUS, BUS_ADRERR, 295 (void __user *)(regs->int_parm_long & __FAIL_ADDR_MASK)); 296 } 297 298 static noinline void do_fault_error(struct pt_regs *regs, vm_fault_t fault) 299 { 300 int si_code; 301 302 switch (fault) { 303 case VM_FAULT_BADACCESS: 304 case VM_FAULT_BADMAP: 305 /* Bad memory access. Check if it is kernel or user space. */ 306 if (user_mode(regs)) { 307 /* User mode accesses just cause a SIGSEGV */ 308 si_code = (fault == VM_FAULT_BADMAP) ? 309 SEGV_MAPERR : SEGV_ACCERR; 310 do_sigsegv(regs, si_code); 311 break; 312 } 313 fallthrough; 314 case VM_FAULT_BADCONTEXT: 315 case VM_FAULT_PFAULT: 316 do_no_context(regs, fault); 317 break; 318 case VM_FAULT_SIGNAL: 319 if (!user_mode(regs)) 320 do_no_context(regs, fault); 321 break; 322 default: /* fault & VM_FAULT_ERROR */ 323 if (fault & VM_FAULT_OOM) { 324 if (!user_mode(regs)) 325 do_no_context(regs, fault); 326 else 327 pagefault_out_of_memory(); 328 } else if (fault & VM_FAULT_SIGSEGV) { 329 /* Kernel mode? Handle exceptions or die */ 330 if (!user_mode(regs)) 331 do_no_context(regs, fault); 332 else 333 do_sigsegv(regs, SEGV_MAPERR); 334 } else if (fault & VM_FAULT_SIGBUS) { 335 /* Kernel mode? Handle exceptions or die */ 336 if (!user_mode(regs)) 337 do_no_context(regs, fault); 338 else 339 do_sigbus(regs); 340 } else 341 BUG(); 342 break; 343 } 344 } 345 346 /* 347 * This routine handles page faults. It determines the address, 348 * and the problem, and then passes it off to one of the appropriate 349 * routines. 350 * 351 * interruption code (int_code): 352 * 04 Protection -> Write-Protection (suppression) 353 * 10 Segment translation -> Not present (nullification) 354 * 11 Page translation -> Not present (nullification) 355 * 3b Region third trans. -> Not present (nullification) 356 */ 357 static inline vm_fault_t do_exception(struct pt_regs *regs, int access) 358 { 359 struct gmap *gmap; 360 struct task_struct *tsk; 361 struct mm_struct *mm; 362 struct vm_area_struct *vma; 363 enum fault_type type; 364 unsigned long address; 365 unsigned int flags; 366 vm_fault_t fault; 367 bool is_write; 368 369 tsk = current; 370 /* 371 * The instruction that caused the program check has 372 * been nullified. Don't signal single step via SIGTRAP. 373 */ 374 clear_thread_flag(TIF_PER_TRAP); 375 376 if (kprobe_page_fault(regs, 14)) 377 return 0; 378 379 mm = tsk->mm; 380 address = get_fault_address(regs); 381 is_write = fault_is_write(regs); 382 383 /* 384 * Verify that the fault happened in user space, that 385 * we are not in an interrupt and that there is a 386 * user context. 387 */ 388 fault = VM_FAULT_BADCONTEXT; 389 type = get_fault_type(regs); 390 switch (type) { 391 case KERNEL_FAULT: 392 goto out; 393 case USER_FAULT: 394 case GMAP_FAULT: 395 if (faulthandler_disabled() || !mm) 396 goto out; 397 break; 398 } 399 400 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address); 401 flags = FAULT_FLAG_DEFAULT; 402 if (user_mode(regs)) 403 flags |= FAULT_FLAG_USER; 404 if (is_write) 405 access = VM_WRITE; 406 if (access == VM_WRITE) 407 flags |= FAULT_FLAG_WRITE; 408 if (!(flags & FAULT_FLAG_USER)) 409 goto lock_mmap; 410 vma = lock_vma_under_rcu(mm, address); 411 if (!vma) 412 goto lock_mmap; 413 if (!(vma->vm_flags & access)) { 414 vma_end_read(vma); 415 goto lock_mmap; 416 } 417 fault = handle_mm_fault(vma, address, flags | FAULT_FLAG_VMA_LOCK, regs); 418 if (!(fault & (VM_FAULT_RETRY | VM_FAULT_COMPLETED))) 419 vma_end_read(vma); 420 if (!(fault & VM_FAULT_RETRY)) { 421 count_vm_vma_lock_event(VMA_LOCK_SUCCESS); 422 if (likely(!(fault & VM_FAULT_ERROR))) 423 fault = 0; 424 goto out; 425 } 426 count_vm_vma_lock_event(VMA_LOCK_RETRY); 427 /* Quick path to respond to signals */ 428 if (fault_signal_pending(fault, regs)) { 429 fault = VM_FAULT_SIGNAL; 430 goto out; 431 } 432 lock_mmap: 433 mmap_read_lock(mm); 434 435 gmap = NULL; 436 if (IS_ENABLED(CONFIG_PGSTE) && type == GMAP_FAULT) { 437 gmap = (struct gmap *) S390_lowcore.gmap; 438 current->thread.gmap_addr = address; 439 current->thread.gmap_write_flag = !!(flags & FAULT_FLAG_WRITE); 440 current->thread.gmap_int_code = regs->int_code & 0xffff; 441 address = __gmap_translate(gmap, address); 442 if (address == -EFAULT) { 443 fault = VM_FAULT_BADMAP; 444 goto out_up; 445 } 446 if (gmap->pfault_enabled) 447 flags |= FAULT_FLAG_RETRY_NOWAIT; 448 } 449 450 retry: 451 fault = VM_FAULT_BADMAP; 452 vma = find_vma(mm, address); 453 if (!vma) 454 goto out_up; 455 456 if (unlikely(vma->vm_start > address)) { 457 if (!(vma->vm_flags & VM_GROWSDOWN)) 458 goto out_up; 459 vma = expand_stack(mm, address); 460 if (!vma) 461 goto out; 462 } 463 464 /* 465 * Ok, we have a good vm_area for this memory access, so 466 * we can handle it.. 467 */ 468 fault = VM_FAULT_BADACCESS; 469 if (unlikely(!(vma->vm_flags & access))) 470 goto out_up; 471 472 /* 473 * If for any reason at all we couldn't handle the fault, 474 * make sure we exit gracefully rather than endlessly redo 475 * the fault. 476 */ 477 fault = handle_mm_fault(vma, address, flags, regs); 478 if (fault_signal_pending(fault, regs)) { 479 fault = VM_FAULT_SIGNAL; 480 if (flags & FAULT_FLAG_RETRY_NOWAIT) 481 goto out_up; 482 goto out; 483 } 484 485 /* The fault is fully completed (including releasing mmap lock) */ 486 if (fault & VM_FAULT_COMPLETED) { 487 if (gmap) { 488 mmap_read_lock(mm); 489 goto out_gmap; 490 } 491 fault = 0; 492 goto out; 493 } 494 495 if (unlikely(fault & VM_FAULT_ERROR)) 496 goto out_up; 497 498 if (fault & VM_FAULT_RETRY) { 499 if (IS_ENABLED(CONFIG_PGSTE) && gmap && 500 (flags & FAULT_FLAG_RETRY_NOWAIT)) { 501 /* 502 * FAULT_FLAG_RETRY_NOWAIT has been set, mmap_lock has 503 * not been released 504 */ 505 current->thread.gmap_pfault = 1; 506 fault = VM_FAULT_PFAULT; 507 goto out_up; 508 } 509 flags &= ~FAULT_FLAG_RETRY_NOWAIT; 510 flags |= FAULT_FLAG_TRIED; 511 mmap_read_lock(mm); 512 goto retry; 513 } 514 out_gmap: 515 if (IS_ENABLED(CONFIG_PGSTE) && gmap) { 516 address = __gmap_link(gmap, current->thread.gmap_addr, 517 address); 518 if (address == -EFAULT) { 519 fault = VM_FAULT_BADMAP; 520 goto out_up; 521 } 522 if (address == -ENOMEM) { 523 fault = VM_FAULT_OOM; 524 goto out_up; 525 } 526 } 527 fault = 0; 528 out_up: 529 mmap_read_unlock(mm); 530 out: 531 return fault; 532 } 533 534 void do_protection_exception(struct pt_regs *regs) 535 { 536 unsigned long trans_exc_code; 537 int access; 538 vm_fault_t fault; 539 540 trans_exc_code = regs->int_parm_long; 541 /* 542 * Protection exceptions are suppressing, decrement psw address. 543 * The exception to this rule are aborted transactions, for these 544 * the PSW already points to the correct location. 545 */ 546 if (!(regs->int_code & 0x200)) 547 regs->psw.addr = __rewind_psw(regs->psw, regs->int_code >> 16); 548 /* 549 * Check for low-address protection. This needs to be treated 550 * as a special case because the translation exception code 551 * field is not guaranteed to contain valid data in this case. 552 */ 553 if (unlikely(!(trans_exc_code & 4))) { 554 do_low_address(regs); 555 return; 556 } 557 if (unlikely(MACHINE_HAS_NX && (trans_exc_code & 0x80))) { 558 regs->int_parm_long = (trans_exc_code & ~PAGE_MASK) | 559 (regs->psw.addr & PAGE_MASK); 560 access = VM_EXEC; 561 fault = VM_FAULT_BADACCESS; 562 } else { 563 access = VM_WRITE; 564 fault = do_exception(regs, access); 565 } 566 if (unlikely(fault)) 567 do_fault_error(regs, fault); 568 } 569 NOKPROBE_SYMBOL(do_protection_exception); 570 571 void do_dat_exception(struct pt_regs *regs) 572 { 573 int access; 574 vm_fault_t fault; 575 576 access = VM_ACCESS_FLAGS; 577 fault = do_exception(regs, access); 578 if (unlikely(fault)) 579 do_fault_error(regs, fault); 580 } 581 NOKPROBE_SYMBOL(do_dat_exception); 582 583 #if IS_ENABLED(CONFIG_PGSTE) 584 585 void do_secure_storage_access(struct pt_regs *regs) 586 { 587 unsigned long addr = regs->int_parm_long & __FAIL_ADDR_MASK; 588 struct vm_area_struct *vma; 589 struct mm_struct *mm; 590 struct page *page; 591 struct gmap *gmap; 592 int rc; 593 594 /* 595 * bit 61 tells us if the address is valid, if it's not we 596 * have a major problem and should stop the kernel or send a 597 * SIGSEGV to the process. Unfortunately bit 61 is not 598 * reliable without the misc UV feature so we need to check 599 * for that as well. 600 */ 601 if (uv_has_feature(BIT_UV_FEAT_MISC) && 602 !test_bit_inv(61, ®s->int_parm_long)) { 603 /* 604 * When this happens, userspace did something that it 605 * was not supposed to do, e.g. branching into secure 606 * memory. Trigger a segmentation fault. 607 */ 608 if (user_mode(regs)) { 609 send_sig(SIGSEGV, current, 0); 610 return; 611 } 612 613 /* 614 * The kernel should never run into this case and we 615 * have no way out of this situation. 616 */ 617 panic("Unexpected PGM 0x3d with TEID bit 61=0"); 618 } 619 620 switch (get_fault_type(regs)) { 621 case GMAP_FAULT: 622 mm = current->mm; 623 gmap = (struct gmap *)S390_lowcore.gmap; 624 mmap_read_lock(mm); 625 addr = __gmap_translate(gmap, addr); 626 mmap_read_unlock(mm); 627 if (IS_ERR_VALUE(addr)) { 628 do_fault_error(regs, VM_FAULT_BADMAP); 629 break; 630 } 631 fallthrough; 632 case USER_FAULT: 633 mm = current->mm; 634 mmap_read_lock(mm); 635 vma = find_vma(mm, addr); 636 if (!vma) { 637 mmap_read_unlock(mm); 638 do_fault_error(regs, VM_FAULT_BADMAP); 639 break; 640 } 641 page = follow_page(vma, addr, FOLL_WRITE | FOLL_GET); 642 if (IS_ERR_OR_NULL(page)) { 643 mmap_read_unlock(mm); 644 break; 645 } 646 if (arch_make_page_accessible(page)) 647 send_sig(SIGSEGV, current, 0); 648 put_page(page); 649 mmap_read_unlock(mm); 650 break; 651 case KERNEL_FAULT: 652 page = phys_to_page(addr); 653 if (unlikely(!try_get_page(page))) 654 break; 655 rc = arch_make_page_accessible(page); 656 put_page(page); 657 if (rc) 658 BUG(); 659 break; 660 default: 661 do_fault_error(regs, VM_FAULT_BADMAP); 662 WARN_ON_ONCE(1); 663 } 664 } 665 NOKPROBE_SYMBOL(do_secure_storage_access); 666 667 void do_non_secure_storage_access(struct pt_regs *regs) 668 { 669 unsigned long gaddr = regs->int_parm_long & __FAIL_ADDR_MASK; 670 struct gmap *gmap = (struct gmap *)S390_lowcore.gmap; 671 672 if (get_fault_type(regs) != GMAP_FAULT) { 673 do_fault_error(regs, VM_FAULT_BADMAP); 674 WARN_ON_ONCE(1); 675 return; 676 } 677 678 if (gmap_convert_to_secure(gmap, gaddr) == -EINVAL) 679 send_sig(SIGSEGV, current, 0); 680 } 681 NOKPROBE_SYMBOL(do_non_secure_storage_access); 682 683 void do_secure_storage_violation(struct pt_regs *regs) 684 { 685 unsigned long gaddr = regs->int_parm_long & __FAIL_ADDR_MASK; 686 struct gmap *gmap = (struct gmap *)S390_lowcore.gmap; 687 688 /* 689 * If the VM has been rebooted, its address space might still contain 690 * secure pages from the previous boot. 691 * Clear the page so it can be reused. 692 */ 693 if (!gmap_destroy_page(gmap, gaddr)) 694 return; 695 /* 696 * Either KVM messed up the secure guest mapping or the same 697 * page is mapped into multiple secure guests. 698 * 699 * This exception is only triggered when a guest 2 is running 700 * and can therefore never occur in kernel context. 701 */ 702 printk_ratelimited(KERN_WARNING 703 "Secure storage violation in task: %s, pid %d\n", 704 current->comm, current->pid); 705 send_sig(SIGSEGV, current, 0); 706 } 707 708 #endif /* CONFIG_PGSTE */ 709