git.oblomov.eu Git - linux-2.6/blob - arch/x86/mm/fault_64.c

   1 /*
   2  *  Copyright (C) 1995  Linus Torvalds
   3  *  Copyright (C) 2001,2002 Andi Kleen, SuSE Labs.
   4  */
   5
   6 #include <linux/signal.h>
   7 #include <linux/sched.h>
   8 #include <linux/kernel.h>
   9 #include <linux/errno.h>
  10 #include <linux/string.h>
  11 #include <linux/types.h>
  12 #include <linux/ptrace.h>
  13 #include <linux/mman.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/init.h>
  18 #include <linux/tty.h>
  19 #include <linux/vt_kern.h>              /* For unblank_screen() */
  20 #include <linux/compiler.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/module.h>
  23 #include <linux/kprobes.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/kdebug.h>
  26
  27 #include <asm/system.h>
  28 #include <asm/pgalloc.h>
  29 #include <asm/smp.h>
  30 #include <asm/tlbflush.h>
  31 #include <asm/proto.h>
  32 #include <asm-generic/sections.h>
  33
  34 /*
  35  * Page fault error code bits
  36  *      bit 0 == 0 means no page found, 1 means protection fault
  37  *      bit 1 == 0 means read, 1 means write
  38  *      bit 2 == 0 means kernel, 1 means user-mode
  39  *      bit 3 == 1 means use of reserved bit detected
  40  *      bit 4 == 1 means fault was an instruction fetch
  41  */
  42 #define PF_PROT         (1<<0)
  43 #define PF_WRITE        (1<<1)
  44 #define PF_USER         (1<<2)
  45 #define PF_RSVD         (1<<3)
  46 #define PF_INSTR        (1<<4)
  47
  48 static inline int notify_page_fault(struct pt_regs *regs)
  49 {
  50 #ifdef CONFIG_KPROBES
  51         int ret = 0;
  52
  53         /* kprobe_running() needs smp_processor_id() */
  54         if (!user_mode(regs)) {
  55                 preempt_disable();
  56                 if (kprobe_running() && kprobe_fault_handler(regs, 14))
  57                         ret = 1;
  58                 preempt_enable();
  59         }
  60
  61         return ret;
  62 #else
  63         return 0;
  64 #endif
  65 }
  66
  67 /*
  68  * X86_32
  69  * Sometimes AMD Athlon/Opteron CPUs report invalid exceptions on prefetch.
  70  * Check that here and ignore it.
  71  *
  72  * X86_64
  73  * Sometimes the CPU reports invalid exceptions on prefetch.
  74  * Check that here and ignore it.
  75  *
  76  * Opcode checker based on code by Richard Brunner
  77  */
  78 static int is_prefetch(struct pt_regs *regs, unsigned long addr,
  79                        unsigned long error_code)
  80 {
  81         unsigned char *instr;
  82         int scan_more = 1;
  83         int prefetch = 0;
  84         unsigned char *max_instr;
  85
  86 #ifdef CONFIG_X86_32
  87         unsigned long limit;
  88         if (unlikely(boot_cpu_data.x86_vendor == X86_VENDOR_AMD &&
  89                      boot_cpu_data.x86 >= 6)) {
  90                 /* Catch an obscure case of prefetch inside an NX page. */
  91                 if (nx_enabled && (error_code & PF_INSTR))
  92                         return 0;
  93         } else {
  94                 return 0;
  95         }
  96         instr = (unsigned char *)get_segment_eip(regs, &limit);
  97 #else
  98         /* If it was a exec fault ignore */
  99         if (error_code & PF_INSTR)
 100                 return 0;
 101         instr = (unsigned char __user *)convert_rip_to_linear(current, regs);
 102 #endif
 103
 104         max_instr = instr + 15;
 105
 106 #ifdef CONFIG_X86_64
 107         if (user_mode(regs) && instr >= (unsigned char *)TASK_SIZE)
 108                 return 0;
 109 #endif
 110
 111         while (scan_more && instr < max_instr) {
 112                 unsigned char opcode;
 113                 unsigned char instr_hi;
 114                 unsigned char instr_lo;
 115
 116 #ifdef CONFIG_X86_32
 117                 if (instr > (unsigned char *)limit)
 118                         break;
 119 #endif
 120                 if (probe_kernel_address(instr, opcode))
 121                         break;
 122
 123                 instr_hi = opcode & 0xf0;
 124                 instr_lo = opcode & 0x0f;
 125                 instr++;
 126
 127                 switch (instr_hi) {
 128                 case 0x20:
 129                 case 0x30:
 130                         /*
 131                          * Values 0x26,0x2E,0x36,0x3E are valid x86 prefixes.
 132                          * In X86_64 long mode, the CPU will signal invalid
 133                          * opcode if some of these prefixes are present so
 134                          * X86_64 will never get here anyway
 135                          */
 136                         scan_more = ((instr_lo & 7) == 0x6);
 137                         break;
 138 #ifdef CONFIG_X86_64
 139                 case 0x40:
 140                         /*
 141                          * In AMD64 long mode 0x40..0x4F are valid REX prefixes
 142                          * Need to figure out under what instruction mode the
 143                          * instruction was issued. Could check the LDT for lm,
 144                          * but for now it's good enough to assume that long
 145                          * mode only uses well known segments or kernel.
 146                          */
 147                         scan_more = (!user_mode(regs)) || (regs->cs == __USER_CS);
 148                         break;
 149 #endif
 150                 case 0x60:
 151                         /* 0x64 thru 0x67 are valid prefixes in all modes. */
 152                         scan_more = (instr_lo & 0xC) == 0x4;
 153                         break;
 154                 case 0xF0:
 155                         /* 0xF0, 0xF2, 0xF3 are valid prefixes in all modes. */
 156                         scan_more = !instr_lo || (instr_lo>>1) == 1;
 157                         break;
 158                 case 0x00:
 159                         /* Prefetch instruction is 0x0F0D or 0x0F18 */
 160                         scan_more = 0;
 161 #ifdef CONFIG_X86_32
 162                         if (instr > (unsigned char *)limit)
 163                                 break;
 164 #endif
 165                         if (probe_kernel_address(instr, opcode))
 166                                 break;
 167                         prefetch = (instr_lo == 0xF) &&
 168                                 (opcode == 0x0D || opcode == 0x18);
 169                         break;
 170                 default:
 171                         scan_more = 0;
 172                         break;
 173                 }
 174         }
 175         return prefetch;
 176 }
 177
 178 static void force_sig_info_fault(int si_signo, int si_code,
 179         unsigned long address, struct task_struct *tsk)
 180 {
 181         siginfo_t info;
 182
 183         info.si_signo = si_signo;
 184         info.si_errno = 0;
 185         info.si_code = si_code;
 186         info.si_addr = (void __user *)address;
 187         force_sig_info(si_signo, &info, tsk);
 188 }
 189
 190 static int bad_address(void *p)
 191 {
 192         unsigned long dummy;
 193         return probe_kernel_address((unsigned long *)p, dummy);
 194 }
 195
 196 void dump_pagetable(unsigned long address)
 197 {
 198         pgd_t *pgd;
 199         pud_t *pud;
 200         pmd_t *pmd;
 201         pte_t *pte;
 202
 203         pgd = (pgd_t *)read_cr3();
 204
 205         pgd = __va((unsigned long)pgd & PHYSICAL_PAGE_MASK);
 206         pgd += pgd_index(address);
 207         if (bad_address(pgd)) goto bad;
 208         printk("PGD %lx ", pgd_val(*pgd));
 209         if (!pgd_present(*pgd)) goto ret;
 210
 211         pud = pud_offset(pgd, address);
 212         if (bad_address(pud)) goto bad;
 213         printk("PUD %lx ", pud_val(*pud));
 214         if (!pud_present(*pud)) goto ret;
 215
 216         pmd = pmd_offset(pud, address);
 217         if (bad_address(pmd)) goto bad;
 218         printk("PMD %lx ", pmd_val(*pmd));
 219         if (!pmd_present(*pmd) || pmd_large(*pmd)) goto ret;
 220
 221         pte = pte_offset_kernel(pmd, address);
 222         if (bad_address(pte)) goto bad;
 223         printk("PTE %lx", pte_val(*pte));
 224 ret:
 225         printk("\n");
 226         return;
 227 bad:
 228         printk("BAD\n");
 229 }
 230
 231 #ifdef CONFIG_X86_64
 232 static const char errata93_warning[] =
 233 KERN_ERR "******* Your BIOS seems to not contain a fix for K8 errata #93\n"
 234 KERN_ERR "******* Working around it, but it may cause SEGVs or burn power.\n"
 235 KERN_ERR "******* Please consider a BIOS update.\n"
 236 KERN_ERR "******* Disabling USB legacy in the BIOS may also help.\n";
 237
 238 /* Workaround for K8 erratum #93 & buggy BIOS.
 239    BIOS SMM functions are required to use a specific workaround
 240    to avoid corruption of the 64bit RIP register on C stepping K8.
 241    A lot of BIOS that didn't get tested properly miss this.
 242    The OS sees this as a page fault with the upper 32bits of RIP cleared.
 243    Try to work around it here.
 244    Note we only handle faults in kernel here. */
 245
 246 static int is_errata93(struct pt_regs *regs, unsigned long address)
 247 {
 248         static int warned;
 249         if (address != regs->ip)
 250                 return 0;
 251         if ((address >> 32) != 0)
 252                 return 0;
 253         address |= 0xffffffffUL << 32;
 254         if ((address >= (u64)_stext && address <= (u64)_etext) ||
 255             (address >= MODULES_VADDR && address <= MODULES_END)) {
 256                 if (!warned) {
 257                         printk(errata93_warning);
 258                         warned = 1;
 259                 }
 260                 regs->ip = address;
 261                 return 1;
 262         }
 263         return 0;
 264 }
 265 #endif
 266
 267 static noinline void pgtable_bad(unsigned long address, struct pt_regs *regs,
 268                                  unsigned long error_code)
 269 {
 270         unsigned long flags = oops_begin();
 271         struct task_struct *tsk;
 272
 273         printk(KERN_ALERT "%s: Corrupted page table at address %lx\n",
 274                current->comm, address);
 275         dump_pagetable(address);
 276         tsk = current;
 277         tsk->thread.cr2 = address;
 278         tsk->thread.trap_no = 14;
 279         tsk->thread.error_code = error_code;
 280         if (__die("Bad pagetable", regs, error_code))
 281                 regs = NULL;
 282         oops_end(flags, regs, SIGKILL);
 283 }
 284
 285 /*
 286  * Handle a fault on the vmalloc area
 287  *
 288  * This assumes no large pages in there.
 289  */
 290 static int vmalloc_fault(unsigned long address)
 291 {
 292         pgd_t *pgd, *pgd_ref;
 293         pud_t *pud, *pud_ref;
 294         pmd_t *pmd, *pmd_ref;
 295         pte_t *pte, *pte_ref;
 296
 297         /* Copy kernel mappings over when needed. This can also
 298            happen within a race in page table update. In the later
 299            case just flush. */
 300
 301         pgd = pgd_offset(current->mm ?: &init_mm, address);
 302         pgd_ref = pgd_offset_k(address);
 303         if (pgd_none(*pgd_ref))
 304                 return -1;
 305         if (pgd_none(*pgd))
 306                 set_pgd(pgd, *pgd_ref);
 307         else
 308                 BUG_ON(pgd_page_vaddr(*pgd) != pgd_page_vaddr(*pgd_ref));
 309
 310         /* Below here mismatches are bugs because these lower tables
 311            are shared */
 312
 313         pud = pud_offset(pgd, address);
 314         pud_ref = pud_offset(pgd_ref, address);
 315         if (pud_none(*pud_ref))
 316                 return -1;
 317         if (pud_none(*pud) || pud_page_vaddr(*pud) != pud_page_vaddr(*pud_ref))
 318                 BUG();
 319         pmd = pmd_offset(pud, address);
 320         pmd_ref = pmd_offset(pud_ref, address);
 321         if (pmd_none(*pmd_ref))
 322                 return -1;
 323         if (pmd_none(*pmd) || pmd_page(*pmd) != pmd_page(*pmd_ref))
 324                 BUG();
 325         pte_ref = pte_offset_kernel(pmd_ref, address);
 326         if (!pte_present(*pte_ref))
 327                 return -1;
 328         pte = pte_offset_kernel(pmd, address);
 329         /* Don't use pte_page here, because the mappings can point
 330            outside mem_map, and the NUMA hash lookup cannot handle
 331            that. */
 332         if (!pte_present(*pte) || pte_pfn(*pte) != pte_pfn(*pte_ref))
 333                 BUG();
 334         return 0;
 335 }
 336
 337 int show_unhandled_signals = 1;
 338
 339 /*
 340  * This routine handles page faults.  It determines the address,
 341  * and the problem, and then passes it off to one of the appropriate
 342  * routines.
 343  */
 344 asmlinkage void __kprobes do_page_fault(struct pt_regs *regs,
 345                                         unsigned long error_code)
 346 {
 347         struct task_struct *tsk;
 348         struct mm_struct *mm;
 349         struct vm_area_struct *vma;
 350         unsigned long address;
 351         int write, fault;
 352         unsigned long flags;
 353         int si_code;
 354
 355         /*
 356          * We can fault from pretty much anywhere, with unknown IRQ state.
 357          */
 358         trace_hardirqs_fixup();
 359
 360         tsk = current;
 361         mm = tsk->mm;
 362         prefetchw(&mm->mmap_sem);
 363
 364         /* get the address */
 365         address = read_cr2();
 366
 367         si_code = SEGV_MAPERR;
 368
 369
 370         /*
 371          * We fault-in kernel-space virtual memory on-demand. The
 372          * 'reference' page table is init_mm.pgd.
 373          *
 374          * NOTE! We MUST NOT take any locks for this case. We may
 375          * be in an interrupt or a critical region, and should
 376          * only copy the information from the master page table,
 377          * nothing more.
 378          *
 379          * This verifies that the fault happens in kernel space
 380          * (error_code & 4) == 0, and that the fault was not a
 381          * protection error (error_code & 9) == 0.
 382          */
 383         if (unlikely(address >= TASK_SIZE64)) {
 384                 /*
 385                  * Don't check for the module range here: its PML4
 386                  * is always initialized because it's shared with the main
 387                  * kernel text. Only vmalloc may need PML4 syncups.
 388                  */
 389                 if (!(error_code & (PF_RSVD|PF_USER|PF_PROT)) &&
 390                       ((address >= VMALLOC_START && address < VMALLOC_END))) {
 391                         if (vmalloc_fault(address) >= 0)
 392                                 return;
 393                 }
 394                 if (notify_page_fault(regs))
 395                         return;
 396                 /*
 397                  * Don't take the mm semaphore here. If we fixup a prefetch
 398                  * fault we could otherwise deadlock.
 399                  */
 400                 goto bad_area_nosemaphore;
 401         }
 402
 403         if (notify_page_fault(regs))
 404                 return;
 405
 406         if (likely(regs->flags & X86_EFLAGS_IF))
 407                 local_irq_enable();
 408
 409         if (unlikely(error_code & PF_RSVD))
 410                 pgtable_bad(address, regs, error_code);
 411
 412         /*
 413          * If we're in an interrupt, have no user context or are running in an
 414          * atomic region then we must not take the fault.
 415          */
 416         if (unlikely(in_atomic() || !mm))
 417                 goto bad_area_nosemaphore;
 418
 419         /*
 420          * User-mode registers count as a user access even for any
 421          * potential system fault or CPU buglet.
 422          */
 423         if (user_mode_vm(regs))
 424                 error_code |= PF_USER;
 425
 426  again:
 427         /* When running in the kernel we expect faults to occur only to
 428          * addresses in user space.  All other faults represent errors in the
 429          * kernel and should generate an OOPS.  Unfortunately, in the case of an
 430          * erroneous fault occurring in a code path which already holds mmap_sem
 431          * we will deadlock attempting to validate the fault against the
 432          * address space.  Luckily the kernel only validly references user
 433          * space from well defined areas of code, which are listed in the
 434          * exceptions table.
 435          *
 436          * As the vast majority of faults will be valid we will only perform
 437          * the source reference check when there is a possibility of a deadlock.
 438          * Attempt to lock the address space, if we cannot we then validate the
 439          * source.  If this is invalid we can skip the address space check,
 440          * thus avoiding the deadlock.
 441          */
 442         if (!down_read_trylock(&mm->mmap_sem)) {
 443                 if ((error_code & PF_USER) == 0 &&
 444                     !search_exception_tables(regs->ip))
 445                         goto bad_area_nosemaphore;
 446                 down_read(&mm->mmap_sem);
 447         }
 448
 449         vma = find_vma(mm, address);
 450         if (!vma)
 451                 goto bad_area;
 452         if (likely(vma->vm_start <= address))
 453                 goto good_area;
 454         if (!(vma->vm_flags & VM_GROWSDOWN))
 455                 goto bad_area;
 456         if (error_code & PF_USER) {
 457                 /* Allow userspace just enough access below the stack pointer
 458                  * to let the 'enter' instruction work.
 459                  */
 460                 if (address + 65536 + 32 * sizeof(unsigned long) < regs->sp)
 461                         goto bad_area;
 462         }
 463         if (expand_stack(vma, address))
 464                 goto bad_area;
 465 /*
 466  * Ok, we have a good vm_area for this memory access, so
 467  * we can handle it..
 468  */
 469 good_area:
 470         si_code = SEGV_ACCERR;
 471         write = 0;
 472         switch (error_code & (PF_PROT|PF_WRITE)) {
 473         default:        /* 3: write, present */
 474                 /* fall through */
 475         case PF_WRITE:          /* write, not present */
 476                 if (!(vma->vm_flags & VM_WRITE))
 477                         goto bad_area;
 478                 write++;
 479                 break;
 480         case PF_PROT:           /* read, present */
 481                 goto bad_area;
 482         case 0:                 /* read, not present */
 483                 if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)))
 484                         goto bad_area;
 485         }
 486
 487         /*
 488          * If for any reason at all we couldn't handle the fault,
 489          * make sure we exit gracefully rather than endlessly redo
 490          * the fault.
 491          */
 492         fault = handle_mm_fault(mm, vma, address, write);
 493         if (unlikely(fault & VM_FAULT_ERROR)) {
 494                 if (fault & VM_FAULT_OOM)
 495                         goto out_of_memory;
 496                 else if (fault & VM_FAULT_SIGBUS)
 497                         goto do_sigbus;
 498                 BUG();
 499         }
 500         if (fault & VM_FAULT_MAJOR)
 501                 tsk->maj_flt++;
 502         else
 503                 tsk->min_flt++;
 504         up_read(&mm->mmap_sem);
 505         return;
 506
 507 /*
 508  * Something tried to access memory that isn't in our memory map..
 509  * Fix it, but check if it's kernel or user first..
 510  */
 511 bad_area:
 512         up_read(&mm->mmap_sem);
 513
 514 bad_area_nosemaphore:
 515         /* User mode accesses just cause a SIGSEGV */
 516         if (error_code & PF_USER) {
 517
 518                 /*
 519                  * It's possible to have interrupts off here.
 520                  */
 521                 local_irq_enable();
 522
 523                 if (is_prefetch(regs, address, error_code))
 524                         return;
 525
 526                 /* Work around K8 erratum #100 K8 in compat mode
 527                    occasionally jumps to illegal addresses >4GB.  We
 528                    catch this here in the page fault handler because
 529                    these addresses are not reachable. Just detect this
 530                    case and return.  Any code segment in LDT is
 531                    compatibility mode. */
 532                 if ((regs->cs == __USER32_CS || (regs->cs & (1<<2))) &&
 533                     (address >> 32))
 534                         return;
 535
 536                 if (show_unhandled_signals && unhandled_signal(tsk, SIGSEGV) &&
 537                     printk_ratelimit()) {
 538                         printk(
 539                        "%s%s[%d]: segfault at %lx ip %lx sp %lx error %lx\n",
 540                                         tsk->pid > 1 ? KERN_INFO : KERN_EMERG,
 541                                         tsk->comm, tsk->pid, address, regs->ip,
 542                                         regs->sp, error_code);
 543                 }
 544
 545                 tsk->thread.cr2 = address;
 546                 /* Kernel addresses are always protection faults */
 547                 tsk->thread.error_code = error_code | (address >= TASK_SIZE);
 548                 tsk->thread.trap_no = 14;
 549
 550                 force_sig_info_fault(SIGSEGV, si_code, address, tsk);
 551                 return;
 552         }
 553
 554 no_context:
 555         /* Are we prepared to handle this kernel fault?  */
 556         if (fixup_exception(regs))
 557                 return;
 558
 559         /*
 560          * Hall of shame of CPU/BIOS bugs.
 561          */
 562
 563         if (is_prefetch(regs, address, error_code))
 564                 return;
 565
 566         if (is_errata93(regs, address))
 567                 return;
 568
 569 /*
 570  * Oops. The kernel tried to access some bad page. We'll have to
 571  * terminate things with extreme prejudice.
 572  */
 573
 574         flags = oops_begin();
 575
 576         if (address < PAGE_SIZE)
 577                 printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
 578         else
 579                 printk(KERN_ALERT "Unable to handle kernel paging request");
 580         printk(" at %016lx RIP: \n" KERN_ALERT, address);
 581         printk_address(regs->ip, regs->bp);
 582         dump_pagetable(address);
 583         tsk->thread.cr2 = address;
 584         tsk->thread.trap_no = 14;
 585         tsk->thread.error_code = error_code;
 586         if (__die("Oops", regs, error_code))
 587                 regs = NULL;
 588         /* Executive summary in case the body of the oops scrolled away */
 589         printk(KERN_EMERG "CR2: %016lx\n", address);
 590         oops_end(flags, regs, SIGKILL);
 591
 592 /*
 593  * We ran out of memory, or some other thing happened to us that made
 594  * us unable to handle the page fault gracefully.
 595  */
 596 out_of_memory:
 597         up_read(&mm->mmap_sem);
 598         if (is_global_init(current)) {
 599                 yield();
 600                 goto again;
 601         }
 602         printk("VM: killing process %s\n", tsk->comm);
 603         if (error_code & PF_USER)
 604                 do_group_exit(SIGKILL);
 605         goto no_context;
 606
 607 do_sigbus:
 608         up_read(&mm->mmap_sem);
 609
 610         /* Kernel mode? Handle exceptions or die */
 611         if (!(error_code & PF_USER))
 612                 goto no_context;
 613
 614         tsk->thread.cr2 = address;
 615         tsk->thread.error_code = error_code;
 616         tsk->thread.trap_no = 14;
 617         force_sig_info_fault(SIGBUS, BUS_ADRERR, address, tsk);
 618         return;
 619 }
 620
 621 DEFINE_SPINLOCK(pgd_lock);
 622 LIST_HEAD(pgd_list);
 623
 624 void vmalloc_sync_all(void)
 625 {
 626         /* Note that races in the updates of insync and start aren't
 627            problematic:
 628            insync can only get set bits added, and updates to start are only
 629            improving performance (without affecting correctness if undone). */
 630         static DECLARE_BITMAP(insync, PTRS_PER_PGD);
 631         static unsigned long start = VMALLOC_START & PGDIR_MASK;
 632         unsigned long address;
 633
 634         for (address = start; address <= VMALLOC_END; address += PGDIR_SIZE) {
 635                 if (!test_bit(pgd_index(address), insync)) {
 636                         const pgd_t *pgd_ref = pgd_offset_k(address);
 637                         struct page *page;
 638
 639                         if (pgd_none(*pgd_ref))
 640                                 continue;
 641                         spin_lock(&pgd_lock);
 642                         list_for_each_entry(page, &pgd_list, lru) {
 643                                 pgd_t *pgd;
 644                                 pgd = (pgd_t *)page_address(page) + pgd_index(address);
 645                                 if (pgd_none(*pgd))
 646                                         set_pgd(pgd, *pgd_ref);
 647                                 else
 648                                         BUG_ON(pgd_page_vaddr(*pgd) != pgd_page_vaddr(*pgd_ref));
 649                         }
 650                         spin_unlock(&pgd_lock);
 651                         set_bit(pgd_index(address), insync);
 652                 }
 653                 if (address == start)
 654                         start = address + PGDIR_SIZE;
 655         }
 656         /* Check that there is no need to do the same for the modules area. */
 657         BUILD_BUG_ON(!(MODULES_VADDR > __START_KERNEL));
 658         BUILD_BUG_ON(!(((MODULES_END - 1) & PGDIR_MASK) ==
 659                                 (__START_KERNEL & PGDIR_MASK)));
 660 }