PAGE_SIZE 57 arch/x86/ia32/ia32_aout.c dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
PAGE_SIZE 60 arch/x86/ia32/ia32_aout.c (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
PAGE_SIZE 115 arch/x86/ia32/ia32_aout.c .min_coredump = PAGE_SIZE
PAGE_SIZE 186 arch/x86/ia32/ia32_aout.c if ((dump.u_dsize + dump.u_ssize + 1) * PAGE_SIZE > limit)
PAGE_SIZE 190 arch/x86/ia32/ia32_aout.c if ((dump.u_ssize + 1) * PAGE_SIZE > limit)
PAGE_SIZE 206 arch/x86/ia32/ia32_aout.c DUMP_SEEK(PAGE_SIZE);
PAGE_SIZE 133 arch/x86/kernel/acpi/boot.c offset = phys & (PAGE_SIZE - 1);
PAGE_SIZE 134 arch/x86/kernel/acpi/boot.c mapped_size = PAGE_SIZE - offset;
PAGE_SIZE 146 arch/x86/kernel/acpi/boot.c phys += PAGE_SIZE;
PAGE_SIZE 149 arch/x86/kernel/acpi/boot.c mapped_size += PAGE_SIZE;
PAGE_SIZE 13 arch/x86/kernel/acpi/sleep.h extern char swsusp_pg_dir[PAGE_SIZE];
PAGE_SIZE 509 arch/x86/kernel/alternative.c pages[1] = vmalloc_to_page(addr + PAGE_SIZE);
PAGE_SIZE 513 arch/x86/kernel/alternative.c pages[1] = virt_to_page(addr + PAGE_SIZE);
PAGE_SIZE 439 arch/x86/kernel/amd_iommu.c addr += PAGE_SIZE) {
PAGE_SIZE 500 arch/x86/kernel/amd_iommu.c PAGE_SIZE) >> PAGE_SHIFT;
PAGE_SIZE 523 arch/x86/kernel/amd_iommu.c WARN_ON((address + (PAGE_SIZE*pages)) > dom->aperture_size);
PAGE_SIZE 664 arch/x86/kernel/amd_iommu.c dma_dom->bitmap = kzalloc(dma_dom->aperture_size / (PAGE_SIZE * 8),
PAGE_SIZE 692 arch/x86/kernel/amd_iommu.c num_pte_pages = dma_dom->aperture_size / (PAGE_SIZE * 512);
PAGE_SIZE 952 arch/x86/kernel/amd_iommu.c paddr += PAGE_SIZE;
PAGE_SIZE 953 arch/x86/kernel/amd_iommu.c start += PAGE_SIZE;
PAGE_SIZE 989 arch/x86/kernel/amd_iommu.c start += PAGE_SIZE;
PAGE_SIZE 1270 arch/x86/kernel/apic_32.c apic_phys = (unsigned long) alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 1809 arch/x86/kernel/apic_32.c lapic_resource.end = lapic_resource.start + PAGE_SIZE - 1;
PAGE_SIZE 1216 arch/x86/kernel/apic_64.c apic_phys = (unsigned long) alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 1838 arch/x86/kernel/apic_64.c lapic_resource.end = lapic_resource.start + PAGE_SIZE - 1;
PAGE_SIZE 98 arch/x86/kernel/asm-offsets_32.c DEFINE(PAGE_SIZE_asm, PAGE_SIZE);
PAGE_SIZE 138 arch/x86/kernel/asm-offsets_64.c DEFINE(PAGE_SIZE_asm, PAGE_SIZE);
PAGE_SIZE 1013 arch/x86/kernel/cpu/common.c estacks += PAGE_SIZE << order[v];
PAGE_SIZE 622 arch/x86/kernel/cpu/intel_cacheinfo.c ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
PAGE_SIZE 49 arch/x86/kernel/cpu/mtrr/if.c if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)))
PAGE_SIZE 68 arch/x86/kernel/cpu/mtrr/if.c if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)))
PAGE_SIZE 407 arch/x86/kernel/cpu/mtrr/main.c if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
PAGE_SIZE 66 arch/x86/kernel/crash_dump_32.c kdump_buf_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 34 arch/x86/kernel/crash_dump_64.c vaddr = ioremap(pfn << PAGE_SHIFT, PAGE_SIZE);
PAGE_SIZE 625 arch/x86/kernel/e820.c if (map_len > PAGE_SIZE)
PAGE_SIZE 630 arch/x86/kernel/e820.c if (map_len > PAGE_SIZE)
PAGE_SIZE 679 arch/x86/kernel/e820.c { 0, PAGE_SIZE, "BIOS data page" }, /* BIOS data page */
PAGE_SIZE 681 arch/x86/kernel/e820.c { TRAMPOLINE_BASE, TRAMPOLINE_BASE + 2 * PAGE_SIZE, "TRAMPOLINE" },
PAGE_SIZE 689 arch/x86/kernel/e820.c { PAGE_SIZE, PAGE_SIZE + PAGE_SIZE, "EX TRAMPOLINE" },
PAGE_SIZE 694 arch/x86/kernel/e820.c { TRAMPOLINE_BASE, TRAMPOLINE_BASE + PAGE_SIZE, "TRAMPOLINE" },
PAGE_SIZE 1111 arch/x86/kernel/e820.c u64 align = PAGE_SIZE;
PAGE_SIZE 116 arch/x86/kernel/efi_64.c phys_addr += PAGE_SIZE;
PAGE_SIZE 2899 arch/x86/kernel/io_apic_32.c alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 2935 arch/x86/kernel/io_apic_64.c alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 39 arch/x86/kernel/ldt.c mincount = (mincount + (PAGE_SIZE / LDT_ENTRY_SIZE - 1)) &
PAGE_SIZE 40 arch/x86/kernel/ldt.c (~(PAGE_SIZE / LDT_ENTRY_SIZE - 1));
PAGE_SIZE 41 arch/x86/kernel/ldt.c if (mincount * LDT_ENTRY_SIZE > PAGE_SIZE)
PAGE_SIZE 80 arch/x86/kernel/ldt.c if (oldsize * LDT_ENTRY_SIZE > PAGE_SIZE)
PAGE_SIZE 135 arch/x86/kernel/ldt.c if (mm->context.size * LDT_ENTRY_SIZE > PAGE_SIZE)
PAGE_SIZE 28 arch/x86/kernel/machine_kexec_32.c #define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE)))
PAGE_SIZE 21 arch/x86/kernel/machine_kexec_64.c #define PAGE_ALIGNED __attribute__ ((__aligned__(PAGE_SIZE)))
PAGE_SIZE 194 arch/x86/kernel/machine_kexec_64.c control_page = page_address(image->control_code_page) + PAGE_SIZE;
PAGE_SIZE 195 arch/x86/kernel/machine_kexec_64.c memcpy(control_page, relocate_kernel, PAGE_SIZE);
PAGE_SIZE 721 arch/x86/kernel/mpparse.c reserve_bootmem_generic(virt_to_phys(mpf), PAGE_SIZE,
PAGE_SIZE 724 arch/x86/kernel/mpparse.c unsigned long size = PAGE_SIZE;
PAGE_SIZE 735 arch/x86/kernel/mpparse.c unsigned long end = max_low_pfn * PAGE_SIZE;
PAGE_SIZE 278 arch/x86/kernel/pci-calgary_64.c PAGE_SIZE) >> PAGE_SHIFT;
PAGE_SIZE 344 arch/x86/kernel/pci-calgary_64.c badend = bad_dma_address + (EMERGENCY_PAGES * PAGE_SIZE);
PAGE_SIZE 1458 arch/x86/kernel/pci-calgary_64.c saved_max_pfn : max_pfn) * PAGE_SIZE);
PAGE_SIZE 130 arch/x86/kernel/pci-dma.c unsigned long size = roundup((addr & ~PAGE_MASK) + len, PAGE_SIZE);
PAGE_SIZE 93 arch/x86/kernel/pci-gart_64.c PAGE_SIZE) >> PAGE_SHIFT;
PAGE_SIZE 95 arch/x86/kernel/pci-gart_64.c PAGE_SIZE) >> PAGE_SHIFT;
PAGE_SIZE 203 arch/x86/kernel/pci-gart_64.c if (size > PAGE_SIZE*EMERGENCY_PAGES) {
PAGE_SIZE 250 arch/x86/kernel/pci-gart_64.c phys_mem += PAGE_SIZE;
PAGE_SIZE 252 arch/x86/kernel/pci-gart_64.c return iommu_bus_base + iommu_page*PAGE_SIZE + (phys_mem & ~PAGE_MASK);
PAGE_SIZE 283 arch/x86/kernel/pci-gart_64.c if (dma_addr < iommu_bus_base + EMERGENCY_PAGES*PAGE_SIZE ||
PAGE_SIZE 364 arch/x86/kernel/pci-gart_64.c sout->dma_address += iommu_page*PAGE_SIZE + s->offset;
PAGE_SIZE 375 arch/x86/kernel/pci-gart_64.c addr += PAGE_SIZE;
PAGE_SIZE 439 arch/x86/kernel/pci-gart_64.c (ps->offset + ps->length) % PAGE_SIZE) {
PAGE_SIZE 271 arch/x86/kernel/setup.c PAGE_SIZE);
PAGE_SIZE 382 arch/x86/kernel/setup.c data = early_memremap(pa_data, PAGE_SIZE);
PAGE_SIZE 391 arch/x86/kernel/setup.c early_iounmap(data, PAGE_SIZE);
PAGE_SIZE 639 arch/x86/kernel/setup.c u64 addr = PAGE_SIZE; /* assume first page is reserved anyway */
PAGE_SIZE 657 arch/x86/kernel/setup.c corruption_check_size = round_up(corruption_check_size, PAGE_SIZE);
PAGE_SIZE 661 arch/x86/kernel/setup.c addr = find_e820_area_size(addr, &size, PAGE_SIZE);
PAGE_SIZE 959 arch/x86/kernel/setup.c high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
PAGE_SIZE 69 arch/x86/kernel/tce_64.c uaddr += PAGE_SIZE;
PAGE_SIZE 72 arch/x86/kernel/test_rodata.c if (start & (PAGE_SIZE - 1)) {
PAGE_SIZE 76 arch/x86/kernel/test_rodata.c if (end & (PAGE_SIZE - 1)) {
PAGE_SIZE 313 arch/x86/kernel/vmi_32.c int limit = PAGE_SIZE / sizeof(int);
PAGE_SIZE 1016 arch/x86/kvm/lapic.c memset(apic->regs, 0, PAGE_SIZE);
PAGE_SIZE 112 arch/x86/kvm/mmu.c #define PT64_BASE_ADDR_MASK (((1ULL << 52) - 1) & ~(u64)(PAGE_SIZE-1))
PAGE_SIZE 744 arch/x86/kvm/mmu.c for (pos = spt, end = pos + PAGE_SIZE / sizeof(u64); pos != end; pos++)
PAGE_SIZE 775 arch/x86/kvm/mmu.c sp->spt = mmu_memory_cache_alloc(&vcpu->arch.mmu_page_cache, PAGE_SIZE);
PAGE_SIZE 776 arch/x86/kvm/mmu.c sp->gfns = mmu_memory_cache_alloc(&vcpu->arch.mmu_page_cache, PAGE_SIZE);
PAGE_SIZE 380 arch/x86/kvm/svm.c memset(msrpm, 0xff, PAGE_SIZE * (1 << MSRPM_ALLOC_ORDER));
PAGE_SIZE 431 arch/x86/kvm/svm.c memset(iopm_va, 0xff, PAGE_SIZE * (1 << IOPM_ALLOC_ORDER));
PAGE_SIZE 1179 arch/x86/kvm/vmx.c if ((vmx_msr_high & 0x1fff) > PAGE_SIZE)
PAGE_SIZE 1725 arch/x86/kvm/vmx.c r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
PAGE_SIZE 1732 arch/x86/kvm/vmx.c r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE);
PAGE_SIZE 1735 arch/x86/kvm/vmx.c r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
PAGE_SIZE 1740 arch/x86/kvm/vmx.c RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1,
PAGE_SIZE 1767 arch/x86/kvm/vmx.c r = kvm_clear_guest_page(kvm, identity_map_pfn, 0, PAGE_SIZE);
PAGE_SIZE 1806 arch/x86/kvm/vmx.c kvm_userspace_mem.memory_size = PAGE_SIZE;
PAGE_SIZE 1830 arch/x86/kvm/vmx.c kvm_userspace_mem.memory_size = PAGE_SIZE;
PAGE_SIZE 2208 arch/x86/kvm/vmx.c .memory_size = PAGE_SIZE * 3,
PAGE_SIZE 3126 arch/x86/kvm/vmx.c vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 3132 arch/x86/kvm/vmx.c vmx->host_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 3275 arch/x86/kvm/vmx.c memset(va, 0xff, PAGE_SIZE);
PAGE_SIZE 3280 arch/x86/kvm/vmx.c memset(va, 0xff, PAGE_SIZE);
PAGE_SIZE 3284 arch/x86/kvm/vmx.c memset(va, 0xff, PAGE_SIZE);
PAGE_SIZE 206 arch/x86/kvm/x86.c unsigned offset = ((cr3 & (PAGE_SIZE-1)) >> 5) << 2;
PAGE_SIZE 1432 arch/x86/kvm/x86.c if (addr > (unsigned int)(-3 * PAGE_SIZE))
PAGE_SIZE 1485 arch/x86/kvm/x86.c if (alias->memory_size & (PAGE_SIZE - 1))
PAGE_SIZE 1487 arch/x86/kvm/x86.c if (alias->guest_phys_addr & (PAGE_SIZE - 1))
PAGE_SIZE 1843 arch/x86/kvm/x86.c unsigned offset = addr & (PAGE_SIZE-1);
PAGE_SIZE 1844 arch/x86/kvm/x86.c unsigned tocopy = min(bytes, (unsigned)PAGE_SIZE - offset);
PAGE_SIZE 2320 arch/x86/kvm/x86.c vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
PAGE_SIZE 2364 arch/x86/kvm/x86.c vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;
PAGE_SIZE 2386 arch/x86/kvm/x86.c in_page = PAGE_SIZE - offset_in_page(address);
PAGE_SIZE 2414 arch/x86/kvm/x86.c page = gva_to_page(vcpu, address + i * PAGE_SIZE);
PAGE_SIZE 3982 arch/x86/kvm/x86.c npages * PAGE_SIZE,
PAGE_SIZE 4001 arch/x86/kvm/x86.c old.npages * PAGE_SIZE);
PAGE_SIZE 567 arch/x86/kvm/x86_emulate.c size = min(15UL, PAGE_SIZE - offset_in_page(linear));
PAGE_SIZE 492 arch/x86/lguest/boot.c (__pa(pmdp)&(PAGE_SIZE-1))/4, 0);
PAGE_SIZE 758 arch/x86/lguest/boot.c THREAD_SIZE/PAGE_SIZE);
PAGE_SIZE 738 arch/x86/lib/usercopy_32.c unsigned long offset = ((unsigned long)to)%PAGE_SIZE;
PAGE_SIZE 739 arch/x86/lib/usercopy_32.c unsigned long len = PAGE_SIZE - offset;
PAGE_SIZE 64 arch/x86/mm/dump_pagetables.c #define PTE_LEVEL_MULT (PAGE_SIZE)
PAGE_SIZE 401 arch/x86/mm/fault.c if (address < PAGE_SIZE)
PAGE_SIZE 95 arch/x86/mm/gup.c } while (ptep++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 134 arch/x86/mm/gup.c } while (addr += PAGE_SIZE, addr != end);
PAGE_SIZE 191 arch/x86/mm/gup.c } while (addr += PAGE_SIZE, addr != end);
PAGE_SIZE 188 arch/x86/mm/hugetlbpage.c page = &pte_page(*pte)[vpfn % (HPAGE_SIZE/PAGE_SIZE)];
PAGE_SIZE 78 arch/x86/mm/init_32.c adr = __va(pfn * PAGE_SIZE);
PAGE_SIZE 79 arch/x86/mm/init_32.c memset(adr, 0, PAGE_SIZE);
PAGE_SIZE 80 arch/x86/mm/init_32.c *phys = pfn * PAGE_SIZE;
PAGE_SIZE 98 arch/x86/mm/init_32.c pmd_table = (pmd_t *)alloc_bootmem_low_pages(PAGE_SIZE);
PAGE_SIZE 124 arch/x86/mm/init_32.c page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 128 arch/x86/mm/init_32.c (pte_t *)alloc_bootmem_low_pages(PAGE_SIZE);
PAGE_SIZE 239 arch/x86/mm/init_32.c unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;
PAGE_SIZE 256 arch/x86/mm/init_32.c addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
PAGE_SIZE 257 arch/x86/mm/init_32.c PAGE_OFFSET + PAGE_SIZE-1;
PAGE_SIZE 277 arch/x86/mm/init_32.c pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
PAGE_SIZE 369 arch/x86/mm/init_32.c page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);
PAGE_SIZE 526 arch/x86/mm/init_32.c char swsusp_pg_dir[PAGE_SIZE]
PAGE_SIZE 527 arch/x86/mm/init_32.c __attribute__ ((aligned(PAGE_SIZE)));
PAGE_SIZE 531 arch/x86/mm/init_32.c memcpy(swsusp_pg_dir, swapper_pg_dir, PAGE_SIZE);
PAGE_SIZE 687 arch/x86/mm/init_32.c 64*1024*1024/PAGE_SIZE){
PAGE_SIZE 716 arch/x86/mm/init_32.c high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
PAGE_SIZE 721 arch/x86/mm/init_32.c high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
PAGE_SIZE 757 arch/x86/mm/init_32.c PAGE_SIZE);
PAGE_SIZE 793 arch/x86/mm/init_32.c ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 795 arch/x86/mm/init_32.c ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 800 arch/x86/mm/init_32.c tables += PAGE_SIZE * 2;
PAGE_SIZE 809 arch/x86/mm/init_32.c tables, PAGE_SIZE);
PAGE_SIZE 1024 arch/x86/mm/init_32.c PKMAP_BASE, PKMAP_BASE+LAST_PKMAP*PAGE_SIZE,
PAGE_SIZE 1025 arch/x86/mm/init_32.c (LAST_PKMAP*PAGE_SIZE) >> 10,
PAGE_SIZE 1045 arch/x86/mm/init_32.c BUG_ON(PKMAP_BASE + LAST_PKMAP*PAGE_SIZE > FIXADDR_START);
PAGE_SIZE 1157 arch/x86/mm/init_32.c for (addr = begin; addr < end; addr += PAGE_SIZE) {
PAGE_SIZE 1160 arch/x86/mm/init_32.c memset((void *)addr, POISON_FREE_INITMEM, PAGE_SIZE);
PAGE_SIZE 159 arch/x86/mm/init_64.c ptr = alloc_bootmem_pages(PAGE_SIZE);
PAGE_SIZE 313 arch/x86/mm/init_64.c adr = early_memremap(pfn * PAGE_SIZE, PAGE_SIZE);
PAGE_SIZE 314 arch/x86/mm/init_64.c memset(adr, 0, PAGE_SIZE);
PAGE_SIZE 315 arch/x86/mm/init_64.c *phys = pfn * PAGE_SIZE;
PAGE_SIZE 324 arch/x86/mm/init_64.c early_iounmap(adr, PAGE_SIZE);
PAGE_SIZE 337 arch/x86/mm/init_64.c for(i = pte_index(addr); i < PTRS_PER_PTE; i++, addr += PAGE_SIZE, pte++) {
PAGE_SIZE 361 arch/x86/mm/init_64.c last_map_addr = (addr & PAGE_MASK) + PAGE_SIZE;
PAGE_SIZE 550 arch/x86/mm/init_64.c tables = roundup(puds * sizeof(pud_t), PAGE_SIZE);
PAGE_SIZE 557 arch/x86/mm/init_64.c tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE);
PAGE_SIZE 562 arch/x86/mm/init_64.c ptes = (extra + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 564 arch/x86/mm/init_64.c ptes = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 565 arch/x86/mm/init_64.c tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE);
PAGE_SIZE 573 arch/x86/mm/init_64.c table_start = find_e820_area(start, end, tables, PAGE_SIZE);
PAGE_SIZE 791 arch/x86/mm/init_64.c PAGE_SIZE);
PAGE_SIZE 942 arch/x86/mm/init_64.c for (; addr < end; addr += PAGE_SIZE) {
PAGE_SIZE 945 arch/x86/mm/init_64.c memset((void *)(addr & ~(PAGE_SIZE-1)),
PAGE_SIZE 946 arch/x86/mm/init_64.c POISON_FREE_INITMEM, PAGE_SIZE);
PAGE_SIZE 968 arch/x86/mm/init_64.c ((unsigned long)__start_rodata + PAGE_SIZE - 1) & PAGE_MASK;
PAGE_SIZE 1043 arch/x86/mm/init_64.c if (phys+len <= MAX_DMA_PFN*PAGE_SIZE) {
PAGE_SIZE 1044 arch/x86/mm/init_64.c dma_reserve += len / PAGE_SIZE;
PAGE_SIZE 1091 arch/x86/mm/init_64.c .vm_end = VSYSCALL_START + (VSYSCALL_MAPPED_PAGES * PAGE_SIZE),
PAGE_SIZE 1164 arch/x86/mm/init_64.c next = (addr + PAGE_SIZE) & PAGE_MASK;
PAGE_SIZE 1175 arch/x86/mm/init_64.c addr_end = addr + PAGE_SIZE;
PAGE_SIZE 1176 arch/x86/mm/init_64.c p_end = p + PAGE_SIZE;
PAGE_SIZE 127 arch/x86/mm/ioremap.c addr = (e820.map[i].addr + PAGE_SIZE-1) >> PAGE_SHIFT;
PAGE_SIZE 478 arch/x86/mm/ioremap.c addr = (void __force *)ioremap_default(start, PAGE_SIZE);
PAGE_SIZE 505 arch/x86/mm/ioremap.c static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
PAGE_SIZE 703 arch/x86/mm/ioremap.c phys_addr += PAGE_SIZE;
PAGE_SIZE 380 arch/x86/mm/kmmio.c size += PAGE_SIZE;
PAGE_SIZE 456 arch/x86/mm/kmmio.c size += PAGE_SIZE;
PAGE_SIZE 104 arch/x86/mm/numa_32.c #define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE)
PAGE_SIZE 167 arch/x86/mm/numa_32.c PAGE_SIZE);
PAGE_SIZE 306 arch/x86/mm/numa_32.c (node_remap_size[nid] * PAGE_SIZE);
PAGE_SIZE 308 arch/x86/mm/numa_32.c ALIGN(sizeof(pg_data_t), PAGE_SIZE);
PAGE_SIZE 360 arch/x86/mm/numa_32.c high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
PAGE_SIZE 363 arch/x86/mm/numa_32.c high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
PAGE_SIZE 179 arch/x86/mm/numa_64.c const int pgdat_size = roundup(sizeof(pg_data_t), PAGE_SIZE);
PAGE_SIZE 213 arch/x86/mm/numa_64.c bootmap_start = roundup(nodedata_phys + pgdat_size, PAGE_SIZE);
PAGE_SIZE 215 arch/x86/mm/numa_64.c bootmap_start = roundup(start, PAGE_SIZE);
PAGE_SIZE 221 arch/x86/mm/numa_64.c bootmap_pages<<PAGE_SHIFT, PAGE_SIZE);
PAGE_SIZE 69 arch/x86/mm/pageattr-test.c i += GPS/PAGE_SIZE;
PAGE_SIZE 78 arch/x86/mm/pageattr-test.c i += LPS/PAGE_SIZE;
PAGE_SIZE 99 arch/x86/mm/pageattr-test.c expected = (s->gpg*GPS + s->lpg*LPS)/PAGE_SIZE + s->spg + missed;
PAGE_SIZE 150 arch/x86/mm/pageattr-test.c pte = lookup_address(addr[i] + k*PAGE_SIZE, &level);
PAGE_SIZE 194 arch/x86/mm/pageattr.c for (i = 0, addr = start; i < numpages; i++, addr += PAGE_SIZE) {
PAGE_SIZE 201 arch/x86/mm/pageattr.c clflush_cache_range((void *) addr, PAGE_SIZE);
PAGE_SIZE 236 arch/x86/mm/pageattr.c clflush_cache_range((void *) *addr, PAGE_SIZE);
PAGE_SIZE 415 arch/x86/mm/pageattr.c addr = address + PAGE_SIZE;
PAGE_SIZE 417 arch/x86/mm/pageattr.c for (i = 1; i < cpa->numpages; i++, addr += PAGE_SIZE, pfn++) {
PAGE_SIZE 745 arch/x86/mm/pageattr.c *cpa->vaddr += cpa->numpages * PAGE_SIZE;
PAGE_SIZE 869 arch/x86/mm/pageattr.c if (reserve_memtype(__pa(addr), __pa(addr) + numpages * PAGE_SIZE,
PAGE_SIZE 887 arch/x86/mm/pageattr.c for (end = start + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
PAGE_SIZE 904 arch/x86/mm/pageattr.c for (end = tmp + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
PAGE_SIZE 926 arch/x86/mm/pageattr.c if (reserve_memtype(__pa(addr), __pa(addr) + numpages * PAGE_SIZE,
PAGE_SIZE 942 arch/x86/mm/pageattr.c free_memtype(__pa(addr), __pa(addr) + numpages * PAGE_SIZE);
PAGE_SIZE 956 arch/x86/mm/pageattr.c for (end = start + PAGE_SIZE; i < addrinarray - 1; end += PAGE_SIZE) {
PAGE_SIZE 1093 arch/x86/mm/pageattr.c numpages * PAGE_SIZE);
PAGE_SIZE 497 arch/x86/mm/pat.c cursor += PAGE_SIZE;
PAGE_SIZE 112 arch/x86/mm/pgtable_32.c __FIXADDR_TOP = -reserve - PAGE_SIZE;
PAGE_SIZE 108 arch/x86/mm/srat_64.c PAGE_SIZE);
PAGE_SIZE 367 arch/x86/pci/pcbios.c opt.size = PAGE_SIZE;
PAGE_SIZE 334 arch/x86/vdso/vdso32-setup.c addr = get_unmapped_area(NULL, 0, PAGE_SIZE, 0, 0);
PAGE_SIZE 351 arch/x86/vdso/vdso32-setup.c ret = install_special_mapping(mm, addr, PAGE_SIZE,
PAGE_SIZE 38 arch/x86/vdso/vma.c int npages = (vdso_end - vdso_start + PAGE_SIZE - 1) / PAGE_SIZE;
PAGE_SIZE 52 arch/x86/vdso/vma.c copy_page(page_address(p), vdso_start + i*PAGE_SIZE);
PAGE_SIZE 287 arch/x86/xen/enlighten.c const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
PAGE_SIZE 296 arch/x86/xen/enlighten.c const unsigned entries_per_page = PAGE_SIZE / LDT_ENTRY_SIZE;
PAGE_SIZE 323 arch/x86/xen/enlighten.c unsigned pages = (size + PAGE_SIZE - 1) / PAGE_SIZE;
PAGE_SIZE 336 arch/x86/xen/enlighten.c for (f = 0; va < dtr->address + size; va += PAGE_SIZE, f++) {
PAGE_SIZE 1570 arch/x86/xen/enlighten.c xen_start_info->nr_pt_frames * PAGE_SIZE),
PAGE_SIZE 1583 arch/x86/xen/enlighten.c init_pg_tables_end = __pa(pgd) + xen_start_info->nr_pt_frames*PAGE_SIZE;
PAGE_SIZE 74 arch/x86/xen/grant-table.c xen_alloc_vm_area(PAGE_SIZE * max_nr_gframes);
PAGE_SIZE 81 arch/x86/xen/grant-table.c PAGE_SIZE * nr_gframes,
PAGE_SIZE 90 arch/x86/xen/grant-table.c PAGE_SIZE * nr_gframes, unmap_pte_fn, NULL);
PAGE_SIZE 124 arch/x86/xen/mmu.c #define P2M_ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(unsigned long))
PAGE_SIZE 133 block/blk-map.c end = ((unsigned long)ubuf + map_len + PAGE_SIZE - 1)
PAGE_SIZE 143 block/blk-map.c map_len -= PAGE_SIZE;
PAGE_SIZE 204 block/blk-merge.c (PAGE_SIZE - 1));
PAGE_SIZE 457 block/blk-settings.c BUG_ON(mask > PAGE_SIZE);
PAGE_SIZE 401 block/scsi_ioctl.c if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
PAGE_SIZE 89 crypto/ablkcipher.c if (alg->ivsize > PAGE_SIZE / 8)
PAGE_SIZE 141 crypto/ablkcipher.c if (alg->ivsize > PAGE_SIZE / 8)
PAGE_SIZE 95 crypto/aead.c if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8)
PAGE_SIZE 150 crypto/aead.c if (max(alg->maxauthsize, alg->ivsize) > PAGE_SIZE / 8)
PAGE_SIZE 32 crypto/ahash.c ((unsigned int)(PAGE_SIZE)) - offset);
PAGE_SIZE 73 crypto/ahash.c ((unsigned int)(PAGE_SIZE)) - walk->offset);
PAGE_SIZE 160 crypto/ahash.c if (alg->digestsize > PAGE_SIZE / 8)
PAGE_SIZE 66 crypto/algapi.c if (alg->cra_blocksize > PAGE_SIZE / 8)
PAGE_SIZE 272 crypto/blkcipher.c walk->src.phys.offset &= PAGE_SIZE - 1;
PAGE_SIZE 273 crypto/blkcipher.c walk->dst.phys.offset &= PAGE_SIZE - 1;
PAGE_SIZE 486 crypto/blkcipher.c if (alg->ivsize > PAGE_SIZE / 8)
PAGE_SIZE 55 crypto/digest.c (PAGE_SIZE)) -
PAGE_SIZE 145 crypto/digest.c if (dalg->dia_digestsize > PAGE_SIZE / 8)
PAGE_SIZE 228 crypto/digest.c if (dalg->dia_digestsize > PAGE_SIZE / 8)
PAGE_SIZE 155 crypto/hash.c if (alg->digestsize > PAGE_SIZE / 8)
PAGE_SIZE 61 crypto/scatterwalk.c walk->offset += PAGE_SIZE - 1;
PAGE_SIZE 168 crypto/tcrypt.c if ((*keysize + *b_size) > TVMEMSIZE * PAGE_SIZE) {
PAGE_SIZE 171 crypto/tcrypt.c TVMEMSIZE * PAGE_SIZE);
PAGE_SIZE 178 crypto/tcrypt.c memset(tvmem[0], 0xff, PAGE_SIZE);
PAGE_SIZE 198 crypto/tcrypt.c PAGE_SIZE - *keysize);
PAGE_SIZE 200 crypto/tcrypt.c sg_set_buf(sg + j, tvmem[j], PAGE_SIZE);
PAGE_SIZE 201 crypto/tcrypt.c memset (tvmem[j], 0xff, PAGE_SIZE);
PAGE_SIZE 424 crypto/tcrypt.c sg_set_buf(sg + i, tvmem[i], PAGE_SIZE);
PAGE_SIZE 425 crypto/tcrypt.c memset(tvmem[i], 0xff, PAGE_SIZE);
PAGE_SIZE 429 crypto/tcrypt.c if (speed[i].blen > TVMEMSIZE * PAGE_SIZE) {
PAGE_SIZE 431 crypto/tcrypt.c speed[i].blen, TVMEMSIZE * PAGE_SIZE);
PAGE_SIZE 415 crypto/testmgr.c template[i].tap[k] > PAGE_SIZE))
PAGE_SIZE 427 crypto/testmgr.c if (offset_in_page(q) + n < PAGE_SIZE)
PAGE_SIZE 445 crypto/testmgr.c PAGE_SIZE)) {
PAGE_SIZE 740 crypto/testmgr.c template[i].tap[k] > PAGE_SIZE))
PAGE_SIZE 750 crypto/testmgr.c PAGE_SIZE)
PAGE_SIZE 131 crypto/xcbc.c unsigned int len = min(slen, ((unsigned int)(PAGE_SIZE)) - offset);
PAGE_SIZE 141 crypto/xcbc.c if (len + offset >= PAGE_SIZE) {
PAGE_SIZE 179 crypto/xcbc.c slen -= min(slen, ((unsigned int)(PAGE_SIZE)) - offset);
PAGE_SIZE 59 crypto/xor.c #define BENCH_SIZE (PAGE_SIZE)
PAGE_SIZE 109 crypto/xor.c b2 = b1 + 2*PAGE_SIZE + BENCH_SIZE;
PAGE_SIZE 36 fs/affs/affs.h #define AFFS_CACHE_SIZE PAGE_SIZE
PAGE_SIZE 17 fs/affs/file.c #if PAGE_SIZE < 4096
PAGE_SIZE 317 fs/affs/super.c affs_set_blocksize(sb, PAGE_SIZE);
PAGE_SIZE 116 fs/afs/dir.c union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
PAGE_SIZE 151 fs/afs/dir.c if (latter >= PAGE_SIZE)
PAGE_SIZE 152 fs/afs/dir.c qty = PAGE_SIZE;
PAGE_SIZE 355 fs/afs/dir.c page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key);
PAGE_SIZE 361 fs/afs/dir.c limit = blkoff & ~(PAGE_SIZE - 1);
PAGE_SIZE 367 fs/afs/dir.c dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
PAGE_SIZE 189 fs/afs/file.c len = min_t(size_t, i_size_read(inode) - offset, PAGE_SIZE);
PAGE_SIZE 356 fs/afs/fsclient.c if (call->count > PAGE_SIZE)
PAGE_SIZE 409 fs/afs/fsclient.c if (call->count < PAGE_SIZE) {
PAGE_SIZE 413 fs/afs/fsclient.c memset(buffer + call->count, 0, PAGE_SIZE - call->count);
PAGE_SIZE 153 fs/afs/mntpt.c if (size > PAGE_SIZE - 1)
PAGE_SIZE 256 fs/afs/proc.c if (size <= 1 || size >= PAGE_SIZE)
PAGE_SIZE 354 fs/afs/proc.c if (size <= 1 || size >= PAGE_SIZE)
PAGE_SIZE 267 fs/afs/rxrpc.c to = PAGE_SIZE;
PAGE_SIZE 144 fs/afs/super.c options[PAGE_SIZE - 1] = 0;
PAGE_SIZE 93 fs/afs/write.c ASSERTCMP(start + len, <=, PAGE_SIZE);
PAGE_SIZE 122 fs/afs/write.c if (offset == 0 && to == PAGE_SIZE)
PAGE_SIZE 134 fs/afs/write.c if (to < PAGE_SIZE)
PAGE_SIZE 135 fs/afs/write.c memset(p + to, 0, PAGE_SIZE - to);
PAGE_SIZE 140 fs/afs/write.c if (i_size - pos >= PAGE_SIZE) {
PAGE_SIZE 143 fs/afs/write.c tail = eof = PAGE_SIZE;
PAGE_SIZE 149 fs/afs/write.c if (tail < PAGE_SIZE)
PAGE_SIZE 150 fs/afs/write.c memset(p + tail, 0, PAGE_SIZE - tail);
PAGE_SIZE 152 fs/afs/write.c memset(p + eof, 0, PAGE_SIZE - eof);
PAGE_SIZE 439 fs/afs/write.c to = (last == wb->last) ? wb->to_last : PAGE_SIZE;
PAGE_SIZE 799 fs/afs/write.c wb->to_last = PAGE_SIZE;
PAGE_SIZE 115 fs/aio.c nr_pages = (size + PAGE_SIZE-1) >> PAGE_SHIFT;
PAGE_SIZE 120 fs/aio.c nr_events = (PAGE_SIZE * nr_pages - sizeof(struct aio_ring)) / sizeof(struct io_event);
PAGE_SIZE 130 fs/aio.c info->mmap_size = nr_pages * PAGE_SIZE;
PAGE_SIZE 175 fs/aio.c #define AIO_EVENTS_PER_PAGE (PAGE_SIZE / sizeof(struct io_event))
PAGE_SIZE 176 fs/aio.c #define AIO_EVENTS_FIRST_PAGE ((PAGE_SIZE - sizeof(struct aio_ring)) / sizeof(struct io_event))
PAGE_SIZE 85 fs/befs/super.c if (befs_sb->block_size > PAGE_SIZE) {
PAGE_SIZE 88 fs/befs/super.c PAGE_SIZE);
PAGE_SIZE 310 fs/bfs/inode.c if (i > PAGE_SIZE - 100) break;
PAGE_SIZE 42 fs/binfmt_aout.c .min_coredump = PAGE_SIZE
PAGE_SIZE 108 fs/binfmt_aout.c # define START_STACK(u) ((regs->u_regs[UREG_FP]) & ~(PAGE_SIZE - 1))
PAGE_SIZE 130 fs/binfmt_aout.c if ((dump.u_dsize + dump.u_ssize+1) * PAGE_SIZE > limit)
PAGE_SIZE 139 fs/binfmt_aout.c if ((dump.u_ssize + 1) * PAGE_SIZE > limit)
PAGE_SIZE 162 fs/binfmt_aout.c DUMP_SEEK(PAGE_SIZE);
PAGE_SIZE 352 fs/binfmt_aout.c map_size = ex.a_text+ex.a_data + PAGE_SIZE - 1;
PAGE_SIZE 60 fs/binfmt_elf.c #if ELF_EXEC_PAGESIZE > PAGE_SIZE
PAGE_SIZE 63 fs/binfmt_elf.c #define ELF_MIN_ALIGN PAGE_SIZE
PAGE_SIZE 986 fs/binfmt_elf.c error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
PAGE_SIZE 1142 fs/binfmt_elf.c if (n > PAGE_SIZE)
PAGE_SIZE 1143 fs/binfmt_elf.c n = PAGE_SIZE;
PAGE_SIZE 1207 fs/binfmt_elf.c return PAGE_SIZE;
PAGE_SIZE 2010 fs/binfmt_elf.c for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
PAGE_SIZE 2016 fs/binfmt_elf.c DUMP_SEEK(PAGE_SIZE);
PAGE_SIZE 2019 fs/binfmt_elf.c if (!dump_seek(file, PAGE_SIZE)) {
PAGE_SIZE 2028 fs/binfmt_elf.c if ((size += PAGE_SIZE) > limit ||
PAGE_SIZE 2030 fs/binfmt_elf.c PAGE_SIZE)) {
PAGE_SIZE 375 fs/binfmt_elf_fdpic.c stack_size = (stack_size + PAGE_SIZE - 1) & PAGE_MASK;
PAGE_SIZE 376 fs/binfmt_elf_fdpic.c if (stack_size < PAGE_SIZE * 2)
PAGE_SIZE 377 fs/binfmt_elf_fdpic.c stack_size = PAGE_SIZE * 2;
PAGE_SIZE 402 fs/binfmt_elf_fdpic.c (stack_size > PAGE_SIZE) ? (stack_size - PAGE_SIZE) : 0;
PAGE_SIZE 581 fs/binfmt_elf_fdpic.c NEW_AUX_ENT(AT_PAGESZ, PAGE_SIZE);
PAGE_SIZE 622 fs/binfmt_elf_fdpic.c (MAX_ARG_PAGES * PAGE_SIZE - bprm->p);
PAGE_SIZE 670 fs/binfmt_elf_fdpic.c sp -= PAGE_SIZE;
PAGE_SIZE 671 fs/binfmt_elf_fdpic.c if (copy_to_user((void *) sp, src, PAGE_SIZE) != 0)
PAGE_SIZE 678 fs/binfmt_elf_fdpic.c *_sp = (*_sp - (MAX_ARG_PAGES * PAGE_SIZE - bprm->p)) & ~15;
PAGE_SIZE 1095 fs/binfmt_elf_fdpic.c excess1 = PAGE_SIZE - ((maddr + phdr->p_filesz) & ~PAGE_MASK);
PAGE_SIZE 1486 fs/binfmt_elf_fdpic.c addr += PAGE_SIZE
PAGE_SIZE 1493 fs/binfmt_elf_fdpic.c DUMP_SEEK(file->f_pos + PAGE_SIZE);
PAGE_SIZE 1497 fs/binfmt_elf_fdpic.c DUMP_SEEK(file->f_pos + PAGE_SIZE);
PAGE_SIZE 1504 fs/binfmt_elf_fdpic.c if ((*size += PAGE_SIZE) > *limit ||
PAGE_SIZE 1505 fs/binfmt_elf_fdpic.c !dump_write(file, kaddr, PAGE_SIZE)
PAGE_SIZE 1539 fs/binfmt_elf_fdpic.c if ((*size += PAGE_SIZE) > *limit)
PAGE_SIZE 83 fs/binfmt_flat.c .min_coredump = PAGE_SIZE
PAGE_SIZE 865 fs/binfmt_flat.c #define TOP_OF_ARGS (PAGE_SIZE * MAX_ARG_PAGES - sizeof(void *))
PAGE_SIZE 894 fs/binfmt_flat.c ((char *) page_address(bprm->page[i/PAGE_SIZE]))[i % PAGE_SIZE];
PAGE_SIZE 380 fs/bio-integrity.c end = (((unsigned long) buf) + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 400 fs/bio-integrity.c bytes = PAGE_SIZE - offset;
PAGE_SIZE 335 fs/bio.c nr_pages = ((q->max_sectors << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 645 fs/bio.c end = (uaddr + iov[i].iov_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 671 fs/bio.c bytes = PAGE_SIZE;
PAGE_SIZE 760 fs/bio.c unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 786 fs/bio.c unsigned long end = (uaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 800 fs/bio.c unsigned int bytes = PAGE_SIZE - offset;
PAGE_SIZE 952 fs/bio.c unsigned long end = (kaddr + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 964 fs/bio.c unsigned int bytes = PAGE_SIZE - offset;
PAGE_SIZE 74 fs/block_dev.c if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
PAGE_SIZE 929 fs/buffer.c offset = PAGE_SIZE;
PAGE_SIZE 1091 fs/buffer.c } while ((size << sizebits) < PAGE_SIZE);
PAGE_SIZE 1123 fs/buffer.c (size < 512 || size > PAGE_SIZE))) {
PAGE_SIZE 1474 fs/buffer.c BUG_ON(offset >= PAGE_SIZE);
PAGE_SIZE 3345 fs/buffer.c max_buffer_heads = nrpages * (PAGE_SIZE / sizeof(struct buffer_head));
PAGE_SIZE 1533 fs/cifs/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 1535 fs/cifs/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 29 fs/coda/symlink.c unsigned int len = PAGE_SIZE;
PAGE_SIZE 534 fs/compat.c #define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *))
PAGE_SIZE 1285 fs/compat.c offset = pos % PAGE_SIZE;
PAGE_SIZE 1287 fs/compat.c offset = PAGE_SIZE;
PAGE_SIZE 2749 fs/compat_ioctl.c fn = d_path(&filp->f_path, path, PAGE_SIZE);
PAGE_SIZE 168 fs/configfs/dir.c inode->i_size = PAGE_SIZE;
PAGE_SIZE 2112 fs/dcache.c cwd = __d_path(&pwd, &tmp, page, PAGE_SIZE);
PAGE_SIZE 2120 fs/dcache.c len = PAGE_SIZE + page - cwd;
PAGE_SIZE 169 fs/dcookies.c kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 174 fs/dcookies.c path = d_path(&dcs->path, kbuf, PAGE_SIZE);
PAGE_SIZE 183 fs/dcookies.c pathlen = kbuf + PAGE_SIZE - path;
PAGE_SIZE 211 fs/dcookies.c dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 222 fs/dcookies.c hash_size = PAGE_SIZE / sizeof(struct list_head);
PAGE_SIZE 177 fs/direct-io.c dio->curr_user_address += ret * PAGE_SIZE;
PAGE_SIZE 578 fs/direct-io.c if ((dio->cur_page_len + dio->cur_page_offset) == PAGE_SIZE)
PAGE_SIZE 787 fs/direct-io.c const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
PAGE_SIZE 895 fs/direct-io.c u = (PAGE_SIZE - offset_in_page) >> blkbits;
PAGE_SIZE 973 fs/direct-io.c ((user_addr+iov[seg].iov_len +PAGE_SIZE-1)/PAGE_SIZE
PAGE_SIZE 974 fs/direct-io.c - user_addr/PAGE_SIZE);
PAGE_SIZE 991 fs/direct-io.c if (user_addr & (PAGE_SIZE-1)) {
PAGE_SIZE 993 fs/direct-io.c bytes -= PAGE_SIZE - (user_addr & (PAGE_SIZE - 1));
PAGE_SIZE 995 fs/direct-io.c dio->total_pages += (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
PAGE_SIZE 152 fs/dlm/config.c return snprintf(buf, PAGE_SIZE, "%u\n", cl->cl_##name); \
PAGE_SIZE 68 fs/dlm/lockspace.c return snprintf(buf, PAGE_SIZE, "%u\n", ls->ls_global_id);
PAGE_SIZE 80 fs/dlm/lockspace.c return snprintf(buf, PAGE_SIZE, "%x\n", status);
PAGE_SIZE 85 fs/dlm/lockspace.c return snprintf(buf, PAGE_SIZE, "%d\n", ls->ls_recover_nodeid);
PAGE_SIZE 2161 fs/dquot.c nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
PAGE_SIZE 2174 fs/dquot.c nr_hash, order, (PAGE_SIZE << order));
PAGE_SIZE 662 fs/ecryptfs/inode.c int len = PAGE_SIZE, rc;
PAGE_SIZE 706 fs/ecryptfs/main.c return snprintf(buff, PAGE_SIZE, "%d\n", ECRYPTFS_VERSIONING_MASK);
PAGE_SIZE 256 fs/exec.c vma->vm_start = vma->vm_end - PAGE_SIZE;
PAGE_SIZE 294 fs/exec.c page = bprm->page[pos / PAGE_SIZE];
PAGE_SIZE 299 fs/exec.c bprm->page[pos / PAGE_SIZE] = page;
PAGE_SIZE 332 fs/exec.c bprm->p = PAGE_SIZE * MAX_ARG_PAGES - sizeof(void *);
PAGE_SIZE 439 fs/exec.c offset = pos % PAGE_SIZE;
PAGE_SIZE 441 fs/exec.c offset = PAGE_SIZE;
PAGE_SIZE 651 fs/exec.c stack_base = vma->vm_end + EXTRA_STACK_VM_PAGES * PAGE_SIZE;
PAGE_SIZE 653 fs/exec.c stack_base = vma->vm_start - EXTRA_STACK_VM_PAGES * PAGE_SIZE;
PAGE_SIZE 1142 fs/exec.c for (; offset < PAGE_SIZE && kaddr[offset];
PAGE_SIZE 1149 fs/exec.c if (offset == PAGE_SIZE)
PAGE_SIZE 1151 fs/exec.c } while (offset == PAGE_SIZE);
PAGE_SIZE 868 fs/ext2/super.c if (ext2_use_xip(sb) && blocksize != PAGE_SIZE) {
PAGE_SIZE 1171 fs/ext2/super.c if ((ext2_use_xip(sb)) && (sb->s_blocksize != PAGE_SIZE)) {
PAGE_SIZE 25 fs/ext2/xip.c sector = block * (PAGE_SIZE / 512); /* ext2 block to bdev sector */
PAGE_SIZE 43 fs/file.c if (size <= PAGE_SIZE)
PAGE_SIZE 51 fs/file.c if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *)))
PAGE_SIZE 59 fs/file.c if (fdt->max_fds <= (PAGE_SIZE * BITS_PER_BYTE / 2))
PAGE_SIZE 100 fs/file.c if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *))) {
PAGE_SIZE 400 fs/file_table.c n = (mempages * (PAGE_SIZE / 1024)) / 10;
PAGE_SIZE 207 fs/filesystems.c while (tmp && len < PAGE_SIZE - 80) {
PAGE_SIZE 135 fs/freevxfs/vxfs_inode.c offset = (ino % (PAGE_SIZE / VXFS_ISIZE)) * VXFS_ISIZE;
PAGE_SIZE 136 fs/freevxfs/vxfs_inode.c pp = vxfs_get_page(ilistp->i_mapping, ino * VXFS_ISIZE / PAGE_SIZE);
PAGE_SIZE 552 fs/fuse/dev.c offset = cs->addr % PAGE_SIZE;
PAGE_SIZE 555 fs/fuse/dev.c cs->len = min(PAGE_SIZE - offset, cs->seglen);
PAGE_SIZE 586 fs/fuse/dev.c if (page && zeroing && count < PAGE_SIZE) {
PAGE_SIZE 588 fs/fuse/dev.c memset(mapaddr, 0, PAGE_SIZE);
PAGE_SIZE 615 fs/fuse/dev.c unsigned count = min(nbytes, (unsigned) PAGE_SIZE - offset);
PAGE_SIZE 624 fs/fuse/dev.c count = min(nbytes, (unsigned) PAGE_SIZE);
PAGE_SIZE 1028 fs/fuse/dir.c fuse_read_fill(req, file, inode, file->f_pos, PAGE_SIZE, FUSE_READDIR);
PAGE_SIZE 1061 fs/fuse/dir.c req->out.args[0].size = PAGE_SIZE - 1;
PAGE_SIZE 938 fs/fuse/file.c npages = (nbytes + offset + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 121 fs/fuse/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 123 fs/fuse/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 290 fs/gfs2/ops_fstype.c bio_add_page(bio, page, PAGE_SIZE, 0);
PAGE_SIZE 566 fs/gfs2/ops_fstype.c if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
PAGE_SIZE 570 fs/gfs2/ops_fstype.c sdp->sd_sb.sb_bsize, (unsigned int)PAGE_SIZE);
PAGE_SIZE 207 fs/gfs2/quota.c for (o = 0; o < PAGE_SIZE; o++) {
PAGE_SIZE 219 fs/gfs2/quota.c qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;
PAGE_SIZE 1116 fs/gfs2/quota.c sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
PAGE_SIZE 1126 fs/gfs2/quota.c sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);
PAGE_SIZE 34 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%u:%u\n",
PAGE_SIZE 40 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%s\n", sdp->sd_fsname);
PAGE_SIZE 51 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%u\n", count);
PAGE_SIZE 83 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%u\n", b);
PAGE_SIZE 224 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, fmt, sdp->sd_lockstruct.ls_##name); \
PAGE_SIZE 253 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, fmt, sdp->sd_args.ar_##name); \
PAGE_SIZE 302 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, fmt, \
PAGE_SIZE 320 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%u %u\n",
PAGE_SIZE 376 fs/gfs2/sys.c return snprintf(buf, PAGE_SIZE, "%u\n", sdp->sd_tune.gt_##name); \
PAGE_SIZE 253 fs/gfs2/util.c c = b / (8 * PAGE_SIZE);
PAGE_SIZE 254 fs/gfs2/util.c b %= 8 * PAGE_SIZE;
PAGE_SIZE 107 fs/hfs/mdb.c size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE);
PAGE_SIZE 168 fs/hfs/mdb.c HFS_SB(sb)->bitmap = (__be32 *)__get_free_pages(GFP_KERNEL, PAGE_SIZE < 8192 ? 1 : 0);
PAGE_SIZE 146 fs/hfsplus/wrapper.c blocksize = min(HFSPLUS_SB(sb).alloc_blksz, (u32)PAGE_SIZE);
PAGE_SIZE 523 fs/hpfs/namei.c err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE);
PAGE_SIZE 25 fs/hppfs/hppfs.c char contents[PAGE_SIZE - sizeof(struct list_head)];
PAGE_SIZE 218 fs/hppfs/hppfs.c new_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 225 fs/hppfs/hppfs.c cur = min_t(ssize_t, count, PAGE_SIZE);
PAGE_SIZE 83 fs/isofs/joliet.c de->name_len[0] >> 1, PAGE_SIZE);
PAGE_SIZE 729 fs/isofs/rock.c link + (PAGE_SIZE - 1));
PAGE_SIZE 33 fs/jffs2/compr_lzo.c lzo_compress_buf = vmalloc(lzo1x_worst_compress(PAGE_SIZE));
PAGE_SIZE 362 fs/jffs2/erase.c ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 371 fs/jffs2/erase.c uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
PAGE_SIZE 118 fs/jffs2/scan.c buf_size = PAGE_SIZE;
PAGE_SIZE 3195 fs/jfs/jfs_dtree.c (dirent_buf + PAGE_SIZE)) {
PAGE_SIZE 1851 fs/jfs/jfs_logmgr.c for (offset = 0; offset < PAGE_SIZE; offset += LOGPSIZE) {
PAGE_SIZE 219 fs/libfs.c s->s_blocksize = PAGE_SIZE;
PAGE_SIZE 35 fs/namespace.c #define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head))
PAGE_SIZE 1659 fs/namespace.c if (!type || !memchr(type, 0, PAGE_SIZE))
PAGE_SIZE 1874 fs/namespace.c if (size > PAGE_SIZE)
PAGE_SIZE 1875 fs/namespace.c size = PAGE_SIZE;
PAGE_SIZE 1882 fs/namespace.c if (i != PAGE_SIZE)
PAGE_SIZE 1883 fs/namespace.c memset((char *)page + i, 0, PAGE_SIZE - i);
PAGE_SIZE 1915 fs/namespace.c if (!dir_name || !*dir_name || !memchr(dir_name, 0, PAGE_SIZE))
PAGE_SIZE 1917 fs/namespace.c if (dev_name && !memchr(dev_name, 0, PAGE_SIZE))
PAGE_SIZE 1921 fs/namespace.c ((char *)data_page)[PAGE_SIZE - 1] = 0;
PAGE_SIZE 52 fs/ncpfs/mmap.c count = PAGE_SIZE;
PAGE_SIZE 84 fs/ncpfs/mmap.c if (already_read < PAGE_SIZE)
PAGE_SIZE 85 fs/ncpfs/mmap.c memset(pg_addr + already_read, 0, PAGE_SIZE - already_read);
PAGE_SIZE 382 fs/nfs/callback_xdr.c if (maxlen > 0 && maxlen < PAGE_SIZE) {
PAGE_SIZE 1476 fs/nfs/dir.c if (pathlen > PAGE_SIZE)
PAGE_SIZE 1488 fs/nfs/dir.c if (pathlen < PAGE_SIZE)
PAGE_SIZE 1489 fs/nfs/dir.c memset(kaddr + pathlen, 0, PAGE_SIZE - pathlen);
PAGE_SIZE 133 fs/nfs/direct.c npages = (count + (pgbase & ~PAGE_MASK) + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 318 fs/nfs/direct.c bytes = result * PAGE_SIZE;
PAGE_SIZE 732 fs/nfs/direct.c bytes = result * PAGE_SIZE;
PAGE_SIZE 236 fs/nfs/inode.c #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
PAGE_SIZE 434 fs/nfs/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 436 fs/nfs/inode.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 276 fs/nfs/internal.h PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 237 fs/nfs/namespace.c devname = nfs_devname(mnt_parent, dentry, page, PAGE_SIZE);
PAGE_SIZE 79 fs/nfs/nfs4namespace.c path = nfs4_path(mnt_parent, dentry, page, PAGE_SIZE);
PAGE_SIZE 83 fs/nfs/nfs4namespace.c fs_path = nfs4_pathname_string(&locations->fs_path, page2, PAGE_SIZE);
PAGE_SIZE 166 fs/nfs/nfs4namespace.c mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
PAGE_SIZE 191 fs/nfs/nfs4namespace.c snprintf(page, PAGE_SIZE, "%s:%s",
PAGE_SIZE 2603 fs/nfs/nfs4proc.c if (buf && acl_len <= PAGE_SIZE) {
PAGE_SIZE 2638 fs/nfs/nfs4proc.c if (buflen < PAGE_SIZE) {
PAGE_SIZE 2647 fs/nfs/nfs4proc.c resp_len = args.acl_len = PAGE_SIZE;
PAGE_SIZE 2161 fs/nfs/nfs4xdr.c 0, PAGE_SIZE);
PAGE_SIZE 4580 fs/nfs/nfs4xdr.c xdr_enter_page(&xdr, PAGE_SIZE);
PAGE_SIZE 287 fs/nfs/pagelist.c if (desc->pg_bsize < PAGE_SIZE)
PAGE_SIZE 1634 fs/nfs/super.c PAGE_SIZE,
PAGE_SIZE 34 fs/nfs/symlink.c error = NFS_PROTO(inode)->readlink(inode, page, 0, PAGE_SIZE);
PAGE_SIZE 108 fs/nfsd/export.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 113 fs/nfsd/export.c if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
PAGE_SIZE 123 fs/nfsd/export.c if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
PAGE_SIZE 131 fs/nfsd/export.c if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
PAGE_SIZE 154 fs/nfsd/export.c if ((len=qword_get(&mesg, buf, PAGE_SIZE)) < 0)
PAGE_SIZE 421 fs/nfsd/export.c len = qword_get(mesg, buf, PAGE_SIZE);
PAGE_SIZE 430 fs/nfsd/export.c len = qword_get(mesg, buf, PAGE_SIZE);
PAGE_SIZE 524 fs/nfsd/export.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 529 fs/nfsd/export.c len = qword_get(&mesg, buf, PAGE_SIZE);
PAGE_SIZE 540 fs/nfsd/export.c if ((len=qword_get(&mesg, buf, PAGE_SIZE)) <= 0)
PAGE_SIZE 584 fs/nfsd/export.c while ((len = qword_get(&mesg, buf, PAGE_SIZE)) > 0) {
PAGE_SIZE 589 fs/nfsd/export.c len = qword_get(&mesg, buf, PAGE_SIZE);
PAGE_SIZE 252 fs/nfsd/nfs2acl.c w -= PAGE_SIZE;
PAGE_SIZE 191 fs/nfsd/nfs3acl.c w -= PAGE_SIZE;
PAGE_SIZE 501 fs/nfsd/nfs3proc.c ((caddr_t)resp->buffer < page_addr + PAGE_SIZE)) {
PAGE_SIZE 505 fs/nfsd/nfs3proc.c count += PAGE_SIZE;
PAGE_SIZE 554 fs/nfsd/nfs3proc.c resp->f_rtmult = PAGE_SIZE;
PAGE_SIZE 557 fs/nfsd/nfs3proc.c resp->f_wtmult = PAGE_SIZE;
PAGE_SIZE 558 fs/nfsd/nfs3proc.c resp->f_dtpref = PAGE_SIZE;
PAGE_SIZE 353 fs/nfsd/nfs3xdr.c rqstp->rq_vec[v].iov_len = len < PAGE_SIZE? len : PAGE_SIZE;
PAGE_SIZE 410 fs/nfsd/nfs3xdr.c rqstp->rq_vec[v].iov_len = PAGE_SIZE;
PAGE_SIZE 472 fs/nfsd/nfs3xdr.c if (len == 0 || len > NFS3_MAXPATHLEN || len >= PAGE_SIZE)
PAGE_SIZE 489 fs/nfsd/nfs3xdr.c if (avail > PAGE_SIZE)
PAGE_SIZE 490 fs/nfsd/nfs3xdr.c avail = PAGE_SIZE;
PAGE_SIZE 575 fs/nfsd/nfs3xdr.c if (args->count > PAGE_SIZE)
PAGE_SIZE 576 fs/nfsd/nfs3xdr.c args->count = PAGE_SIZE;
PAGE_SIZE 606 fs/nfsd/nfs3xdr.c len -= PAGE_SIZE;
PAGE_SIZE 788 fs/nfsd/nfs3xdr.c if (rqstp->rq_res.head[0].iov_len + (2<<2) > PAGE_SIZE)
PAGE_SIZE 922 fs/nfsd/nfs3xdr.c ((caddr_t)cd->buffer < curr_page_addr + PAGE_SIZE))
PAGE_SIZE 926 fs/nfsd/nfs3xdr.c if ((caddr_t)(cd->buffer + elen) < (curr_page_addr + PAGE_SIZE)) {
PAGE_SIZE 967 fs/nfsd/nfs3xdr.c len1 = curr_page_addr + PAGE_SIZE - (caddr_t)cd->buffer;
PAGE_SIZE 217 fs/nfsd/nfs4idmap.c buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 224 fs/nfsd/nfs4idmap.c if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
PAGE_SIZE 229 fs/nfsd/nfs4idmap.c if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
PAGE_SIZE 235 fs/nfsd/nfs4idmap.c if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
PAGE_SIZE 253 fs/nfsd/nfs4idmap.c len = qword_get(&buf, buf1, PAGE_SIZE);
PAGE_SIZE 387 fs/nfsd/nfs4idmap.c buf1 = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 394 fs/nfsd/nfs4idmap.c if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
PAGE_SIZE 399 fs/nfsd/nfs4idmap.c if (qword_get(&buf, buf1, PAGE_SIZE) <= 0)
PAGE_SIZE 405 fs/nfsd/nfs4idmap.c error = qword_get(&buf, buf1, PAGE_SIZE);
PAGE_SIZE 875 fs/nfsd/nfs4proc.c resp->end = rqstp->rq_res.head[0].iov_base + PAGE_SIZE;
PAGE_SIZE 160 fs/nfsd/nfs4xdr.c if (avail + PAGE_SIZE < nbytes) /* need more than a page !! */
PAGE_SIZE 181 fs/nfsd/nfs4xdr.c if (argp->pagelen < PAGE_SIZE) {
PAGE_SIZE 185 fs/nfsd/nfs4xdr.c argp->end = p + (PAGE_SIZE>>2);
PAGE_SIZE 186 fs/nfsd/nfs4xdr.c argp->pagelen -= PAGE_SIZE;
PAGE_SIZE 971 fs/nfsd/nfs4xdr.c if (argp->pagelen >= PAGE_SIZE) {
PAGE_SIZE 972 fs/nfsd/nfs4xdr.c argp->rqstp->rq_vec[v].iov_len = PAGE_SIZE;
PAGE_SIZE 973 fs/nfsd/nfs4xdr.c argp->pagelen -= PAGE_SIZE;
PAGE_SIZE 1130 fs/nfsd/nfs4xdr.c if (argp->pagelen < PAGE_SIZE) {
PAGE_SIZE 1134 fs/nfsd/nfs4xdr.c argp->end = p + (PAGE_SIZE>>2);
PAGE_SIZE 1135 fs/nfsd/nfs4xdr.c argp->pagelen -= PAGE_SIZE;
PAGE_SIZE 2259 fs/nfsd/nfs4xdr.c len < PAGE_SIZE ? len : PAGE_SIZE;
PAGE_SIZE 2261 fs/nfsd/nfs4xdr.c len -= PAGE_SIZE;
PAGE_SIZE 2310 fs/nfsd/nfs4xdr.c maxcount = PAGE_SIZE;
PAGE_SIZE 2367 fs/nfsd/nfs4xdr.c maxcount = PAGE_SIZE;
PAGE_SIZE 2414 fs/nfsd/nfs4xdr.c resp->end = resp->p + (PAGE_SIZE - resp->xbuf->head[0].iov_len)/4;
PAGE_SIZE 2738 fs/nfsd/nfs4xdr.c BUG_ON(iov->iov_len > PAGE_SIZE);
PAGE_SIZE 313 fs/nfsd/nfscache.c if (vec->iov_len + data->iov_len > PAGE_SIZE) {
PAGE_SIZE 277 fs/nfsd/nfsxdr.c rqstp->rq_vec[v].iov_len = len < PAGE_SIZE?len:PAGE_SIZE;
PAGE_SIZE 331 fs/nfsd/nfsxdr.c rqstp->rq_vec[v].iov_len = PAGE_SIZE;
PAGE_SIZE 406 fs/nfsd/nfsxdr.c if (args->count > PAGE_SIZE)
PAGE_SIZE 407 fs/nfsd/nfsxdr.c args->count = PAGE_SIZE;
PAGE_SIZE 366 fs/ntfs/file.c while (!__get_user(c, uaddr) && (uaddr += PAGE_SIZE, uaddr < end))
PAGE_SIZE 343 fs/ntfs/lcnalloc.c rl2 = ntfs_malloc_nofs(rlsize + (int)PAGE_SIZE);
PAGE_SIZE 353 fs/ntfs/lcnalloc.c rlsize += PAGE_SIZE;
PAGE_SIZE 44 fs/ntfs/malloc.h if (likely(size <= PAGE_SIZE)) {
PAGE_SIZE 47 fs/ntfs/malloc.h return kmalloc(PAGE_SIZE, gfp_mask & ~__GFP_HIGHMEM);
PAGE_SIZE 788 fs/ntfs/runlist.c rl = ntfs_malloc_nofs(rlsize = PAGE_SIZE);
PAGE_SIZE 807 fs/ntfs/runlist.c rl2 = ntfs_malloc_nofs(rlsize + (int)PAGE_SIZE);
PAGE_SIZE 815 fs/ntfs/runlist.c rlsize += PAGE_SIZE;
PAGE_SIZE 1521 fs/ntfs/runlist.c rl = ntfs_malloc_nofs(PAGE_SIZE);
PAGE_SIZE 312 fs/ocfs2/aops.c zero_user(page, 0, PAGE_SIZE);
PAGE_SIZE 729 fs/ocfs2/aops.c BUG_ON(cluster_start > PAGE_SIZE);
PAGE_SIZE 730 fs/ocfs2/aops.c BUG_ON(cluster_end > PAGE_SIZE);
PAGE_SIZE 47 fs/ocfs2/cluster/masklog.c return snprintf(buf, PAGE_SIZE, "%s\n", state);
PAGE_SIZE 41 fs/ocfs2/cluster/sys.c return snprintf(buf, PAGE_SIZE, "%u\n", O2NM_API_VERSION);
PAGE_SIZE 41 fs/ocfs2/dlm/dlmcommon.h #if DLM_HASH_SIZE_DEFAULT < PAGE_SIZE
PAGE_SIZE 44 fs/ocfs2/dlm/dlmcommon.h # define DLM_HASH_PAGES (DLM_HASH_SIZE_DEFAULT / PAGE_SIZE)
PAGE_SIZE 46 fs/ocfs2/dlm/dlmcommon.h #define DLM_BUCKETS_PER_PAGE (PAGE_SIZE / sizeof(struct hlist_head))
PAGE_SIZE 348 fs/ocfs2/dlm/dlmdebug.c dump_mle(mle, buf, PAGE_SIZE - 1);
PAGE_SIZE 392 fs/ocfs2/dlm/dlmdebug.c db->len = PAGE_SIZE;
PAGE_SIZE 711 fs/ocfs2/dlm/dlmdebug.c dl->dl_len = PAGE_SIZE;
PAGE_SIZE 447 fs/ocfs2/file.c unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 456 fs/ocfs2/stackglue.c ret = snprintf(buf, PAGE_SIZE, "%u.%u\n",
PAGE_SIZE 472 fs/ocfs2/stackglue.c ssize_t ret = 0, total = 0, remain = PAGE_SIZE;
PAGE_SIZE 508 fs/ocfs2/stackglue.c ret = snprintf(buf, PAGE_SIZE, "%s\n",
PAGE_SIZE 510 fs/ocfs2/stackglue.c if (ret == PAGE_SIZE)
PAGE_SIZE 528 fs/ocfs2/stackglue.c ret = snprintf(buf, PAGE_SIZE, "%s\n", cluster_stack_name);
PAGE_SIZE 455 fs/omfs/inode.c if (sbi->s_sys_blocksize > PAGE_SIZE) {
PAGE_SIZE 424 fs/pipe.c chars = total_len & (PAGE_SIZE-1); /* size of the last buffer */
PAGE_SIZE 432 fs/pipe.c if (ops->can_merge && offset + chars <= PAGE_SIZE) {
PAGE_SIZE 494 fs/pipe.c chars = PAGE_SIZE;
PAGE_SIZE 280 fs/proc/base.c if (len > PAGE_SIZE)
PAGE_SIZE 281 fs/proc/base.c len = PAGE_SIZE;
PAGE_SIZE 287 fs/proc/base.c if (res > 0 && buffer[res-1] != '\0' && len < PAGE_SIZE) {
PAGE_SIZE 293 fs/proc/base.c if (len > PAGE_SIZE - res)
PAGE_SIZE 294 fs/proc/base.c len = PAGE_SIZE - res;
PAGE_SIZE 315 fs/proc/base.c if (res > PAGE_SIZE)
PAGE_SIZE 316 fs/proc/base.c res = PAGE_SIZE;
PAGE_SIZE 808 fs/proc/base.c this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
PAGE_SIZE 866 fs/proc/base.c this_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
PAGE_SIZE 948 fs/proc/base.c max_len = (count > PAGE_SIZE) ? PAGE_SIZE : count;
PAGE_SIZE 1071 fs/proc/base.c if (count >= PAGE_SIZE)
PAGE_SIZE 1072 fs/proc/base.c count = PAGE_SIZE - 1;
PAGE_SIZE 1345 fs/proc/base.c pathname = d_path(path, tmp, PAGE_SIZE);
PAGE_SIZE 1349 fs/proc/base.c len = tmp + PAGE_SIZE - 1 - pathname;
PAGE_SIZE 2091 fs/proc/base.c if (count > PAGE_SIZE)
PAGE_SIZE 2092 fs/proc/base.c count = PAGE_SIZE;
PAGE_SIZE 38 fs/proc/generic.c #define PROC_BLOCK_SIZE (PAGE_SIZE - 1024)
PAGE_SIZE 134 fs/proc/generic.c if (n > PAGE_SIZE) {
PAGE_SIZE 137 fs/proc/generic.c n = PAGE_SIZE;
PAGE_SIZE 146 fs/proc/generic.c if (n > PAGE_SIZE) {
PAGE_SIZE 149 fs/proc/generic.c n = PAGE_SIZE;
PAGE_SIZE 161 fs/proc/generic.c if (n > (PAGE_SIZE - startoff)) {
PAGE_SIZE 164 fs/proc/generic.c n = PAGE_SIZE - startoff;
PAGE_SIZE 204 fs/proc/kcore.c phdr->p_align = PAGE_SIZE;
PAGE_SIZE 311 fs/proc/kcore.c if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
PAGE_SIZE 341 fs/proc/kcore.c unsigned long msize = m->size - PAGE_SIZE;
PAGE_SIZE 397 fs/proc/kcore.c tsz = (buflen > PAGE_SIZE ? PAGE_SIZE : buflen);
PAGE_SIZE 283 fs/proc/proc_misc.c len = snprintf(page, PAGE_SIZE, linux_proc_banner,
PAGE_SIZE 446 fs/proc/proc_misc.c unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 452 fs/proc/proc_misc.c *n = PAGE_SIZE / (2 * sizeof(unsigned long));
PAGE_SIZE 928 fs/proc/proc_misc.c (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
PAGE_SIZE 62 fs/proc/task_mmu.c return PAGE_SIZE * mm->total_vm;
PAGE_SIZE 325 fs/proc/task_mmu.c for (; addr != end; pte++, addr += PAGE_SIZE) {
PAGE_SIZE 329 fs/proc/task_mmu.c mss->swap += PAGE_SIZE;
PAGE_SIZE 336 fs/proc/task_mmu.c mss->resident += PAGE_SIZE;
PAGE_SIZE 344 fs/proc/task_mmu.c mss->referenced += PAGE_SIZE;
PAGE_SIZE 348 fs/proc/task_mmu.c mss->shared_dirty += PAGE_SIZE;
PAGE_SIZE 350 fs/proc/task_mmu.c mss->shared_clean += PAGE_SIZE;
PAGE_SIZE 351 fs/proc/task_mmu.c mss->pss += (PAGE_SIZE << PSS_SHIFT) / mapcount;
PAGE_SIZE 354 fs/proc/task_mmu.c mss->private_dirty += PAGE_SIZE;
PAGE_SIZE 356 fs/proc/task_mmu.c mss->private_clean += PAGE_SIZE;
PAGE_SIZE 357 fs/proc/task_mmu.c mss->pss += (PAGE_SIZE << PSS_SHIFT);
PAGE_SIZE 436 fs/proc/task_mmu.c for (; addr != end; pte++, addr += PAGE_SIZE) {
PAGE_SIZE 539 fs/proc/task_mmu.c for (addr = start; addr < end; addr += PAGE_SIZE) {
PAGE_SIZE 575 fs/proc/task_mmu.c for (; addr != end; addr += PAGE_SIZE) {
PAGE_SIZE 662 fs/proc/task_mmu.c pagecount = (PAGE_ALIGN(uend) - uaddr) / PAGE_SIZE;
PAGE_SIZE 51 fs/proc/vmcore.c offset = (unsigned long)(*ppos % PAGE_SIZE);
PAGE_SIZE 52 fs/proc/vmcore.c pfn = (unsigned long)(*ppos / PAGE_SIZE);
PAGE_SIZE 57 fs/proc/vmcore.c if (count > (PAGE_SIZE - offset))
PAGE_SIZE 58 fs/proc/vmcore.c nr_bytes = PAGE_SIZE - offset;
PAGE_SIZE 135 fs/proc/vmcore.c if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
PAGE_SIZE 158 fs/proc/vmcore.c if ((tsz = (PAGE_SIZE - (start & ~PAGE_MASK))) > buflen)
PAGE_SIZE 92 fs/ramfs/file-nommu.c npages = (newsize + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 101 fs/ramfs/file-nommu.c newsize = PAGE_SIZE * npages;
PAGE_SIZE 148 fs/ramfs/file-nommu.c (size + PAGE_SIZE - 1) >> PAGE_SHIFT
PAGE_SIZE 250 fs/ramfs/file-nommu.c lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 254 fs/ramfs/file-nommu.c maxpages = (isize + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 441 fs/romfs/inode.c readlen = size > PAGE_SIZE ? PAGE_SIZE : size;
PAGE_SIZE 452 fs/romfs/inode.c if (filled < PAGE_SIZE)
PAGE_SIZE 453 fs/romfs/inode.c memset(buf + filled, 0, PAGE_SIZE-filled);
PAGE_SIZE 37 fs/select.c ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
PAGE_SIZE 540 fs/select.c #define POLLFD_PER_PAGE ((PAGE_SIZE-sizeof(struct poll_list)) / sizeof(struct pollfd))
PAGE_SIZE 90 fs/seq_file.c m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 203 fs/seq_file.c m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 61 fs/smbfs/file.c int count = PAGE_SIZE;
PAGE_SIZE 51 fs/smbfs/proc.c #define SMB_ST_BLKSIZE (PAGE_SIZE)
PAGE_SIZE 1119 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 1546 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 1579 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 1614 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 1685 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2534 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2616 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2701 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2751 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2782 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 2903 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 3011 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 3085 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 3266 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 3315 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 3358 fs/smbfs/proc.c if (! (req = smb_alloc_request(server, PAGE_SIZE)))
PAGE_SIZE 251 fs/smbfs/sock.c static char drop_buffer[PAGE_SIZE];
PAGE_SIZE 270 fs/smbfs/sock.c if (rlen > PAGE_SIZE)
PAGE_SIZE 271 fs/smbfs/sock.c rlen = PAGE_SIZE;
PAGE_SIZE 281 fs/smbfs/sock.c iov.iov_len = PAGE_SIZE;
PAGE_SIZE 1217 fs/splice.c npages = (off + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 1231 fs/splice.c const int plen = min_t(size_t, len, PAGE_SIZE - off);
PAGE_SIZE 63 fs/sysfs/bin.c int count = min_t(size_t, bytes, PAGE_SIZE);
PAGE_SIZE 120 fs/sysfs/bin.c int count = min_t(size_t, bytes, PAGE_SIZE);
PAGE_SIZE 195 fs/sysfs/bin.c bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 92 fs/sysfs/file.c if (count >= (ssize_t)PAGE_SIZE) {
PAGE_SIZE 96 fs/sysfs/file.c count = PAGE_SIZE - 1;
PAGE_SIZE 167 fs/sysfs/file.c if (count >= PAGE_SIZE)
PAGE_SIZE 168 fs/sysfs/file.c count = PAGE_SIZE - 1;
PAGE_SIZE 177 fs/sysfs/inode.c inode->i_size = PAGE_SIZE;
PAGE_SIZE 1072 fs/udf/super.c if (size <= PAGE_SIZE)
PAGE_SIZE 1811 fs/udf/super.c if (size <= PAGE_SIZE)
PAGE_SIZE 38 fs/xfs/linux-2.6/kmem.c if (unlikely(!(flags & KM_LARGE) && (size > PAGE_SIZE))) {
PAGE_SIZE 239 fs/xfs/linux-2.6/xfs_file.c bufsize = (size_t)min_t(loff_t, PAGE_SIZE, inode->i_size);
PAGE_SIZE 599 fs/xfs/linux-2.6/xfs_ioctl.c if (!size || size > 16 * PAGE_SIZE)
PAGE_SIZE 55 fs/xfs/quota/xfs_qm.h #define XFS_QM_HASHSIZE_LOW (PAGE_SIZE / sizeof(xfs_dqhash_t))
PAGE_SIZE 56 fs/xfs/quota/xfs_qm.h #define XFS_QM_HASHSIZE_HIGH ((PAGE_SIZE * 4) / sizeof(xfs_dqhash_t))
PAGE_SIZE 392 fs/xfs/xfs_itable.c irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4,
PAGE_SIZE 824 fs/xfs/xfs_itable.c bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer)));
PAGE_SIZE 250 fs/xfs/xfs_mount.c if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
PAGE_SIZE 256 fs/xfs/xfs_mount.c PAGE_SIZE);
PAGE_SIZE 44 include/asm-cris/arch-v10/processor.h if (regs > PAGE_SIZE && \
PAGE_SIZE 39 include/asm-cris/arch-v32/processor.h if (regs > PAGE_SIZE && virt_addr_valid(regs)) \
PAGE_SIZE 10 include/asm-cris/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 12 include/asm-cris/page.h #define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)
PAGE_SIZE 13 include/asm-cris/page.h #define copy_page(to,from) memcpy((void *)(to), (void *)(from), PAGE_SIZE)
PAGE_SIZE 33 include/asm-cris/processor.h #define THREAD_SIZE PAGE_SIZE
PAGE_SIZE 34 include/asm-cris/processor.h #define KERNEL_STACK_SIZE PAGE_SIZE
PAGE_SIZE 6 include/asm-cris/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 46 include/asm-cris/user.h #define NBPG PAGE_SIZE
PAGE_SIZE 56 include/asm-frv/cacheflush.h frv_dcache_writeback(addr, addr + PAGE_SIZE);
PAGE_SIZE 88 include/asm-frv/cacheflush.h flush_icache_user_range(vma, page, page_to_phys(page), PAGE_SIZE);
PAGE_SIZE 102 include/asm-frv/gdb-stub.h extern volatile u8 gdbstub_rx_buffer[PAGE_SIZE];
PAGE_SIZE 101 include/asm-frv/highmem.h unsigned long damlr = KMAP_ATOMIC_SECONDARY_FRAME + (slot) * PAGE_SIZE; \
PAGE_SIZE 32 include/asm-frv/mem-layout.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 68 include/asm-frv/mem-layout.h #define BRK_BASE __UL(2 * 1024 * 1024 + PAGE_SIZE)
PAGE_SIZE 14 include/asm-frv/page.h #define clear_page(pgaddr) memset((pgaddr), 0, PAGE_SIZE)
PAGE_SIZE 15 include/asm-frv/page.h #define copy_page(to,from) memcpy((to), (from), PAGE_SIZE)
PAGE_SIZE 17 include/asm-frv/page.h #define clear_user_page(pgaddr, vaddr, page) memset((pgaddr), 0, PAGE_SIZE)
PAGE_SIZE 18 include/asm-frv/page.h #define copy_user_page(vto, vfrom, vaddr, topg) memcpy((vto), (vfrom), PAGE_SIZE)
PAGE_SIZE 4 include/asm-frv/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 75 include/asm-frv/user.h #define NBPG PAGE_SIZE
PAGE_SIZE 106 include/asm-m32r/elf.h #define ELF_EXEC_PAGESIZE PAGE_SIZE
PAGE_SIZE 7 include/asm-m32r/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 143 include/asm-m32r/processor.h #define THREAD_SIZE (2*PAGE_SIZE)
PAGE_SIZE 4 include/asm-m32r/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 81 include/asm-m32r/thread_info.h #define THREAD_SIZE (2*PAGE_SIZE)
PAGE_SIZE 46 include/asm-m32r/user.h #define NBPG PAGE_SIZE
PAGE_SIZE 30 include/asm-m68k/a.out-core.h dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
PAGE_SIZE 33 include/asm-m68k/a.out-core.h (PAGE_SIZE-1))) >> PAGE_SHIFT;
PAGE_SIZE 13 include/asm-m68k/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 20 include/asm-m68k/page.h #define THREAD_SIZE PAGE_SIZE
PAGE_SIZE 47 include/asm-m68k/page.h : "0" (to), "1" (from) , "2" (PAGE_SIZE / 32 - 1)
PAGE_SIZE 70 include/asm-m68k/page.h "1" ((PAGE_SIZE - 16) / 16 - 1));
PAGE_SIZE 74 include/asm-m68k/page.h #define clear_page(page) memset((page), 0, PAGE_SIZE)
PAGE_SIZE 75 include/asm-m68k/page.h #define copy_page(to,from) memcpy((to), (from), PAGE_SIZE)
PAGE_SIZE 122 include/asm-m68k/processor.h if ((tsk)->thread.esp0 > PAGE_SIZE && \
PAGE_SIZE 4 include/asm-m68k/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 49 include/asm-m68k/sun3_pgalloc.h memset((void *)page, 0, PAGE_SIZE);
PAGE_SIZE 95 include/asm-m68k/sun3_pgalloc.h memcpy(new_pgd, swapper_pg_dir, PAGE_SIZE);
PAGE_SIZE 141 include/asm-mn10300/gdb-stub.h extern u8 gdbstub_rx_buffer[PAGE_SIZE];
PAGE_SIZE 19 include/asm-mn10300/page.h #define PAGE_MASK (~(PAGE_SIZE - 1))
PAGE_SIZE 23 include/asm-mn10300/page.h #define PAGE_MASK +(~(PAGE_SIZE - 1))
PAGE_SIZE 29 include/asm-mn10300/page.h #define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)
PAGE_SIZE 30 include/asm-mn10300/page.h #define copy_page(to, from) memcpy((void *)(to), (void *)(from), PAGE_SIZE)
PAGE_SIZE 62 include/asm-mn10300/pgtable.h #define PGD_SIZE PAGE_SIZE
PAGE_SIZE 98 include/asm-mn10300/pgtable.h extern pte_t kernel_vmalloc_ptes[(VMALLOC_END - VMALLOC_START) / PAGE_SIZE];
PAGE_SIZE 4 include/asm-mn10300/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 48 include/asm-mn10300/user.h #define NBPG PAGE_SIZE
PAGE_SIZE 25 include/asm-parisc/dma.h #define DMA_CHUNK_SIZE (BITS_PER_LONG*PAGE_SIZE)
PAGE_SIZE 16 include/asm-parisc/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 24 include/asm-parisc/page.h #define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)
PAGE_SIZE 28 include/asm-parisc/pgalloc.h memset(pgd, 0, PAGE_SIZE<<PGD_ALLOC_ORDER);
PAGE_SIZE 69 include/asm-parisc/pgalloc.h memset(pmd, 0, PAGE_SIZE<<PMD_ORDER);
PAGE_SIZE 75 include/asm-parisc/pgtable.h #define PLD_SIZE PAGE_SIZE
PAGE_SIZE 22 include/asm-parisc/processor.h #define KERNEL_STACK_SIZE (4*PAGE_SIZE)
PAGE_SIZE 187 include/asm-parisc/ropes.h #define IOVP_SIZE PAGE_SIZE
PAGE_SIZE 40 include/asm-parisc/thread_info.h #define THREAD_SIZE (PAGE_SIZE << THREAD_SIZE_ORDER)
PAGE_SIZE 61 include/asm-um/fixmap.h #define FIXADDR_TOP (TASK_SIZE - 2 * PAGE_SIZE)
PAGE_SIZE 10 include/asm-um/highmem.h #define PKMAP_BASE ((FIXADDR_START - LAST_PKMAP * PAGE_SIZE) & PMD_MASK)
PAGE_SIZE 17 include/asm-um/ldt.h ((LDT_ENTRIES * LDT_ENTRY_SIZE)/PAGE_SIZE)
PAGE_SIZE 19 include/asm-um/ldt.h (PAGE_SIZE/LDT_ENTRY_SIZE)
PAGE_SIZE 15 include/asm-um/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 28 include/asm-um/page.h #define clear_page(page) memset((void *)(page), 0, PAGE_SIZE)
PAGE_SIZE 29 include/asm-um/page.h #define copy_page(to,from) memcpy((void *)(to), (void *)(from), PAGE_SIZE)
PAGE_SIZE 51 include/asm-um/pgtable.h # define VMALLOC_END (PKMAP_BASE-2*PAGE_SIZE)
PAGE_SIZE 53 include/asm-um/pgtable.h # define VMALLOC_END (FIXADDR_START-2*PAGE_SIZE)
PAGE_SIZE 104 include/asm-um/processor-generic.h #define STACK_TOP (TASK_SIZE - 2 * PAGE_SIZE)
PAGE_SIZE 46 include/asm-um/thread_info.h #define THREAD_SIZE ((1 << CONFIG_KERNEL_STACK_ORDER) * PAGE_SIZE)
PAGE_SIZE 33 include/asm-um/tlb.h if (tlb->end < address + PAGE_SIZE)
PAGE_SIZE 34 include/asm-um/tlb.h tlb->end = address + PAGE_SIZE;
PAGE_SIZE 31 include/asm-x86/a.out-core.h dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
PAGE_SIZE 33 include/asm-x86/a.out-core.h dump->u_dsize = ((unsigned long)(current->mm->brk + (PAGE_SIZE - 1)))
PAGE_SIZE 39 include/asm-x86/desc.h } __attribute__((aligned(PAGE_SIZE)));
PAGE_SIZE 75 include/asm-x86/fixmap_64.h #define FIXADDR_TOP (VSYSCALL_END-PAGE_SIZE)
PAGE_SIZE 81 include/asm-x86/fixmap_64.h #define FIXADDR_USER_END (FIXADDR_USER_START + PAGE_SIZE)
PAGE_SIZE 34 include/asm-x86/kvm_host.h #define CR3_NONPAE_RESERVED_BITS ((PAGE_SIZE-1) & ~(X86_CR3_PWT | X86_CR3_PCD))
PAGE_SIZE 57 include/asm-x86/kvm_host.h #define KVM_PAGES_PER_HPAGE (KVM_HPAGE_SIZE / PAGE_SIZE)
PAGE_SIZE 16 include/asm-x86/lguest.h DIV_ROUND_UP(end_switcher_text - start_switcher_text, PAGE_SIZE)
PAGE_SIZE 106 include/asm-x86/mmzone_32.h __alloc_bootmem_node(NODE_DATA(0), (x), PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
PAGE_SIZE 108 include/asm-x86/mmzone_32.h __alloc_bootmem_node_nopanic(NODE_DATA(0), (x), PAGE_SIZE, \
PAGE_SIZE 111 include/asm-x86/mmzone_32.h __alloc_bootmem_node(NODE_DATA(0), (x), PAGE_SIZE, 0)
PAGE_SIZE 123 include/asm-x86/mmzone_32.h __alloc_bootmem_node(NODE_DATA(0), (x), PAGE_SIZE, \
PAGE_SIZE 130 include/asm-x86/mmzone_32.h __alloc_bootmem_node(NODE_DATA(0), (x), PAGE_SIZE, 0); \
PAGE_SIZE 9 include/asm-x86/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 21 include/asm-x86/page_32.h #define THREAD_SIZE (PAGE_SIZE << THREAD_ORDER)
PAGE_SIZE 128 include/asm-x86/page_32.h memset(page, 0, PAGE_SIZE);
PAGE_SIZE 133 include/asm-x86/page_32.h memcpy(to, from, PAGE_SIZE);
PAGE_SIZE 7 include/asm-x86/page_64.h #define THREAD_SIZE (PAGE_SIZE << THREAD_ORDER)
PAGE_SIZE 11 include/asm-x86/page_64.h #define EXCEPTION_STKSZ (PAGE_SIZE << EXCEPTION_STACK_ORDER)
PAGE_SIZE 14 include/asm-x86/page_64.h #define DEBUG_STKSZ (PAGE_SIZE << DEBUG_STACK_ORDER)
PAGE_SIZE 17 include/asm-x86/page_64.h #define IRQSTACKSIZE (PAGE_SIZE << IRQSTACK_ORDER)
PAGE_SIZE 39 include/asm-x86/pgalloc.h BUG_ON((unsigned long)pte & (PAGE_SIZE-1));
PAGE_SIZE 76 include/asm-x86/pgalloc.h BUG_ON((unsigned long)pmd & (PAGE_SIZE-1));
PAGE_SIZE 106 include/asm-x86/pgalloc.h BUG_ON((unsigned long)pud & (PAGE_SIZE-1));
PAGE_SIZE 162 include/asm-x86/pgtable.h extern unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)];
PAGE_SIZE 67 include/asm-x86/pgtable_32.h #define PKMAP_BASE ((FIXADDR_BOOT_START - PAGE_SIZE * (LAST_PKMAP + 1)) \
PAGE_SIZE 71 include/asm-x86/pgtable_32.h # define VMALLOC_END (PKMAP_BASE - 2 * PAGE_SIZE)
PAGE_SIZE 73 include/asm-x86/pgtable_32.h # define VMALLOC_END (FIXADDR_START - 2 * PAGE_SIZE)
PAGE_SIZE 884 include/asm-x86/processor.h #define TASK_SIZE64 ((1UL << 47) - PAGE_SIZE)
PAGE_SIZE 4 include/asm-x86/shmparam.h #define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
PAGE_SIZE 126 include/asm-x86/user_32.h #define NBPG PAGE_SIZE
PAGE_SIZE 132 include/asm-x86/user_64.h #define NBPG PAGE_SIZE
PAGE_SIZE 31 include/asm-x86/xen/page.h ((unsigned long)((u64)CONFIG_XEN_MAX_DOMAIN_MEMORY * 1024 * 1024 * 1024 / PAGE_SIZE))
PAGE_SIZE 62 include/asm-xtensa/cacheasm.h __loopi \ar, \at, PAGE_SIZE, 4 << (\line_width)
PAGE_SIZE 68 include/asm-xtensa/cacheflush.h #if (DCACHE_WAY_SIZE > PAGE_SIZE)
PAGE_SIZE 71 include/asm-xtensa/cacheflush.h #if (ICACHE_WAY_SIZE > PAGE_SIZE)
PAGE_SIZE 86 include/asm-xtensa/cacheflush.h #if (DCACHE_WAY_SIZE > PAGE_SIZE)
PAGE_SIZE 133 include/asm-xtensa/cacheflush.h #if (DCACHE_WAY_SIZE > PAGE_SIZE)
PAGE_SIZE 75 include/asm-xtensa/dma-mapping.h return (dma_addr_t)(page_to_pfn(page)) * PAGE_SIZE + offset;
PAGE_SIZE 127 include/asm-xtensa/elf.h #define ELF_EXEC_PAGESIZE PAGE_SIZE
PAGE_SIZE 33 include/asm-xtensa/page.h #define PAGE_MASK (~(PAGE_SIZE-1))
PAGE_SIZE 67 include/asm-xtensa/page.h #if DCACHE_WAY_SIZE > PAGE_SIZE
PAGE_SIZE 76 include/asm-xtensa/page.h #if ICACHE_WAY_SIZE > PAGE_SIZE
PAGE_SIZE 138 include/asm-xtensa/page.h #if DCACHE_WAY_SIZE > PAGE_SIZE
PAGE_SIZE 134 include/asm-xtensa/pgtable.h #if (DCACHE_WAY_SIZE > PAGE_SIZE)
PAGE_SIZE 186 include/asm-xtensa/pgtable.h extern pgd_t swapper_pg_dir[PAGE_SIZE/sizeof(pgd_t)];
PAGE_SIZE 254 include/asm-xtensa/pgtable.h #if (DCACHE_WAY_SIZE > PAGE_SIZE) && XCHAL_DCACHE_IS_WRITEBACK
PAGE_SIZE 40 include/asm-xtensa/ptrace.h #define KERNEL_STACK_SIZE (2 * PAGE_SIZE)
PAGE_SIZE 19 include/asm-xtensa/shmparam.h #define SHMLBA ((PAGE_SIZE > DCACHE_WAY_SIZE)? PAGE_SIZE : DCACHE_WAY_SIZE)
PAGE_SIZE 17 include/asm-xtensa/tlb.h #if (DCACHE_WAY_SIZE <= PAGE_SIZE)
PAGE_SIZE 149 include/drm/drmP.h #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)
PAGE_SIZE 198 include/drm/drmP.h #define DRM_PROC_LIMIT (PAGE_SIZE-80)
PAGE_SIZE 112 include/linux/a.out.h #define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? PAGE_SIZE : 0)
PAGE_SIZE 129 include/linux/a.out.h #define SEGMENT_SIZE PAGE_SIZE
PAGE_SIZE 143 include/linux/a.out.h #define SEGMENT_SIZE PAGE_SIZE
PAGE_SIZE 14 include/linux/binfmts.h #define MAX_ARG_STRLEN (PAGE_SIZE * 32)
PAGE_SIZE 105 include/linux/bootmem.h __alloc_bootmem(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
PAGE_SIZE 107 include/linux/bootmem.h __alloc_bootmem_nopanic(x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
PAGE_SIZE 109 include/linux/bootmem.h __alloc_bootmem_low(x, PAGE_SIZE, 0)
PAGE_SIZE 113 include/linux/bootmem.h __alloc_bootmem_node(pgdat, x, PAGE_SIZE, __pa(MAX_DMA_ADDRESS))
PAGE_SIZE 115 include/linux/bootmem.h __alloc_bootmem_low_node(pgdat, x, PAGE_SIZE, 0)
PAGE_SIZE 59 include/linux/coda_linux.h if (size < PAGE_SIZE) \
PAGE_SIZE 70 include/linux/coda_linux.h do { if (size < PAGE_SIZE) kfree((ptr)); else vfree((ptr)); } while (0)
PAGE_SIZE 2141 include/linux/fs.h #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
PAGE_SIZE 131 include/linux/highmem.h BUG_ON(end1 > PAGE_SIZE || end2 > PAGE_SIZE);
PAGE_SIZE 97 include/linux/hugetlb.h #define HPAGE_SIZE PAGE_SIZE
PAGE_SIZE 231 include/linux/hugetlb.h return (unsigned long)PAGE_SIZE << h->order;
PAGE_SIZE 263 include/linux/hugetlb.h return size_to_hstate(PAGE_SIZE << compound_order(page));
PAGE_SIZE 272 include/linux/hugetlb.h #define huge_page_size(h) PAGE_SIZE
PAGE_SIZE 765 include/linux/i2o.h *mptr++ = cpu_to_le32(PAGE_SIZE);
PAGE_SIZE 821 include/linux/i2o.h *mptr++ = cpu_to_le32(PAGE_SIZE);
PAGE_SIZE 1 include/linux/kmalloc_sizes.h #if (PAGE_SIZE == 4096)
PAGE_SIZE 197 include/linux/kvm.h ((PAGE_SIZE - sizeof(struct kvm_coalesced_mmio_ring)) / \
PAGE_SIZE 23 include/linux/linkage.h #define __page_aligned_data __section(.data.page_aligned) __aligned(PAGE_SIZE)
PAGE_SIZE 24 include/linux/linkage.h #define __page_aligned_bss __section(.bss.page_aligned) __aligned(PAGE_SIZE)
PAGE_SIZE 119 include/linux/lp.h #define LP_BUFFER_SIZE PAGE_SIZE
PAGE_SIZE 367 include/linux/mlx4/device.h (offset & (PAGE_SIZE - 1));
PAGE_SIZE 46 include/linux/mm.h #define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)
PAGE_SIZE 877 include/linux/mmzone.h #define SECTIONS_PER_ROOT (PAGE_SIZE / sizeof (struct mem_section))
PAGE_SIZE 207 include/linux/netlink.h #if PAGE_SIZE < 8192UL
PAGE_SIZE 208 include/linux/netlink.h #define NLMSG_GOODSIZE SKB_WITH_OVERHEAD(PAGE_SIZE)
PAGE_SIZE 37 include/linux/nfsacl.h #define NFSACL_MAXPAGES ((2*(8+12*NFS_ACL_MAX_ENTRIES) + PAGE_SIZE-1) \
PAGE_SIZE 59 include/linux/pagemap.h #define PAGE_CACHE_SIZE PAGE_SIZE
PAGE_SIZE 4 include/linux/pfn.h #define PFN_ALIGN(x) (((unsigned long)(x) + (PAGE_SIZE - 1)) & PAGE_MASK)
PAGE_SIZE 5 include/linux/pfn.h #define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
PAGE_SIZE 15 include/linux/pid_namespace.h #define PIDMAP_ENTRIES ((PID_MAX_LIMIT + 8*PAGE_SIZE - 1)/PAGE_SIZE/8)
PAGE_SIZE 135 include/linux/pipe_fs_i.h #define PIPE_SIZE PAGE_SIZE
PAGE_SIZE 176 include/linux/pktcdvd.h #if (PAGE_SIZE % CD_FRAMESIZE) != 0
PAGE_SIZE 180 include/linux/pktcdvd.h #define FRAMES_PER_PAGE (PAGE_SIZE / CD_FRAMESIZE)
PAGE_SIZE 82 include/linux/raid/bitmap.h #define PAGE_BITS (PAGE_SIZE << 3)
PAGE_SIZE 23 include/linux/relay.h #define FIX_SIZE(x) ((((x) - 1) & PAGE_MASK) + PAGE_SIZE)
PAGE_SIZE 65 include/linux/resource.h #define MLOCK_LIMIT (8 * PAGE_SIZE)
PAGE_SIZE 225 include/linux/scatterlist.h #define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist))
PAGE_SIZE 849 include/linux/sched.h #define NGROUPS_PER_BLOCK ((unsigned int)(PAGE_SIZE / sizeof(gid_t)))
PAGE_SIZE 30 include/linux/serial.h #define SERIAL_XMIT_SIZE PAGE_SIZE
PAGE_SIZE 333 include/linux/serial_core.h #define UART_XMIT_SIZE PAGE_SIZE
PAGE_SIZE 21 include/linux/shm.h #define SHMALL (SHMMAX/PAGE_SIZE*(SHMMNI/16)) /* max shm system wide (pages) */
PAGE_SIZE 46 include/linux/skbuff.h SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
PAGE_SIZE 128 include/linux/skbuff.h #define MAX_SKB_FRAGS (65536/PAGE_SIZE + 2)
PAGE_SIZE 215 include/linux/slub_def.h if (size > PAGE_SIZE)
PAGE_SIZE 237 include/linux/slub_def.h size <= PAGE_SIZE && !(flags & SLUB_DMA)) {
PAGE_SIZE 151 include/linux/sunrpc/svc.h #define RPCSVC_MAXPAGES ((RPCSVC_MAXPAYLOAD+PAGE_SIZE-1)/PAGE_SIZE \
PAGE_SIZE 304 include/linux/sunrpc/svc.h return vec->iov_len <= PAGE_SIZE;
PAGE_SIZE 59 include/linux/swap.h char reserved[PAGE_SIZE - 10];
PAGE_SIZE 33 include/linux/threads.h #define PID_MAX_LIMIT (CONFIG_BASE_SMALL ? PAGE_SIZE * 8 : \
PAGE_SIZE 66 include/linux/vmalloc.h return area->size - PAGE_SIZE;
PAGE_SIZE 106 include/linux/vt_kern.h #define CON_BUF_SIZE (CONFIG_BASE_SMALL ? 256 : PAGE_SIZE)
PAGE_SIZE 166 include/media/saa7146.h #define SAA7146_I2C_MEM ( 1*PAGE_SIZE)
PAGE_SIZE 167 include/media/saa7146.h #define SAA7146_RPS_MEM ( 1*PAGE_SIZE)
PAGE_SIZE 169 include/net/inet_hashtables.h if (size * sizeof(rwlock_t) > PAGE_SIZE)
PAGE_SIZE 190 include/net/inet_hashtables.h if (size > PAGE_SIZE)
PAGE_SIZE 723 include/net/sock.h #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
PAGE_SIZE 1567 include/sound/emu10k1.h #define snd_emu10k1_memblk_offset(blk) (((blk)->mapped_page << PAGE_SHIFT) | ((blk)->mem.offset & (PAGE_SIZE - 1)))
PAGE_SIZE 90 include/sound/memalloc.h return (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 100 include/sound/memalloc.h return addr + offset % PAGE_SIZE;
PAGE_SIZE 108 include/sound/memalloc.h return sgbuf->table[offset >> PAGE_SHIFT].buf + offset % PAGE_SIZE;
PAGE_SIZE 399 init/main.c size = ALIGN(PERCPU_ENOUGH_ROOM, PAGE_SIZE);
PAGE_SIZE 25 ipc/msgutil.c #define DATALEN_MSG (PAGE_SIZE-sizeof(struct msg_msg))
PAGE_SIZE 26 ipc/msgutil.c #define DATALEN_SEG (PAGE_SIZE-sizeof(struct msg_msgseg))
PAGE_SIZE 171 ipc/shm.c ns->shm_tot -= (shp->shm_segsz + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 339 ipc/shm.c int numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
PAGE_SIZE 904 ipc/shm.c addr > current->mm->start_stack - size - PAGE_SIZE * 5)
PAGE_SIZE 1004 ipc/shm.c (vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff) {
PAGE_SIZE 1033 ipc/shm.c (vma->vm_start - addr)/PAGE_SIZE == vma->vm_pgoff)
PAGE_SIZE 447 ipc/util.c if(size > PAGE_SIZE)
PAGE_SIZE 465 ipc/util.c if(size > PAGE_SIZE)
PAGE_SIZE 511 ipc/util.c if (HDRLEN_KMALLOC + size > PAGE_SIZE)
PAGE_SIZE 1911 kernel/cgroup.c retval = heap_init(heap, PAGE_SIZE, GFP_KERNEL, &started_after);
PAGE_SIZE 2598 kernel/cgroup.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 2627 kernel/cgroup.c retval = cgroup_path(cgrp, buf, PAGE_SIZE);
PAGE_SIZE 3064 kernel/cgroup.c pathbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 3067 kernel/cgroup.c if (cgroup_path(cgrp, pathbuf, PAGE_SIZE) < 0)
PAGE_SIZE 1050 kernel/compat.c while (s.mem_unit < PAGE_SIZE) {
PAGE_SIZE 909 kernel/cpuset.c retval = heap_init(&heap, PAGE_SIZE, GFP_KERNEL, NULL);
PAGE_SIZE 1481 kernel/cpuset.c return cpulist_scnprintf(page, PAGE_SIZE, mask);
PAGE_SIZE 1492 kernel/cpuset.c return nodelist_scnprintf(page, PAGE_SIZE, mask);
PAGE_SIZE 2395 kernel/cpuset.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 2408 kernel/cpuset.c retval = cgroup_path(css->cgroup, buf, PAGE_SIZE);
PAGE_SIZE 183 kernel/exec_domain.c for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next)
PAGE_SIZE 185 kernel/fork.c max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);
PAGE_SIZE 194 kernel/futex.c key->both.offset = address % PAGE_SIZE;
PAGE_SIZE 559 kernel/kexec.c ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1);
PAGE_SIZE 589 kernel/kexec.c image->destination += PAGE_SIZE;
PAGE_SIZE 671 kernel/kexec.c destination += PAGE_SIZE;
PAGE_SIZE 736 kernel/kexec.c addr + PAGE_SIZE))
PAGE_SIZE 814 kernel/kexec.c memset(ptr, 0, PAGE_SIZE);
PAGE_SIZE 816 kernel/kexec.c mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
PAGE_SIZE 868 kernel/kexec.c mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
PAGE_SIZE 1368 kernel/kexec.c VMCOREINFO_PAGESIZE(PAGE_SIZE);
PAGE_SIZE 102 kernel/kprobes.c #define INSNS_PER_PAGE (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t)))
PAGE_SIZE 185 kernel/kprobes.c kip->insns = module_alloc(PAGE_SIZE);
PAGE_SIZE 385 kernel/module.c if (align > PAGE_SIZE) {
PAGE_SIZE 387 kernel/module.c name, align, PAGE_SIZE);
PAGE_SIZE 388 kernel/module.c align = PAGE_SIZE;
PAGE_SIZE 53 kernel/pid.c #define BITS_PER_PAGE (PAGE_SIZE*8)
PAGE_SIZE 138 kernel/pid.c void *page = kzalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 523 kernel/pid.c init_pid_ns.pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 17 kernel/pid_namespace.c #define BITS_PER_PAGE (PAGE_SIZE*8)
PAGE_SIZE 79 kernel/pid_namespace.c ns->pidmap[0].page = kzalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 14 kernel/power/power.h } __attribute__((aligned(PAGE_SIZE)));
PAGE_SIZE 126 kernel/power/snapshot.c #define LINKED_PAGE_DATA_SIZE (PAGE_SIZE - sizeof(void *))
PAGE_SIZE 233 kernel/power/snapshot.c #define BM_BITS_PER_BLOCK (PAGE_SIZE << 3)
PAGE_SIZE 782 kernel/power/snapshot.c res += DIV_ROUND_UP(res * sizeof(struct bm_block), PAGE_SIZE);
PAGE_SIZE 919 kernel/power/snapshot.c for (n = PAGE_SIZE / sizeof(long); n; n--)
PAGE_SIZE 970 kernel/power/snapshot.c memcpy(dst, buffer, PAGE_SIZE);
PAGE_SIZE 1232 kernel/power/snapshot.c nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
PAGE_SIZE 1290 kernel/power/snapshot.c for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
PAGE_SIZE 1342 kernel/power/snapshot.c memset(buffer, 0, PAGE_SIZE);
PAGE_SIZE 1356 kernel/power/snapshot.c memcpy(buffer, kaddr, PAGE_SIZE);
PAGE_SIZE 1366 kernel/power/snapshot.c if (handle->cur_offset + count >= PAGE_SIZE) {
PAGE_SIZE 1367 kernel/power/snapshot.c count = PAGE_SIZE - handle->cur_offset;
PAGE_SIZE 1468 kernel/power/snapshot.c for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
PAGE_SIZE 1646 kernel/power/snapshot.c memcpy(dst, buffer, PAGE_SIZE);
PAGE_SIZE 1894 kernel/power/snapshot.c if (handle->cur_offset + count >= PAGE_SIZE) {
PAGE_SIZE 1895 kernel/power/snapshot.c count = PAGE_SIZE - handle->cur_offset;
PAGE_SIZE 1938 kernel/power/snapshot.c memcpy(buf, kaddr1, PAGE_SIZE);
PAGE_SIZE 1939 kernel/power/snapshot.c memcpy(kaddr1, kaddr2, PAGE_SIZE);
PAGE_SIZE 1940 kernel/power/snapshot.c memcpy(kaddr2, buf, PAGE_SIZE);
PAGE_SIZE 33 kernel/power/swap.c char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int)];
PAGE_SIZE 68 kernel/power/swap.c bio->bi_sector = page_off * (PAGE_SIZE >> 9);
PAGE_SIZE 72 kernel/power/swap.c if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
PAGE_SIZE 179 kernel/power/swap.c res = set_blocksize(resume_bdev, PAGE_SIZE);
PAGE_SIZE 203 kernel/power/swap.c memcpy(src, buf, PAGE_SIZE);
PAGE_SIZE 230 kernel/power/swap.c #define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
PAGE_SIZE 293 kernel/power/swap.c memset(handle->cur, 0, PAGE_SIZE);
PAGE_SIZE 335 kernel/power/swap.c ret = snapshot_read_next(snapshot, PAGE_SIZE);
PAGE_SIZE 395 kernel/power/swap.c error = snapshot_read_next(&snapshot, PAGE_SIZE);
PAGE_SIZE 396 kernel/power/swap.c if (error < PAGE_SIZE) {
PAGE_SIZE 518 kernel/power/swap.c error = snapshot_write_next(snapshot, PAGE_SIZE);
PAGE_SIZE 566 kernel/power/swap.c error = snapshot_write_next(&snapshot, PAGE_SIZE);
PAGE_SIZE 567 kernel/power/swap.c if (error < PAGE_SIZE)
PAGE_SIZE 596 kernel/power/swap.c set_blocksize(resume_bdev, PAGE_SIZE);
PAGE_SIZE 597 kernel/power/swap.c memset(swsusp_header, 0, PAGE_SIZE);
PAGE_SIZE 189 kernel/power/swsusp.c k = nr_pages * (PAGE_SIZE / 1024);
PAGE_SIZE 253 kernel/power/swsusp.c } else if (size > image_size / PAGE_SIZE) {
PAGE_SIZE 254 kernel/power/swsusp.c tmp = __shrink_memory(size - (image_size / PAGE_SIZE));
PAGE_SIZE 34 kernel/profile.c #define NR_PROFILE_HIT (PAGE_SIZE/sizeof(struct profile_hit))
PAGE_SIZE 76 kernel/relay.c if (pa_size > PAGE_SIZE) {
PAGE_SIZE 1254 kernel/relay.c pidx = (read_start / PAGE_SIZE) % subbuf_pages;
PAGE_SIZE 1265 kernel/relay.c this_len = min_t(unsigned long, len, PAGE_SIZE - poff);
PAGE_SIZE 76 kernel/sched_stats.h unsigned int size = PAGE_SIZE * (1 + num_online_cpus() / 32);
PAGE_SIZE 385 kernel/time/clocksource.c count = snprintf(buf, PAGE_SIZE, "%s\n", curr_clocksource->name);
PAGE_SIZE 464 kernel/time/clocksource.c max((ssize_t)PAGE_SIZE - count, (ssize_t)0),
PAGE_SIZE 470 kernel/time/clocksource.c max((ssize_t)PAGE_SIZE - count, (ssize_t)0), "\n");
PAGE_SIZE 185 kernel/trace/ftrace.c ((PAGE_SIZE - sizeof(struct ftrace_page)) / sizeof(struct dyn_ftrace))
PAGE_SIZE 170 kernel/trace/trace.c #define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof(struct trace_entry))
PAGE_SIZE 331 kernel/trace/trace.c int len = (PAGE_SIZE - 1) - s->len;
PAGE_SIZE 366 kernel/trace/trace.c if (len > ((PAGE_SIZE - 1) - s->len))
PAGE_SIZE 378 kernel/trace/trace.c if (s->len >= (PAGE_SIZE - 1))
PAGE_SIZE 389 kernel/trace/trace.c if (len > ((PAGE_SIZE - 1) - s->len))
PAGE_SIZE 455 kernel/trace/trace.c int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;
PAGE_SIZE 786 kernel/trace/trace.c BUG_ON(idx * TRACE_ENTRY_SIZE >= PAGE_SIZE);
PAGE_SIZE 2582 kernel/trace/trace.c if (cnt >= PAGE_SIZE)
PAGE_SIZE 2583 kernel/trace/trace.c cnt = PAGE_SIZE - 1;
PAGE_SIZE 161 kernel/trace/trace.h unsigned char buffer[PAGE_SIZE];
PAGE_SIZE 88 kernel/tsacct.c stats->coremem = p->acct_rss_mem1 * PAGE_SIZE / MB;
PAGE_SIZE 89 kernel/tsacct.c stats->virtmem = p->acct_vm_mem1 * PAGE_SIZE / MB;
PAGE_SIZE 93 kernel/tsacct.c stats->hiwater_rss = mm->hiwater_rss * PAGE_SIZE / KB;
PAGE_SIZE 94 kernel/tsacct.c stats->hiwater_vm = mm->hiwater_vm * PAGE_SIZE / KB;
PAGE_SIZE 29 lib/ioremap.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 361 lib/scatterlist.c miter->length = min_t(unsigned int, len, PAGE_SIZE - off);
PAGE_SIZE 217 lib/swiotlb.c "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
PAGE_SIZE 315 lib/swiotlb.c if (size > PAGE_SIZE)
PAGE_SIZE 492 lib/vsprintf.c if ((unsigned long)s < PAGE_SIZE)
PAGE_SIZE 112 mm/backing-dev.c return snprintf(page, PAGE_SIZE-1, "%lld\n", (long long)expr); \
PAGE_SIZE 499 mm/bootmem.c if (bdata->last_end_off & (PAGE_SIZE - 1) &&
PAGE_SIZE 78 mm/dmapool.c size = PAGE_SIZE;
PAGE_SIZE 104 mm/dmapool.c return PAGE_SIZE - size;
PAGE_SIZE 151 mm/dmapool.c allocation = max_t(size_t, size, PAGE_SIZE);
PAGE_SIZE 92 mm/fremap.c size -= PAGE_SIZE;
PAGE_SIZE 93 mm/fremap.c addr += PAGE_SIZE;
PAGE_SIZE 362 mm/hugetlb.c for (i = 0; i < sz/PAGE_SIZE; i++) {
PAGE_SIZE 364 mm/hugetlb.c clear_user_highpage(page + i, addr + i * PAGE_SIZE);
PAGE_SIZE 377 mm/hugetlb.c copy_user_highpage(dst + i, src + i, addr + i*PAGE_SIZE, vma);
PAGE_SIZE 1325 mm/hugetlb.c if (size_to_hstate(PAGE_SIZE << order)) {
PAGE_SIZE 2112 mm/hugetlb.c vaddr += PAGE_SIZE;
PAGE_SIZE 575 mm/memcontrol.c while (res_counter_charge(&mem->res, PAGE_SIZE)) {
PAGE_SIZE 612 mm/memcontrol.c res_counter_uncharge(&mem->res, PAGE_SIZE);
PAGE_SIZE 728 mm/memcontrol.c res_counter_uncharge(&mem->res, PAGE_SIZE);
PAGE_SIZE 993 mm/memcontrol.c [MEM_CGROUP_STAT_CACHE] = { "cache", PAGE_SIZE, },
PAGE_SIZE 994 mm/memcontrol.c [MEM_CGROUP_STAT_RSS] = { "rss", PAGE_SIZE, },
PAGE_SIZE 1021 mm/memcontrol.c cb->fill(cb, "active", (active) * PAGE_SIZE);
PAGE_SIZE 1022 mm/memcontrol.c cb->fill(cb, "inactive", (inactive) * PAGE_SIZE);
PAGE_SIZE 1101 mm/memcontrol.c if (sizeof(*mem) < PAGE_SIZE)
PAGE_SIZE 1113 mm/memcontrol.c if (sizeof(*mem) < PAGE_SIZE)
PAGE_SIZE 592 mm/memory.c } while (dst_pte++, src_pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 721 mm/memory.c (*zap_work) -= PAGE_SIZE;
PAGE_SIZE 777 mm/memory.c } while (pte++, addr += PAGE_SIZE, (addr != end && *zap_work > 0));
PAGE_SIZE 859 mm/memory.c # define ZAP_BLOCK_SIZE (8 * PAGE_SIZE)
PAGE_SIZE 862 mm/memory.c # define ZAP_BLOCK_SIZE (1024 * PAGE_SIZE)
PAGE_SIZE 1188 mm/memory.c start += PAGE_SIZE;
PAGE_SIZE 1263 mm/memory.c start += PAGE_SIZE;
PAGE_SIZE 1476 mm/memory.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 1605 mm/memory.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 1736 mm/memory.c if (__copy_from_user_inatomic(kaddr, uaddr, PAGE_SIZE))
PAGE_SIZE 1737 mm/memory.c memset(kaddr, 0, PAGE_SIZE);
PAGE_SIZE 2127 mm/memory.c pgoff_t hlen = (holelen + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 2132 mm/memory.c (holebegin + holelen + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 2205 mm/memory.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 2207 mm/memory.c unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
PAGE_SIZE 2772 mm/memory.c len = DIV_ROUND_UP(end, PAGE_SIZE) - addr/PAGE_SIZE;
PAGE_SIZE 2893 mm/memory.c int offset = addr & (PAGE_SIZE-1);
PAGE_SIZE 2903 mm/memory.c maddr = ioremap_prot(phys_addr, PAGE_SIZE, prot);
PAGE_SIZE 2956 mm/memory.c offset = addr & (PAGE_SIZE-1);
PAGE_SIZE 2957 mm/memory.c if (bytes > PAGE_SIZE-offset)
PAGE_SIZE 2958 mm/memory.c bytes = PAGE_SIZE-offset;
PAGE_SIZE 3005 mm/memory.c p = d_path(&f->f_path, buf, PAGE_SIZE);
PAGE_SIZE 326 mm/memory_hotplug.c release_mem_region(phys_start_pfn << PAGE_SHIFT, nr_pages * PAGE_SIZE);
PAGE_SIZE 413 mm/mempolicy.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 949 mm/mempolicy.c len = (len + PAGE_SIZE - 1) & PAGE_MASK;
PAGE_SIZE 1011 mm/mempolicy.c if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
PAGE_SIZE 1023 mm/mempolicy.c if (nlongs > PAGE_SIZE/sizeof(long))
PAGE_SIZE 1053 mm/mempolicy.c if (copy > PAGE_SIZE)
PAGE_SIZE 102 mm/mincore.c for (i = 0; i < nr; i++, ptep++, addr += PAGE_SIZE) {
PAGE_SIZE 213 mm/mincore.c retval = do_mincore(start, tmp, min(pages, PAGE_SIZE));
PAGE_SIZE 243 mm/mlock.c locked = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 263 mm/mlock.c user->locked_shm -= (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 288 mm/mmap.c if (find_vma_intersection(mm, oldbrk, newbrk+PAGE_SIZE))
PAGE_SIZE 78 mm/mprotect.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 108 mm/mremap.c for (; old_addr < old_end; old_pte++, old_addr += PAGE_SIZE,
PAGE_SIZE 109 mm/mremap.c new_pte++, new_addr += PAGE_SIZE) {
PAGE_SIZE 127 mm/mremap.c #define LATENCY_LIMIT (64 * PAGE_SIZE)
PAGE_SIZE 128 mm/nommu.c return PAGE_SIZE << compound_order(page);
PAGE_SIZE 169 mm/nommu.c start += PAGE_SIZE;
PAGE_SIZE 922 mm/nommu.c unsigned long pglen = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 943 mm/nommu.c vmpglen = vma->vm_end - vma->vm_start + PAGE_SIZE - 1;
PAGE_SIZE 523 mm/page_alloc.c debug_check_no_locks_freed(page_address(page),PAGE_SIZE<<order);
PAGE_SIZE 525 mm/page_alloc.c PAGE_SIZE << order);
PAGE_SIZE 983 mm/page_alloc.c debug_check_no_locks_freed(page_address(page), PAGE_SIZE);
PAGE_SIZE 984 mm/page_alloc.c debug_check_no_obj_freed(page_address(page), PAGE_SIZE);
PAGE_SIZE 1727 mm/page_alloc.c unsigned long alloc_end = addr + (PAGE_SIZE << order);
PAGE_SIZE 1733 mm/page_alloc.c used += PAGE_SIZE;
PAGE_SIZE 1755 mm/page_alloc.c addr += PAGE_SIZE;
PAGE_SIZE 1811 mm/page_alloc.c val->mem_unit = PAGE_SIZE;
PAGE_SIZE 1831 mm/page_alloc.c val->mem_unit = PAGE_SIZE;
PAGE_SIZE 2645 mm/page_alloc.c if (batch * PAGE_SIZE > 512 * 1024)
PAGE_SIZE 2646 mm/page_alloc.c batch = (512 * 1024) / PAGE_SIZE;
PAGE_SIZE 4280 mm/page_alloc.c lowmem_kbytes = nr_free_buffer_pages() * (PAGE_SIZE >> 10);
PAGE_SIZE 4431 mm/page_alloc.c if (unlikely((numentries * bucketsize) < PAGE_SIZE))
PAGE_SIZE 4432 mm/page_alloc.c numentries = PAGE_SIZE / bucketsize;
PAGE_SIZE 4462 mm/page_alloc.c (PAGE_SIZE << order);
PAGE_SIZE 4468 mm/page_alloc.c used += PAGE_SIZE;
PAGE_SIZE 4472 mm/page_alloc.c } while (!table && size > PAGE_SIZE && --log2qty);
PAGE_SIZE 34 mm/page_io.c (PAGE_SIZE >> 9);
PAGE_SIZE 37 mm/page_io.c bio->bi_io_vec[0].bv_len = PAGE_SIZE;
PAGE_SIZE 41 mm/page_io.c bio->bi_size = PAGE_SIZE;
PAGE_SIZE 13 mm/pagewalk.c err = walk->pte_entry(pte, addr, addr + PAGE_SIZE, walk);
PAGE_SIZE 16 mm/pagewalk.c addr += PAGE_SIZE;
PAGE_SIZE 806 mm/rmap.c #define CLUSTER_SIZE min(32*PAGE_SIZE, PMD_SIZE)
PAGE_SIZE 847 mm/rmap.c for (; address < end; pte++, address += PAGE_SIZE) {
PAGE_SIZE 812 mm/slab.c size_t slab_size = PAGE_SIZE << gfporder;
PAGE_SIZE 1912 mm/slab.c if (cachep->buffer_size % PAGE_SIZE == 0 &&
PAGE_SIZE 1915 mm/slab.c cachep->buffer_size / PAGE_SIZE, 1);
PAGE_SIZE 2051 mm/slab.c if (left_over * 8 <= (PAGE_SIZE << gfporder))
PAGE_SIZE 2298 mm/slab.c && cachep->obj_size > cache_line_size() && size < PAGE_SIZE) {
PAGE_SIZE 2299 mm/slab.c cachep->obj_offset += PAGE_SIZE - size;
PAGE_SIZE 2300 mm/slab.c size = PAGE_SIZE;
PAGE_SIZE 2310 mm/slab.c if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init)
PAGE_SIZE 2665 mm/slab.c if ((cachep->buffer_size % PAGE_SIZE) == 0 &&
PAGE_SIZE 2668 mm/slab.c cachep->buffer_size / PAGE_SIZE, 0);
PAGE_SIZE 2902 mm/slab.c if ((cachep->buffer_size % PAGE_SIZE)==0 && OFF_SLAB(cachep)) {
PAGE_SIZE 2905 mm/slab.c cachep->buffer_size / PAGE_SIZE, 0);
PAGE_SIZE 3057 mm/slab.c if ((cachep->buffer_size % PAGE_SIZE) == 0 && OFF_SLAB(cachep))
PAGE_SIZE 3059 mm/slab.c cachep->buffer_size / PAGE_SIZE, 1);
PAGE_SIZE 3970 mm/slab.c else if (cachep->buffer_size > PAGE_SIZE)
PAGE_SIZE 3989 mm/slab.c if (cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > 1)
PAGE_SIZE 78 mm/slob.c #if PAGE_SIZE <= (32767 * 2)
PAGE_SIZE 359 mm/slob.c sp->units = SLOB_UNITS(PAGE_SIZE);
PAGE_SIZE 362 mm/slob.c set_slob(b, SLOB_UNITS(PAGE_SIZE), b + SLOB_UNITS(PAGE_SIZE));
PAGE_SIZE 392 mm/slob.c if (sp->units + units == SLOB_UNITS(PAGE_SIZE)) {
PAGE_SIZE 408 mm/slob.c SLOB_UNITS(PAGE_SIZE)) & PAGE_MASK));
PAGE_SIZE 467 mm/slob.c if (size < PAGE_SIZE - align) {
PAGE_SIZE 572 mm/slob.c if (c->size < PAGE_SIZE)
PAGE_SIZE 586 mm/slob.c if (size < PAGE_SIZE)
PAGE_SIZE 292 mm/slub.c (order << 16) + (PAGE_SIZE << order) / size
PAGE_SIZE 463 mm/slub.c print_section("Object", p, min_t(unsigned long, s->objsize, PAGE_SIZE));
PAGE_SIZE 631 mm/slub.c length = (PAGE_SIZE << compound_order(page));
PAGE_SIZE 715 mm/slub.c maxobj = (PAGE_SIZE << compound_order(page)) / s->size;
PAGE_SIZE 765 mm/slub.c max_objects = (PAGE_SIZE << compound_order(page)) / s->size;
PAGE_SIZE 1133 mm/slub.c memset(start, POISON_INUSE, PAGE_SIZE << compound_order(page));
PAGE_SIZE 1809 mm/slub.c if ((PAGE_SIZE << min_order) / size > 65535)
PAGE_SIZE 1816 mm/slub.c unsigned long slab_size = PAGE_SIZE << order;
PAGE_SIZE 2653 mm/slub.c if (unlikely(size > PAGE_SIZE))
PAGE_SIZE 2681 mm/slub.c if (unlikely(size > PAGE_SIZE))
PAGE_SIZE 2706 mm/slub.c return PAGE_SIZE << compound_order(page);
PAGE_SIZE 3206 mm/slub.c if (unlikely(size > PAGE_SIZE))
PAGE_SIZE 3222 mm/slub.c if (unlikely(size > PAGE_SIZE))
PAGE_SIZE 3571 mm/slub.c if (!alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location),
PAGE_SIZE 3597 mm/slub.c if (len > PAGE_SIZE - 100)
PAGE_SIZE 3623 mm/slub.c len < PAGE_SIZE - 60) {
PAGE_SIZE 3625 mm/slub.c len += cpulist_scnprintf(buf + len, PAGE_SIZE - len - 50,
PAGE_SIZE 3630 mm/slub.c len < PAGE_SIZE - 60) {
PAGE_SIZE 3632 mm/slub.c len += nodelist_scnprintf(buf + len, PAGE_SIZE - len - 50,
PAGE_SIZE 4092 mm/slub.c if (data[cpu] && len < PAGE_SIZE - 20)
PAGE_SIZE 77 mm/sparse-vmemmap.c void *p = vmemmap_alloc_block(PAGE_SIZE, node);
PAGE_SIZE 90 mm/sparse-vmemmap.c void *p = vmemmap_alloc_block(PAGE_SIZE, node);
PAGE_SIZE 102 mm/sparse-vmemmap.c void *p = vmemmap_alloc_block(PAGE_SIZE, node);
PAGE_SIZE 114 mm/sparse-vmemmap.c void *p = vmemmap_alloc_block(PAGE_SIZE, node);
PAGE_SIZE 132 mm/sparse-vmemmap.c for (; addr < end; addr += PAGE_SIZE) {
PAGE_SIZE 145 mm/sparse-vmemmap.c vmemmap_verify(pte, node, addr, addr + PAGE_SIZE);
PAGE_SIZE 575 mm/swapfile.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 633 mm/swapfile.c end = addr + PAGE_SIZE;
PAGE_SIZE 1109 mm/swapfile.c blocks_per_page = PAGE_SIZE >> blkbits;
PAGE_SIZE 1529 mm/swapfile.c error = set_blocksize(bdev, PAGE_SIZE);
PAGE_SIZE 40 mm/vmalloc.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 112 mm/vmalloc.c } while (pte++, addr += PAGE_SIZE, addr != end);
PAGE_SIZE 155 mm/vmalloc.c unsigned long end = addr + area->size - PAGE_SIZE;
PAGE_SIZE 248 mm/vmalloc.c size += PAGE_SIZE;
PAGE_SIZE 362 mm/vmalloc.c tmp->size -= PAGE_SIZE;
PAGE_SIZE 390 mm/vmalloc.c if ((PAGE_SIZE-1) & (unsigned long)addr) {
PAGE_SIZE 496 mm/vmalloc.c nr_pages = (area->size - PAGE_SIZE) >> PAGE_SHIFT;
PAGE_SIZE 501 mm/vmalloc.c if (array_size > PAGE_SIZE) {
PAGE_SIZE 721 mm/vmalloc.c if (addr >= vaddr + tmp->size - PAGE_SIZE)
PAGE_SIZE 731 mm/vmalloc.c n = vaddr + tmp->size - PAGE_SIZE - addr;
PAGE_SIZE 759 mm/vmalloc.c if (addr >= vaddr + tmp->size - PAGE_SIZE)
PAGE_SIZE 768 mm/vmalloc.c n = vaddr + tmp->size - PAGE_SIZE - addr;
PAGE_SIZE 805 mm/vmalloc.c if ((PAGE_SIZE-1) & (unsigned long)addr)
PAGE_SIZE 816 mm/vmalloc.c if (usize + (pgoff << PAGE_SHIFT) > area->size - PAGE_SIZE)
PAGE_SIZE 827 mm/vmalloc.c uaddr += PAGE_SIZE;
PAGE_SIZE 828 mm/vmalloc.c addr += PAGE_SIZE;
PAGE_SIZE 829 mm/vmalloc.c usize -= PAGE_SIZE;
PAGE_SIZE 188 net/9p/trans_virtio.c return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE);
PAGE_SIZE 529 net/9p/trans_virtio.c .maxsize = PAGE_SIZE*16,
PAGE_SIZE 201 net/atm/mpoa_proc.c if (nbytes >= PAGE_SIZE)
PAGE_SIZE 202 net/atm/mpoa_proc.c nbytes = PAGE_SIZE-1;
PAGE_SIZE 584 net/bluetooth/hci_conn.c if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
PAGE_SIZE 754 net/bluetooth/hci_core.c if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr))
PAGE_SIZE 472 net/bluetooth/rfcomm/tty.c if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
PAGE_SIZE 65 net/bridge/br_ioctl.c if (maxnum > PAGE_SIZE/sizeof(struct __fdb_entry))
PAGE_SIZE 66 net/bridge/br_ioctl.c maxnum = PAGE_SIZE/sizeof(struct __fdb_entry);
PAGE_SIZE 154 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, ">>> socket %p",
PAGE_SIZE 156 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, " / sk %p", sk);
PAGE_SIZE 157 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, " / bo %p", bo);
PAGE_SIZE 158 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, " / dropped %lu",
PAGE_SIZE 160 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, " / bound %s",
PAGE_SIZE 162 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, " <<<\n");
PAGE_SIZE 172 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 175 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "[%d]%c ",
PAGE_SIZE 179 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 185 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 190 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 196 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "%s%ld%%\n",
PAGE_SIZE 199 net/can/bcm.c if (len > PAGE_SIZE - 200) {
PAGE_SIZE 201 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
PAGE_SIZE 208 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 214 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "t1=%lld ",
PAGE_SIZE 218 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "t2=%lld ",
PAGE_SIZE 221 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "# sent %ld\n",
PAGE_SIZE 224 net/can/bcm.c if (len > PAGE_SIZE - 100) {
PAGE_SIZE 226 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "(..)\n");
PAGE_SIZE 231 net/can/bcm.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 211 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, fmt,
PAGE_SIZE 219 net/can/proc.c if (len > PAGE_SIZE - 100) {
PAGE_SIZE 221 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 237 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 249 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 250 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 253 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 255 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 258 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 261 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 265 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 268 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 272 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 274 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 278 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 281 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 285 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 287 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 291 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 294 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 298 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 301 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 304 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 309 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 314 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 318 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 332 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 340 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 354 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "%s\n",
PAGE_SIZE 369 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 379 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 383 net/can/proc.c if (len > PAGE_SIZE - 100)
PAGE_SIZE 388 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 402 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 419 net/can/proc.c len < PAGE_SIZE - 100)
PAGE_SIZE 425 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len,
PAGE_SIZE 429 net/can/proc.c if (len > PAGE_SIZE - 100)
PAGE_SIZE 434 net/can/proc.c len += snprintf(page + len, PAGE_SIZE - len, "\n");
PAGE_SIZE 811 net/core/dev.c const int max_netdevices = 8*PAGE_SIZE;
PAGE_SIZE 336 net/core/ethtool.c data = kmalloc(PAGE_SIZE, GFP_USER);
PAGE_SIZE 342 net/core/ethtool.c eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
PAGE_SIZE 388 net/core/ethtool.c data = kmalloc(PAGE_SIZE, GFP_USER);
PAGE_SIZE 394 net/core/ethtool.c eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
PAGE_SIZE 316 net/core/flow.c (PAGE_SIZE << order) <
PAGE_SIZE 304 net/core/neighbour.c if (size <= PAGE_SIZE) {
PAGE_SIZE 317 net/core/neighbour.c if (size <= PAGE_SIZE)
PAGE_SIZE 2629 net/core/pktgen.c if (datalen > frags * PAGE_SIZE) {
PAGE_SIZE 2630 net/core/pktgen.c skb_put(skb, datalen - frags * PAGE_SIZE);
PAGE_SIZE 2631 net/core/pktgen.c datalen = frags * PAGE_SIZE;
PAGE_SIZE 2640 net/core/pktgen.c (datalen < PAGE_SIZE ? datalen : PAGE_SIZE);
PAGE_SIZE 2977 net/core/pktgen.c if (datalen > frags * PAGE_SIZE) {
PAGE_SIZE 2978 net/core/pktgen.c skb_put(skb, datalen - frags * PAGE_SIZE);
PAGE_SIZE 2979 net/core/pktgen.c datalen = frags * PAGE_SIZE;
PAGE_SIZE 2988 net/core/pktgen.c (datalen < PAGE_SIZE ? datalen : PAGE_SIZE);
PAGE_SIZE 47 net/core/request_sock.c if (lopt_size > PAGE_SIZE)
PAGE_SIZE 86 net/core/request_sock.c if (lopt_size > PAGE_SIZE)
PAGE_SIZE 127 net/core/request_sock.c if (lopt_size > PAGE_SIZE)
PAGE_SIZE 1351 net/core/skbuff.c *page += *poff / PAGE_SIZE;
PAGE_SIZE 1352 net/core/skbuff.c *poff = *poff % PAGE_SIZE;
PAGE_SIZE 1380 net/core/skbuff.c flen = min_t(unsigned int, flen, PAGE_SIZE - poff);
PAGE_SIZE 1407 net/core/skbuff.c (unsigned long) skb->data & (PAGE_SIZE - 1),
PAGE_SIZE 2211 net/core/skbuff.c skb->truesize += PAGE_SIZE;
PAGE_SIZE 2212 net/core/skbuff.c atomic_add(PAGE_SIZE, &sk->sk_wmem_alloc);
PAGE_SIZE 2219 net/core/skbuff.c left = PAGE_SIZE - frag->page_offset;
PAGE_SIZE 1293 net/core/sock.c npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
PAGE_SIZE 1311 net/core/sock.c frag->size = (data_len >= PAGE_SIZE ?
PAGE_SIZE 1312 net/core/sock.c PAGE_SIZE :
PAGE_SIZE 1314 net/core/sock.c data_len -= PAGE_SIZE;
PAGE_SIZE 1072 net/dccp/proto.c dccp_hashinfo.ehash_size = (1UL << ehash_order) * PAGE_SIZE /
PAGE_SIZE 1097 net/dccp/proto.c dccp_hashinfo.bhash_size = (1UL << bhash_order) * PAGE_SIZE /
PAGE_SIZE 1766 net/decnet/dn_route.c while(order && ((((1UL << order) * PAGE_SIZE) /
PAGE_SIZE 1771 net/decnet/dn_route.c dn_rt_hash_mask = (1UL << order) * PAGE_SIZE /
PAGE_SIZE 393 net/ethernet/eth.c l = _format_mac_addr(buf, PAGE_SIZE, addr, len);
PAGE_SIZE 394 net/ethernet/eth.c l += strlcpy(buf + l, "\n", PAGE_SIZE - l);
PAGE_SIZE 97 net/ipv4/fib_hash.c #define FZ_MAX_DIVISOR ((PAGE_SIZE<<MAX_ORDER) / sizeof(struct hlist_head))
PAGE_SIZE 103 net/ipv4/fib_hash.c if (size <= PAGE_SIZE) {
PAGE_SIZE 137 net/ipv4/fib_hash.c if (size <= PAGE_SIZE)
PAGE_SIZE 611 net/ipv4/fib_semantics.c if (bytes <= PAGE_SIZE)
PAGE_SIZE 623 net/ipv4/fib_semantics.c if (bytes <= PAGE_SIZE)
PAGE_SIZE 354 net/ipv4/fib_trie.c if (size <= PAGE_SIZE)
PAGE_SIZE 372 net/ipv4/fib_trie.c if (size <= PAGE_SIZE)
PAGE_SIZE 113 net/ipv4/inetpeer.c if (si.totalram <= (32768*1024)/PAGE_SIZE)
PAGE_SIZE 115 net/ipv4/inetpeer.c if (si.totalram <= (16384*1024)/PAGE_SIZE)
PAGE_SIZE 117 net/ipv4/inetpeer.c if (si.totalram <= (8192*1024)/PAGE_SIZE)
PAGE_SIZE 1003 net/ipv4/ip_output.c if (page && (left = PAGE_SIZE - off) > 0) {
PAGE_SIZE 1016 net/ipv4/ip_output.c if (copy > PAGE_SIZE)
PAGE_SIZE 1017 net/ipv4/ip_output.c copy = PAGE_SIZE;
PAGE_SIZE 684 net/ipv4/tcp.c struct page *page = pages[poffset / PAGE_SIZE];
PAGE_SIZE 686 net/ipv4/tcp.c int offset = poffset % PAGE_SIZE;
PAGE_SIZE 687 net/ipv4/tcp.c int size = min_t(size_t, psize, PAGE_SIZE - offset);
PAGE_SIZE 807 net/ipv4/tcp.c tmp <= pgbreak + (MAX_SKB_FRAGS - 1) * PAGE_SIZE)
PAGE_SIZE 907 net/ipv4/tcp.c off != PAGE_SIZE) {
PAGE_SIZE 921 net/ipv4/tcp.c if (off == PAGE_SIZE) {
PAGE_SIZE 929 net/ipv4/tcp.c if (copy > PAGE_SIZE - off)
PAGE_SIZE 930 net/ipv4/tcp.c copy = PAGE_SIZE - off;
PAGE_SIZE 964 net/ipv4/tcp.c } else if (off + copy < PAGE_SIZE) {
PAGE_SIZE 1357 net/ipv6/ip6_output.c if (page && (left = PAGE_SIZE - off) > 0) {
PAGE_SIZE 1370 net/ipv6/ip6_output.c if (copy > PAGE_SIZE)
PAGE_SIZE 1371 net/ipv6/ip6_output.c copy = PAGE_SIZE;
PAGE_SIZE 459 net/key/af_key.c if (len > PAGE_SIZE)
PAGE_SIZE 1068 net/netfilter/nf_conntrack_core.c size = *sizep = roundup(*sizep, PAGE_SIZE / sizeof(struct hlist_head));
PAGE_SIZE 1154 net/netfilter/nf_conntrack_core.c if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))
PAGE_SIZE 588 net/netfilter/x_tables.c if (size <= PAGE_SIZE)
PAGE_SIZE 611 net/netfilter/x_tables.c if (info->size <= PAGE_SIZE)
PAGE_SIZE 199 net/netfilter/xt_hashlimit.c if (num_physpages > (1024 * 1024 * 1024 / PAGE_SIZE))
PAGE_SIZE 271 net/netfilter/xt_hashlimit.c if (num_physpages > 1024 * 1024 * 1024 / PAGE_SIZE)
PAGE_SIZE 244 net/netlink/af_netlink.c if (size <= PAGE_SIZE)
PAGE_SIZE 254 net/netlink/af_netlink.c if (size <= PAGE_SIZE)
PAGE_SIZE 1813 net/packet/af_packet.c if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
PAGE_SIZE 1880 net/packet/af_packet.c po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
PAGE_SIZE 1922 net/packet/af_packet.c if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
PAGE_SIZE 1934 net/packet/af_packet.c start += PAGE_SIZE;
PAGE_SIZE 219 net/rxrpc/ar-key.c if (optlen <= 0 || optlen > PAGE_SIZE - 1)
PAGE_SIZE 256 net/rxrpc/ar-key.c if (optlen <= 0 || optlen > PAGE_SIZE - 1)
PAGE_SIZE 700 net/rxrpc/rxkad.c if (sg[0].offset + buflen > PAGE_SIZE) {
PAGE_SIZE 702 net/rxrpc/rxkad.c sg[0].length = PAGE_SIZE - sg[0].offset;
PAGE_SIZE 31 net/sched/cls_fw.c #define HTSIZE (PAGE_SIZE/sizeof(struct fw_filter *))
PAGE_SIZE 504 net/sched/sch_api.c if (size <= PAGE_SIZE)
PAGE_SIZE 521 net/sched/sch_api.c if (size <= PAGE_SIZE)
PAGE_SIZE 1218 net/sctp/protocol.c sctp_assoc_hashsize = (1UL << order) * PAGE_SIZE /
PAGE_SIZE 1251 net/sctp/protocol.c sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
PAGE_SIZE 618 net/sunrpc/auth_gss/svcauth_gss.c if (resv->iov_len + 4 > PAGE_SIZE)
PAGE_SIZE 623 net/sunrpc/auth_gss/svcauth_gss.c if (resv->iov_len > PAGE_SIZE)
PAGE_SIZE 1018 net/sunrpc/auth_gss/svcauth_gss.c if (resv->iov_len + 4 > PAGE_SIZE)
PAGE_SIZE 1023 net/sunrpc/auth_gss/svcauth_gss.c if (resv->iov_len + 3 * 4 > PAGE_SIZE)
PAGE_SIZE 1131 net/sunrpc/auth_gss/svcauth_gss.c if (resv->iov_len + 4 > PAGE_SIZE)
PAGE_SIZE 1243 net/sunrpc/auth_gss/svcauth_gss.c if (resbuf->head[0].iov_len + RPC_MAX_AUTH_SIZE > PAGE_SIZE)
PAGE_SIZE 1261 net/sunrpc/auth_gss/svcauth_gss.c BUG_ON(resv->iov_len > PAGE_SIZE);
PAGE_SIZE 1290 net/sunrpc/auth_gss/svcauth_gss.c + PAGE_SIZE);
PAGE_SIZE 1293 net/sunrpc/auth_gss/svcauth_gss.c + 2 * RPC_MAX_AUTH_SIZE > PAGE_SIZE)
PAGE_SIZE 1301 net/sunrpc/auth_gss/svcauth_gss.c if (resbuf->head[0].iov_len + 2*RPC_MAX_AUTH_SIZE > PAGE_SIZE)
PAGE_SIZE 544 net/sunrpc/cache.c #define DFR_HASHSIZE (PAGE_SIZE/sizeof(struct list_head))
PAGE_SIZE 1052 net/sunrpc/cache.c buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 1062 net/sunrpc/cache.c bp = buf; len = PAGE_SIZE;
PAGE_SIZE 1074 net/sunrpc/cache.c crq->len = PAGE_SIZE - len;
PAGE_SIZE 379 net/sunrpc/svc.c serv->sv_max_mesg = roundup(serv->sv_max_payload + PAGE_SIZE, PAGE_SIZE);
PAGE_SIZE 506 net/sunrpc/svc.c pages = size / PAGE_SIZE + 1; /* extra page as we hold both request and reply.
PAGE_SIZE 1021 net/sunrpc/svc.c rqstp->rq_res.buflen = PAGE_SIZE;
PAGE_SIZE 589 net/sunrpc/svc_xprt.c pages = (serv->sv_max_mesg + PAGE_SIZE) / PAGE_SIZE;
PAGE_SIZE 609 net/sunrpc/svc_xprt.c arg->head[0].iov_len = PAGE_SIZE;
PAGE_SIZE 613 net/sunrpc/svc_xprt.c arg->page_len = (pages-2)*PAGE_SIZE;
PAGE_SIZE 614 net/sunrpc/svc_xprt.c arg->len = (pages-1)*PAGE_SIZE;
PAGE_SIZE 211 net/sunrpc/svcsock.c size = PAGE_SIZE - base < pglen ? PAGE_SIZE - base : pglen;
PAGE_SIZE 222 net/sunrpc/svcsock.c size = PAGE_SIZE < pglen ? PAGE_SIZE : pglen;
PAGE_SIZE 230 net/sunrpc/svcsock.c & (PAGE_SIZE-1),
PAGE_SIZE 535 net/sunrpc/svcsock.c DIV_ROUND_UP(rqstp->rq_arg.page_len, PAGE_SIZE);
PAGE_SIZE 883 net/sunrpc/svcsock.c vlen = PAGE_SIZE;
PAGE_SIZE 887 net/sunrpc/svcsock.c vec[pnum].iov_len = PAGE_SIZE;
PAGE_SIZE 889 net/sunrpc/svcsock.c vlen += PAGE_SIZE;
PAGE_SIZE 104 net/sunrpc/xprtrdma/rpc_rdma.c PAGE_SIZE - xdrbuf->page_base, xdrbuf->page_len);
PAGE_SIZE 113 net/sunrpc/xprtrdma/rpc_rdma.c seg[n].mr_len = min_t(u32, PAGE_SIZE, len);
PAGE_SIZE 313 net/sunrpc/xprtrdma/rpc_rdma.c curlen = PAGE_SIZE - rqst->rq_snd_buf.page_base;
PAGE_SIZE 315 net/sunrpc/xprtrdma/rpc_rdma.c curlen = PAGE_SIZE;
PAGE_SIZE 624 net/sunrpc/xprtrdma/rpc_rdma.c curlen = PAGE_SIZE - rqst->rq_rcv_buf.page_base;
PAGE_SIZE 626 net/sunrpc/xprtrdma/rpc_rdma.c curlen = PAGE_SIZE;
PAGE_SIZE 164 net/sunrpc/xprtrdma/svc_rdma_recvfrom.c sge_bytes = min_t(int, PAGE_SIZE-page_off, ch_bytes);
PAGE_SIZE 198 net/sunrpc/xprtrdma/svc_rdma_recvfrom.c if ((sge_bytes + page_off) == PAGE_SIZE) {
PAGE_SIZE 268 net/sunrpc/xprtrdma/svc_rdma_recvfrom.c PAGE_SIZE, DMA_TO_DEVICE);
PAGE_SIZE 103 net/sunrpc/xprtrdma/svc_rdma_sendto.c frmr->map_len = PAGE_SIZE;
PAGE_SIZE 108 net/sunrpc/xprtrdma/svc_rdma_sendto.c PAGE_SIZE, DMA_TO_DEVICE);
PAGE_SIZE 127 net/sunrpc/xprtrdma/svc_rdma_sendto.c sge_bytes = min_t(u32, page_bytes, (PAGE_SIZE - page_off));
PAGE_SIZE 132 net/sunrpc/xprtrdma/svc_rdma_sendto.c PAGE_SIZE, DMA_TO_DEVICE);
PAGE_SIZE 139 net/sunrpc/xprtrdma/svc_rdma_sendto.c frmr->map_len += PAGE_SIZE;
PAGE_SIZE 168 net/sunrpc/xprtrdma/svc_rdma_sendto.c ib_dma_map_single(xprt->sc_cm_id->device, va, PAGE_SIZE,
PAGE_SIZE 174 net/sunrpc/xprtrdma/svc_rdma_sendto.c frmr->map_len += PAGE_SIZE;
PAGE_SIZE 194 net/sunrpc/xprtrdma/svc_rdma_sendto.c int sge_max = (xdr->len+PAGE_SIZE-1) / PAGE_SIZE + 3;
PAGE_SIZE 222 net/sunrpc/xprtrdma/svc_rdma_sendto.c sge_bytes = min_t(u32, page_bytes, (PAGE_SIZE - page_off));
PAGE_SIZE 361 net/sunrpc/xprtrdma/svc_rdma_sendto.c max_write = xprt->sc_max_sge * PAGE_SIZE;
PAGE_SIZE 435 net/sunrpc/xprtrdma/svc_rdma_sendto.c max_write = xprt->sc_max_sge * PAGE_SIZE;
PAGE_SIZE 532 net/sunrpc/xprtrdma/svc_rdma_sendto.c page, 0, PAGE_SIZE, DMA_TO_DEVICE);
PAGE_SIZE 504 net/sunrpc/xprtrdma/svc_rdma_transport.c page, 0, PAGE_SIZE,
PAGE_SIZE 510 net/sunrpc/xprtrdma/svc_rdma_transport.c ctxt->sge[sge_no].length = PAGE_SIZE;
PAGE_SIZE 512 net/sunrpc/xprtrdma/svc_rdma_transport.c buflen += PAGE_SIZE;
PAGE_SIZE 795 net/sunrpc/xprtrdma/svc_rdma_transport.c ib_dma_unmap_single(frmr->mr->device, addr, PAGE_SIZE,
PAGE_SIZE 1318 net/sunrpc/xprtrdma/svc_rdma_transport.c p, 0, PAGE_SIZE, DMA_FROM_DEVICE);
PAGE_SIZE 1346 net/sunrpc/xprtrdma/svc_rdma_transport.c sge.addr, PAGE_SIZE,
PAGE_SIZE 84 net/sunrpc/xprtrdma/transport.c static unsigned int max_padding = PAGE_SIZE;
PAGE_SIZE 347 net/sunrpc/xprtrdma/transport.c xprt->max_payload = RPCRDMA_MAX_DATA_SEGS * PAGE_SIZE;
PAGE_SIZE 374 net/sunrpc/xprtrdma/transport.c cdata.rsize = RPCRDMA_MAX_SEGS * PAGE_SIZE; /* RDMA write max */
PAGE_SIZE 375 net/sunrpc/xprtrdma/transport.c cdata.wsize = RPCRDMA_MAX_SEGS * PAGE_SIZE; /* RDMA read max */
PAGE_SIZE 437 net/sunrpc/xprtsock.c unsigned int len = min_t(unsigned int, PAGE_SIZE - base, remainder);
PAGE_SIZE 19 net/xfrm/xfrm_hash.c if (sz <= PAGE_SIZE)
PAGE_SIZE 33 net/xfrm/xfrm_hash.c if (sz <= PAGE_SIZE)
PAGE_SIZE 86 net/xfrm/xfrm_ipcomp.c len = PAGE_SIZE;
PAGE_SIZE 1864 net/xfrm/xfrm_state.c if (optlen <= 0 || optlen > PAGE_SIZE)
PAGE_SIZE 78 security/keys/keyctl.c description = strndup_user(_description, PAGE_SIZE);
PAGE_SIZE 92 security/keys/keyctl.c if (plen <= PAGE_SIZE)
PAGE_SIZE 167 security/keys/keyctl.c description = strndup_user(_description, PAGE_SIZE);
PAGE_SIZE 177 security/keys/keyctl.c callout_info = strndup_user(_callout_info, PAGE_SIZE);
PAGE_SIZE 264 security/keys/keyctl.c name = strndup_user(_name, PAGE_SIZE);
PAGE_SIZE 294 security/keys/keyctl.c if (plen > PAGE_SIZE)
PAGE_SIZE 489 security/keys/keyctl.c tmpbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
PAGE_SIZE 495 security/keys/keyctl.c ret = snprintf(tmpbuf, PAGE_SIZE - 1,
PAGE_SIZE 506 security/keys/keyctl.c if (ret > PAGE_SIZE - 1)
PAGE_SIZE 507 security/keys/keyctl.c ret = PAGE_SIZE - 1;
PAGE_SIZE 553 security/keys/keyctl.c description = strndup_user(_description, PAGE_SIZE);
PAGE_SIZE 871 security/keys/keyctl.c if (plen <= PAGE_SIZE)
PAGE_SIZE 730 security/keys/keyring.c BUG_ON(size > PAGE_SIZE);
PAGE_SIZE 783 security/keys/keyring.c if (size > PAGE_SIZE)
PAGE_SIZE 269 security/selinux/avc.c return scnprintf(page, PAGE_SIZE, "entries: %d\nbuckets used: %d/%d\n"
PAGE_SIZE 1129 security/selinux/hooks.c buflen = PAGE_SIZE;
PAGE_SIZE 1824 security/selinux/hooks.c buflen = PAGE_SIZE;
PAGE_SIZE 157 security/selinux/selinuxfs.c if (count >= PAGE_SIZE)
PAGE_SIZE 229 security/selinux/selinuxfs.c if (count >= PAGE_SIZE)
PAGE_SIZE 426 security/selinux/selinuxfs.c if (count >= PAGE_SIZE)
PAGE_SIZE 475 security/selinux/selinuxfs.c if (count >= PAGE_SIZE)
PAGE_SIZE 870 security/selinux/selinuxfs.c if (count > PAGE_SIZE) {
PAGE_SIZE 885 security/selinux/selinuxfs.c length = scnprintf(page, PAGE_SIZE, "%d %d", cur_enforcing,
PAGE_SIZE 916 security/selinux/selinuxfs.c if (count >= PAGE_SIZE) {
PAGE_SIZE 972 security/selinux/selinuxfs.c if (count >= PAGE_SIZE) {
PAGE_SIZE 1077 security/selinux/selinuxfs.c len = snprintf(page, PAGE_SIZE, "/%s/%s", BOOL_DIR_NAME, names[i]);
PAGE_SIZE 1081 security/selinux/selinuxfs.c } else if (len >= PAGE_SIZE) {
PAGE_SIZE 1136 security/selinux/selinuxfs.c if (count >= PAGE_SIZE) {
PAGE_SIZE 1392 security/selinux/selinuxfs.c len = snprintf(page, PAGE_SIZE, "%d", sel_ino_to_class(ino));
PAGE_SIZE 1416 security/selinux/selinuxfs.c len = snprintf(page, PAGE_SIZE, "%d", sel_ino_to_perm(ino));
PAGE_SIZE 214 security/selinux/xfrm.c if (str_len >= PAGE_SIZE)
PAGE_SIZE 415 sound/arm/aaci.c .period_bytes_max = PAGE_SIZE,
PAGE_SIZE 417 sound/arm/aaci.c .periods_max = PAGE_SIZE / 16,
PAGE_SIZE 32 sound/arm/pxa2xx-pcm-lib.c .periods_max = PAGE_SIZE/sizeof(pxa_dma_desc),
PAGE_SIZE 201 sound/arm/pxa2xx-pcm-lib.c dma_alloc_writecombine(substream->pcm->card->dev, PAGE_SIZE,
PAGE_SIZE 221 sound/arm/pxa2xx-pcm-lib.c dma_free_writecombine(substream->pcm->card->dev, PAGE_SIZE,
PAGE_SIZE 129 sound/core/info.c err = resize_info_buffer(buffer, buffer->len + PAGE_SIZE);
PAGE_SIZE 349 sound/core/info.c buffer->len = PAGE_SIZE;
PAGE_SIZE 359 sound/core/info.c buffer->len = PAGE_SIZE;
PAGE_SIZE 141 sound/core/memalloc.c res = dma_alloc_coherent(dev, PAGE_SIZE << pg, dma, gfp_flags);
PAGE_SIZE 158 sound/core/memalloc.c dma_free_coherent(dev, PAGE_SIZE << pg, ptr, dma);
PAGE_SIZE 242 sound/core/memalloc.c if (size <= PAGE_SIZE)
PAGE_SIZE 244 sound/core/memalloc.c aligned_size = PAGE_SIZE << get_order(size);
PAGE_SIZE 380 sound/core/memalloc.c pages * PAGE_SIZE, pages, PAGE_SIZE / 1024);
PAGE_SIZE 943 sound/core/pcm.c return snprintf(buf, PAGE_SIZE, "%s\n", str);
PAGE_SIZE 3103 sound/core/pcm_native.c if (offset > dma_bytes - PAGE_SIZE)
PAGE_SIZE 124 sound/core/rawmidi.c runtime->buffer_size = PAGE_SIZE;
PAGE_SIZE 45 sound/core/seq/seq_midi.c static int output_buffer_size = PAGE_SIZE;
PAGE_SIZE 48 sound/core/seq/seq_midi.c static int input_buffer_size = PAGE_SIZE;
PAGE_SIZE 106 sound/core/sgbuf.c size = sgbuf->pages * PAGE_SIZE;
PAGE_SIZE 117 sound/core/sgbuf.c tmpb.area += PAGE_SIZE;
PAGE_SIZE 118 sound/core/sgbuf.c tmpb.addr += PAGE_SIZE;
PAGE_SIZE 644 sound/oss/au1550_ac97.c db->rawbuf = kmalloc((PAGE_SIZE << db->buforder), GFP_KERNEL);
PAGE_SIZE 665 sound/oss/au1550_ac97.c bufs = PAGE_SIZE << db->buforder;
PAGE_SIZE 1272 sound/oss/au1550_ac97.c if (size > (PAGE_SIZE << db->buforder)) {
PAGE_SIZE 89 sound/oss/dmabuf.c while (start_addr == NULL && dmap->buffsize > PAGE_SIZE) {
PAGE_SIZE 90 sound/oss/dmabuf.c for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
PAGE_SIZE 91 sound/oss/dmabuf.c dmap->buffsize = PAGE_SIZE * (1 << sz);
PAGE_SIZE 133 sound/oss/dmabuf.c for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
PAGE_SIZE 898 sound/oss/msnd_pinnacle.c k = PAGE_SIZE;
PAGE_SIZE 956 sound/oss/msnd_pinnacle.c k = PAGE_SIZE;
PAGE_SIZE 802 sound/oss/sscape.c while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
PAGE_SIZE 803 sound/oss/sscape.c for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
PAGE_SIZE 804 sound/oss/sscape.c devc->buffsize = PAGE_SIZE * (1 << sz);
PAGE_SIZE 838 sound/oss/sscape.c for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
PAGE_SIZE 279 sound/oss/vwsnd.c lith->page0 = ioremap_nocache(baseaddr + LI_PAGE0_OFFSET, PAGE_SIZE);
PAGE_SIZE 280 sound/oss/vwsnd.c lith->page1 = ioremap_nocache(baseaddr + LI_PAGE1_OFFSET, PAGE_SIZE);
PAGE_SIZE 281 sound/oss/vwsnd.c lith->page2 = ioremap_nocache(baseaddr + LI_PAGE2_OFFSET, PAGE_SIZE);
PAGE_SIZE 1554 sound/oss/vwsnd.c #define MAX_FRAGCOUNT(fragsize) (32 * PAGE_SIZE / (fragsize))
PAGE_SIZE 1736 sound/oss/vwsnd.c aport->swbuf = vmalloc(aport->swbuf_size + PAGE_SIZE);
PAGE_SIZE 1743 sound/oss/vwsnd.c wport->swbuf = vmalloc(aport->swbuf_size + PAGE_SIZE);
PAGE_SIZE 63 sound/parisc/harmony.h #define BUF_SIZE PAGE_SIZE
PAGE_SIZE 147 sound/pci/bt87x.c #define MAX_RISC_SIZE ((1 + 255 + (PAGE_ALIGN(255 * 4092) / PAGE_SIZE - 1) + 1 + 1) * 8)
PAGE_SIZE 250 sound/pci/bt87x.c len = PAGE_SIZE - (offset % PAGE_SIZE);
PAGE_SIZE 1334 sound/pci/cmipci.c memset(runtime->dma_area, 0, PAGE_SIZE);
PAGE_SIZE 1336 sound/pci/cmipci.c val = ((PAGE_SIZE / 4) - 1) | (((PAGE_SIZE / 4) / 2 - 1) << 16);
PAGE_SIZE 1320 sound/pci/cs46xx/cs46xx_lib.c PAGE_SIZE, &cpcm->hw_buf) < 0) {
PAGE_SIZE 1410 sound/pci/cs46xx/cs46xx_lib.c PAGE_SIZE, &chip->capt.hw_buf) < 0)
PAGE_SIZE 296 sound/pci/echoaudio/echoaudio.c PAGE_SIZE, &pipe->sgpage)) < 0) {
PAGE_SIZE 534 sound/pci/echoaudio/echoaudio.c edge = PAGE_SIZE;
PAGE_SIZE 555 sound/pci/echoaudio/echoaudio.c edge += PAGE_SIZE;
PAGE_SIZE 1925 sound/pci/echoaudio/echoaudio.c if (sz > PAGE_SIZE)
PAGE_SIZE 1926 sound/pci/echoaudio/echoaudio.c sz = PAGE_SIZE; /* We map only the required part */
PAGE_SIZE 31 sound/pci/echoaudio/echoaudio_dsp.c #if PAGE_SIZE < 4096
PAGE_SIZE 1093 sound/pci/echoaudio/echoaudio_dsp.c memset(pipe->sgpage.area, 0, PAGE_SIZE);
PAGE_SIZE 1842 sound/pci/emu10k1/emu10k1_main.c emu->memhdr = snd_util_memhdr_new(emu->max_cache_pages * PAGE_SIZE);
PAGE_SIZE 1918 sound/pci/emu10k1/emu10k1_main.c memset(emu->silent_page.area, 0, PAGE_SIZE);
PAGE_SIZE 37 sound/pci/emu10k1/memory.c #define UNIT_PAGES (PAGE_SIZE / EMUPAGESIZE)
PAGE_SIZE 44 sound/pci/emu10k1/memory.c #if PAGE_SIZE == 4096
PAGE_SIZE 209 sound/pci/emu10k1/memory.c psize = get_aligned_page(size + PAGE_SIZE -1);
PAGE_SIZE 506 sound/pci/emu10k1/memory.c ptr += offset & (PAGE_SIZE - 1);
PAGE_SIZE 520 sound/pci/emu10k1/memory.c offset += blk->offset & (PAGE_SIZE - 1);
PAGE_SIZE 550 sound/pci/emu10k1/memory.c offset += blk->offset & (PAGE_SIZE - 1);
PAGE_SIZE 476 sound/pci/hda/hda_intel.c PAGE_SIZE, &chip->rb);
PAGE_SIZE 720 sound/pci/intel8x0.c size = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE 1360 sound/pci/riptide/riptide.c .period_bytes_min = PAGE_SIZE >> 1,
PAGE_SIZE 1361 sound/pci/riptide/riptide.c .period_bytes_max = PAGE_SIZE << 8,
PAGE_SIZE 1379 sound/pci/riptide/riptide.c .period_bytes_min = PAGE_SIZE >> 1,
PAGE_SIZE 1380 sound/pci/riptide/riptide.c .period_bytes_max = PAGE_SIZE << 3,
PAGE_SIZE 1525 sound/pci/riptide/riptide.c f = PAGE_SIZE;
PAGE_SIZE 1548 sound/pci/riptide/riptide.c pt = (pt + f) % PAGE_SIZE;
PAGE_SIZE 45 sound/pci/trident/trident_memory.c #if PAGE_SIZE == 4096
PAGE_SIZE 47 sound/pci/trident/trident_memory.c #define ALIGN_PAGE_SIZE PAGE_SIZE /* minimum page size for allocation */
PAGE_SIZE 62 sound/pci/trident/trident_memory.c #elif PAGE_SIZE == 8192
PAGE_SIZE 64 sound/pci/trident/trident_memory.c #define ALIGN_PAGE_SIZE PAGE_SIZE
PAGE_SIZE 88 sound/pci/trident/trident_memory.c #define UNIT_PAGES (PAGE_SIZE / SNDRV_TRIDENT_PAGE_SIZE)
PAGE_SIZE 320 sound/pci/via82xx_modem.c r = PAGE_SIZE - (ofs % PAGE_SIZE);
PAGE_SIZE 876 sound/ppc/snd_ps3.c _ALIGN_UP(SND_PS3_DMA_REGION_SIZE, PAGE_SIZE));
PAGE_SIZE 943 sound/ppc/snd_ps3.c PAGE_SIZE,
PAGE_SIZE 967 sound/ppc/snd_ps3.c PAGE_SIZE,
PAGE_SIZE 1008 sound/ppc/snd_ps3.c PAGE_SIZE,
PAGE_SIZE 131 sound/ppc/snd_ps3.h (SND_PS3_PCM_PREALLOC_SIZE + PAGE_SIZE)
PAGE_SIZE 108 sound/soc/blackfin/bf5xx-ac97-pcm.c .periods_max = PAGE_SIZE/32,
PAGE_SIZE 63 sound/soc/blackfin/bf5xx-i2s-pcm.c .periods_max = PAGE_SIZE/32,
PAGE_SIZE 57 sound/soc/s3c24xx/s3c24xx-pcm.c .period_bytes_min = PAGE_SIZE,
PAGE_SIZE 58 sound/soc/s3c24xx/s3c24xx-pcm.c .period_bytes_max = PAGE_SIZE*2,
PAGE_SIZE 980 sound/soc/soc-core.c if (count >= PAGE_SIZE - 1)
PAGE_SIZE 985 sound/soc/soc-core.c PAGE_SIZE - count, i);
PAGE_SIZE 987 sound/soc/soc-core.c count += snprintf(buf + count, PAGE_SIZE - count,
PAGE_SIZE 990 sound/soc/soc-core.c if (count >= PAGE_SIZE - 1)
PAGE_SIZE 993 sound/soc/soc-core.c count += snprintf(buf + count, PAGE_SIZE - count, "\n");
PAGE_SIZE 994 sound/soc/soc-core.c if (count >= PAGE_SIZE - 1)
PAGE_SIZE 999 sound/soc/soc-core.c if (count >= PAGE_SIZE)
PAGE_SIZE 1000 sound/soc/soc-core.c count = PAGE_SIZE - 1;
PAGE_SIZE 194 sound/usb/usx2y/usb_stream.c if (read_size >= 256*PAGE_SIZE || write_size >= 256*PAGE_SIZE) {
PAGE_SIZE 252 virt/kvm/kvm_main.c for (; start < end; start += PAGE_SIZE)
PAGE_SIZE 457 virt/kvm/kvm_main.c if (mem->memory_size & (PAGE_SIZE - 1))
PAGE_SIZE 459 virt/kvm/kvm_main.c if (mem->guest_phys_addr & (PAGE_SIZE - 1))
PAGE_SIZE 707 virt/kvm/kvm_main.c return (slot->userspace_addr + (gfn - slot->base_gfn) * PAGE_SIZE);
PAGE_SIZE 826 virt/kvm/kvm_main.c if (len > PAGE_SIZE - offset)
PAGE_SIZE 827 virt/kvm/kvm_main.c return PAGE_SIZE - offset;
PAGE_SIZE 1443 virt/kvm/kvm_main.c r = PAGE_SIZE; /* struct kvm_run */
PAGE_SIZE 1445 virt/kvm/kvm_main.c r += PAGE_SIZE; /* pio data page */
PAGE_SIZE 1448 virt/kvm/kvm_main.c r += PAGE_SIZE; /* coalesced mmio ring page */