taglinefilesource code
PAGE_SIZE199arch/alpha/boot/main.c"r" (PAGE_SIZE + INIT_STACK));
PAGE_SIZE453arch/alpha/kernel/osf_sys.creturn PAGE_SIZE;
PAGE_SIZE126arch/alpha/kernel/process.cstack_offset = PAGE_SIZE - sizeof(struct pt_regs);
PAGE_SIZE128arch/alpha/kernel/process.cstack_offset = (PAGE_SIZE-1) & (unsigned long) regs;
PAGE_SIZE157arch/alpha/kernel/process.cdump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
PAGE_SIZE159arch/alpha/kernel/process.cdump->u_dsize = (current->mm->brk + (PAGE_SIZE - 1) - dump->start_data) >> PAGE_SHIFT;
PAGE_SIZE161arch/alpha/kernel/process.c(current->mm->start_stack - dump->start_stack + PAGE_SIZE - 1) >> PAGE_SHIFT;
PAGE_SIZE70arch/alpha/kernel/ptrace.c#define PT_REG(reg)  (PAGE_SIZE - sizeof(struct pt_regs)  \
PAGE_SIZE72arch/alpha/kernel/ptrace.c#define SW_REG(reg)  (PAGE_SIZE - sizeof(struct pt_regs)  \
PAGE_SIZE297arch/alpha/kernel/ptrace.cif ((addr & ~PAGE_MASK) > (PAGE_SIZE - sizeof(long))) {
PAGE_SIZE337arch/alpha/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE113arch/alpha/kernel/setup.chigh = (high + PAGE_SIZE) & (PAGE_MASK*2);
PAGE_SIZE44arch/alpha/mm/init.cmemset((void *) EMPTY_PGT, 0, PAGE_SIZE);
PAGE_SIZE50arch/alpha/mm/init.cmemset((void *) EMPTY_PGE, 0, PAGE_SIZE);
PAGE_SIZE129arch/alpha/mm/init.cmemset((void *) ZERO_PAGE, 0, PAGE_SIZE);
PAGE_SIZE130arch/alpha/mm/init.cmemset(swapper_pg_dir, 0, PAGE_SIZE);
PAGE_SIZE156arch/alpha/mm/init.ctmp += PAGE_SIZE;
PAGE_SIZE159arch/alpha/mm/init.cfor (tmp = PAGE_OFFSET ; tmp < high_memory ; tmp += PAGE_SIZE) {
PAGE_SIZE46arch/i386/kernel/ldt.climit = limit * PAGE_SIZE + PAGE_SIZE - 1;
PAGE_SIZE304arch/i386/kernel/process.cp->tss.esp0 = p->kernel_stack_page + PAGE_SIZE;
PAGE_SIZE306arch/i386/kernel/process.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
PAGE_SIZE367arch/i386/kernel/process.cdump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
PAGE_SIZE369arch/i386/kernel/process.cdump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
PAGE_SIZE215arch/i386/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE257arch/i386/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE78arch/i386/kernel/setup.cextern char empty_zero_page[PAGE_SIZE];
PAGE_SIZE468arch/i386/kernel/smp.cint size=(num_processors-1)*PAGE_SIZE;    /* Number of stacks needed */
PAGE_SIZE491arch/i386/kernel/smp.ckstack_base+=PAGE_SIZE;
PAGE_SIZE123arch/i386/mm/fault.cif ((unsigned long) (address-TASK_SIZE) < PAGE_SIZE) {
PAGE_SIZE54arch/i386/mm/init.cextern char empty_bad_page_table[PAGE_SIZE];
PAGE_SIZE59arch/i386/mm/init.c"c" (PAGE_SIZE/4)
PAGE_SIZE66arch/i386/mm/init.cextern char empty_bad_page[PAGE_SIZE];
PAGE_SIZE71arch/i386/mm/init.c"c" (PAGE_SIZE/4)
PAGE_SIZE128arch/i386/mm/init.cmemset((void *) 0, 0, PAGE_SIZE);
PAGE_SIZE186arch/i386/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE198arch/i386/mm/init.caddress += PAGE_SIZE;
PAGE_SIZE207arch/i386/mm/init.cunsigned long start_low_mem = PAGE_SIZE;
PAGE_SIZE218arch/i386/mm/init.cmemset(empty_zero_page, 0, PAGE_SIZE);
PAGE_SIZE227arch/i386/mm/init.cstart_low_mem += PAGE_SIZE;        /* 32bit startup code */
PAGE_SIZE239arch/i386/mm/init.cstart_low_mem += PAGE_SIZE;
PAGE_SIZE244arch/i386/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE246arch/i386/mm/init.cfor (tmp = 0 ; tmp < high_memory ; tmp += PAGE_SIZE) {
PAGE_SIZE2178arch/m68k/amiga/amifb.csize += PAGE_SIZE-1;
PAGE_SIZE4123arch/m68k/amiga/amifb.csize += PAGE_SIZE-1;
PAGE_SIZE2014arch/m68k/atari/atafb.cfix->smem_len=(external_len + PAGE_SIZE -1) & PAGE_MASK;
PAGE_SIZE2852arch/m68k/atari/atafb.cmem_req = ((mem_req + PAGE_SIZE - 1) & PAGE_MASK) + PAGE_SIZE;
PAGE_SIZE2855arch/m68k/atari/atafb.cpad = ((screen_base + PAGE_SIZE-1) & PAGE_MASK) - screen_base;
PAGE_SIZE2873arch/m68k/atari/atafb.c*mem_start = (*mem_start+PAGE_SIZE-1) & ~(PAGE_SIZE-1);
PAGE_SIZE599arch/m68k/boot/amiga/bootstrap.cstart_mem += PAGE_SIZE;
PAGE_SIZE600arch/m68k/boot/amiga/bootstrap.cmem_size -= PAGE_SIZE;
PAGE_SIZE718arch/m68k/boot/atari/bootstrap.cstart_mem += PAGE_SIZE;
PAGE_SIZE719arch/m68k/boot/atari/bootstrap.cmem_size -= PAGE_SIZE;
PAGE_SIZE759arch/m68k/boot/atari/bootstrap.cmin_addr = PAGE_SIZE;
PAGE_SIZE760arch/m68k/boot/atari/bootstrap.ckernel_phdrs[0].p_vaddr += PAGE_SIZE;
PAGE_SIZE761arch/m68k/boot/atari/bootstrap.ckernel_phdrs[0].p_offset += PAGE_SIZE;
PAGE_SIZE762arch/m68k/boot/atari/bootstrap.ckernel_phdrs[0].p_filesz -= PAGE_SIZE;
PAGE_SIZE763arch/m68k/boot/atari/bootstrap.ckernel_phdrs[0].p_memsz -= PAGE_SIZE;
PAGE_SIZE792arch/m68k/boot/atari/bootstrap.cif (kread (kfd, memptr + kernel_phdrs[i].p_vaddr - PAGE_SIZE,
PAGE_SIZE863arch/m68k/boot/atari/bootstrap.cstart_mem + kernel_phdrs[i].p_vaddr - PAGE_SIZE,
PAGE_SIZE912arch/m68k/boot/atari/bootstrap.cchange_stack ((void *) PAGE_SIZE);
PAGE_SIZE113arch/m68k/kernel/process.cstack_offset = PAGE_SIZE - sizeof(struct pt_regs);
PAGE_SIZE168arch/m68k/kernel/process.cdump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
PAGE_SIZE171arch/m68k/kernel/process.c(PAGE_SIZE-1))) >> PAGE_SHIFT;
PAGE_SIZE238arch/m68k/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE280arch/m68k/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE104arch/m68k/mm/fault.cif ((unsigned long) address < PAGE_SIZE) {
PAGE_SIZE51arch/m68k/mm/init.cmemset((void *)empty_bad_page_table, 0, PAGE_SIZE);
PAGE_SIZE59arch/m68k/mm/init.cmemset ((void *)empty_bad_page, 0, PAGE_SIZE);
PAGE_SIZE110arch/m68k/mm/init.c*memavailp += PAGE_SIZE;
PAGE_SIZE227arch/m68k/mm/init.cphysaddr += PAGE_SIZE;
PAGE_SIZE259arch/m68k/mm/init.cfor (i = 0; i < 64; i++, physaddr += PAGE_SIZE)
PAGE_SIZE271arch/m68k/mm/init.cphysaddr += 64 * PAGE_SIZE;
PAGE_SIZE365arch/m68k/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE367arch/m68k/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE369arch/m68k/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE370arch/m68k/mm/init.cmemset((void *)empty_zero_page, 0, PAGE_SIZE);
PAGE_SIZE462arch/m68k/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE487arch/m68k/mm/init.crsvd_stram_end += PAGE_SIZE - 1;
PAGE_SIZE490arch/m68k/mm/init.cfor( adr = rsvd_stram_beg; adr < rsvd_stram_end; adr += PAGE_SIZE )
PAGE_SIZE500arch/m68k/mm/init.cfor (tmp = 0 ; tmp < end_mem ; tmp += PAGE_SIZE) {
PAGE_SIZE161arch/m68k/mm/memory.cfor (i = 0; i < PAGE_SIZE/(PTRS_PER_PMD*sizeof(pmd_t)); i++)
PAGE_SIZE244arch/m68k/mm/memory.creturn (mmusr & PAGE_MASK) | (vaddr & (PAGE_SIZE-1));
PAGE_SIZE269arch/m68k/mm/memory.creturn (*descaddr & PAGE_MASK) | (vaddr & (PAGE_SIZE-1));
PAGE_SIZE384arch/m68k/mm/memory.cwhile (len > PAGE_SIZE) {
PAGE_SIZE386arch/m68k/mm/memory.clen -= PAGE_SIZE;
PAGE_SIZE387arch/m68k/mm/memory.cpaddr += PAGE_SIZE;
PAGE_SIZE399arch/m68k/mm/memory.cwhile (len > PAGE_SIZE) {
PAGE_SIZE401arch/m68k/mm/memory.clen -= PAGE_SIZE;
PAGE_SIZE402arch/m68k/mm/memory.cpaddr += PAGE_SIZE;
PAGE_SIZE407arch/m68k/mm/memory.cif (((paddr + len - 1) / PAGE_SIZE) != (paddr / PAGE_SIZE)) {
PAGE_SIZE431arch/m68k/mm/memory.cwhile (len > PAGE_SIZE) {
PAGE_SIZE433arch/m68k/mm/memory.clen -= PAGE_SIZE;
PAGE_SIZE434arch/m68k/mm/memory.cpaddr += PAGE_SIZE;
PAGE_SIZE439arch/m68k/mm/memory.cif (((paddr + len - 1) / PAGE_SIZE) != (paddr / PAGE_SIZE)) {
PAGE_SIZE470arch/m68k/mm/memory.cwhile (len > PAGE_SIZE) {
PAGE_SIZE472arch/m68k/mm/memory.clen -= PAGE_SIZE;
PAGE_SIZE473arch/m68k/mm/memory.cvaddr += PAGE_SIZE;
PAGE_SIZE478arch/m68k/mm/memory.cif (((vaddr + len - 1) / PAGE_SIZE) != (vaddr / PAGE_SIZE)) {
PAGE_SIZE488arch/m68k/mm/memory.cwhile (len > PAGE_SIZE) {
PAGE_SIZE490arch/m68k/mm/memory.clen -= PAGE_SIZE;
PAGE_SIZE491arch/m68k/mm/memory.cvaddr += PAGE_SIZE;
PAGE_SIZE638arch/m68k/mm/memory.cphysaddr += PAGE_SIZE;
PAGE_SIZE654arch/m68k/mm/memory.cphysaddr += 64 * PAGE_SIZE;
PAGE_SIZE678arch/m68k/mm/memory.caddress += PAGE_SIZE;
PAGE_SIZE124arch/mips/kernel/process.cchildksp = p->kernel_stack_page + PAGE_SIZE - 8;
PAGE_SIZE128arch/mips/kernel/process.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + PAGE_SIZE)) - 1;
PAGE_SIZE192arch/mips/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE234arch/mips/kernel/ptrace.cif ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
PAGE_SIZE201arch/mips/kernel/setup.cextern char empty_zero_page[PAGE_SIZE];
PAGE_SIZE42arch/mips/kernel/sysmips.cif (address > PAGE_SIZE)
PAGE_SIZE112arch/mips/kernel/traps.cif (((u32) stack & (PAGE_SIZE -1)) == 0)
PAGE_SIZE123arch/mips/kernel/traps.cwhile (((u32)stack & (PAGE_SIZE -1)) != 0) {
PAGE_SIZE61arch/mips/mm/fault.csys_cacheflush(address, PAGE_SIZE, BCACHE);
PAGE_SIZE31arch/mips/mm/init.cextern char empty_zero_page[PAGE_SIZE];
PAGE_SIZE48arch/mips/mm/init.cextern char empty_bad_page_table[PAGE_SIZE];
PAGE_SIZE75arch/mips/mm/init.c"1" (PAGE_SIZE/8));
PAGE_SIZE88arch/mips/mm/init.c"1" (PAGE_SIZE/4));
PAGE_SIZE117arch/mips/mm/init.c"1" (PAGE_SIZE/8));
PAGE_SIZE129arch/mips/mm/init.c"1" (PAGE_SIZE/4));
PAGE_SIZE136arch/mips/mm/init.csys_cacheflush((void *)page, PAGE_SIZE, BCACHE);
PAGE_SIZE143arch/mips/mm/init.cextern char empty_bad_page[PAGE_SIZE];
PAGE_SIZE185arch/mips/mm/init.c(void *) (from + (PT_OFFSET - PAGE_OFFSET)), PAGE_SIZE);
PAGE_SIZE254arch/mips/mm/init.ctmp += PAGE_SIZE;
PAGE_SIZE263arch/mips/mm/init.cfor (tmp = PAGE_OFFSET ; tmp < high_memory ; tmp += PAGE_SIZE) {
PAGE_SIZE123arch/ppc/kernel/process.cchildregs = ((struct pt_regs *) (p->kernel_stack_page + 2*PAGE_SIZE)) - 2;
PAGE_SIZE71arch/ppc/mm/init.cextern char empty_bad_page_table[PAGE_SIZE];
PAGE_SIZE95arch/ppc/mm/init.cextern char empty_bad_page[PAGE_SIZE];
PAGE_SIZE119arch/ppc/mm/init.cextern char empty_zero_page[PAGE_SIZE];
PAGE_SIZE120arch/ppc/mm/init.cbzero(empty_zero_page, PAGE_SIZE);
PAGE_SIZE177arch/ppc/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE190arch/ppc/mm/init.caddress += PAGE_SIZE;
PAGE_SIZE220arch/ppc/mm/init.cstart_mem += PAGE_SIZE;
PAGE_SIZE228arch/ppc/mm/init.cfor (tmp = KERNELBASE ; tmp < high_memory ; tmp += PAGE_SIZE)
PAGE_SIZE749arch/ppc/mm/init.caddress += PAGE_SIZE;
PAGE_SIZE753arch/ppc/mm/init.caddress += PAGE_SIZE*PTRS_PER_PTE;
PAGE_SIZE757arch/ppc/mm/init.caddress += PAGE_SIZE*PTRS_PER_PTE;
PAGE_SIZE77arch/sparc/kernel/ioport.cfor (; len > 0; len -= PAGE_SIZE) {
PAGE_SIZE79arch/sparc/kernel/ioport.cvaddr += PAGE_SIZE;
PAGE_SIZE80arch/sparc/kernel/ioport.caddr += PAGE_SIZE;
PAGE_SIZE82arch/sparc/kernel/ioport.cnext_free_region += PAGE_SIZE;
PAGE_SIZE249arch/sparc/kernel/process.cstack_offset = ((PAGE_SIZE*3) - TRACEREG_SZ);
PAGE_SIZE251arch/sparc/kernel/process.cstack_offset = ((PAGE_SIZE<<2) - TRACEREG_SZ);
PAGE_SIZE299arch/sparc/kernel/process.c((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);
PAGE_SIZE300arch/sparc/kernel/process.cdump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));
PAGE_SIZE302arch/sparc/kernel/process.cdump->u_dsize &= ~(PAGE_SIZE - 1);
PAGE_SIZE303arch/sparc/kernel/process.cfirst_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));
PAGE_SIZE304arch/sparc/kernel/process.cdump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);
PAGE_SIZE222arch/sparc/kernel/sun4m_irq.ccnt_regs[obio_node-1].phys_addr + PAGE_SIZE;
PAGE_SIZE229arch/sparc/kernel/sun4m_irq.cPAGE_SIZE*NCPUS, "counters_percpu",
PAGE_SIZE289arch/sparc/kernel/sun4m_irq.cint_regs[ie_node].phys_addr = int_regs[ie_node-1].phys_addr + PAGE_SIZE;
PAGE_SIZE296arch/sparc/kernel/sun4m_irq.cPAGE_SIZE*NCPUS, "interrupts_percpu",
PAGE_SIZE25arch/sparc/kernel/sys_sparc.creturn PAGE_SIZE; /* Possibly older binaries want 8192 on sun4's? */
PAGE_SIZE156arch/sparc/kernel/sys_sunos.cif (find_vma_intersection(current, oldbrk, newbrk+PAGE_SIZE))
PAGE_SIZE276arch/sparc/kernel/sys_sunos.cif(addr & (PAGE_SIZE - 1))
PAGE_SIZE279arch/sparc/kernel/sys_sunos.cnum_pages = (len / PAGE_SIZE);
PAGE_SIZE287arch/sparc/kernel/sys_sunos.cfor(limit = addr + len; addr < limit; addr += PAGE_SIZE, pnum++) {
PAGE_SIZE202arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
PAGE_SIZE51arch/sparc/mm/generic.caddress += PAGE_SIZE;
PAGE_SIZE52arch/sparc/mm/generic.coffset += PAGE_SIZE;
PAGE_SIZE46arch/sparc/mm/init.cmemset((void *) EMPTY_PGT, 0, PAGE_SIZE);
PAGE_SIZE52arch/sparc/mm/init.cmemset((void *) EMPTY_PGE, 0, PAGE_SIZE);
PAGE_SIZE168arch/sparc/mm/init.cfor(addr = start_mem; addr < end_mem; addr += PAGE_SIZE) {
PAGE_SIZE175arch/sparc/mm/init.c((phys_addr + PAGE_SIZE) < limit))
PAGE_SIZE180arch/sparc/mm/init.cfor(addr = start_mem; addr < end_mem; addr += PAGE_SIZE)
PAGE_SIZE193arch/sparc/mm/init.cmemset((void *) ZERO_PAGE, 0, PAGE_SIZE);
PAGE_SIZE203arch/sparc/mm/init.caddr += PAGE_SIZE;
PAGE_SIZE207arch/sparc/mm/init.cfor (addr = PAGE_OFFSET; addr < end_mem; addr += PAGE_SIZE) {
PAGE_SIZE534arch/sparc/mm/srmmu.cmemset((void *) pages, 0, (PAGE_SIZE << 2));
PAGE_SIZE929arch/sparc/mm/srmmu.cvaddr = (KERNBASE + PAGE_SIZE) | (set << 5);
PAGE_SIZE933arch/sparc/mm/srmmu.cvaddr += PAGE_SIZE;
PAGE_SIZE1300arch/sparc/mm/srmmu.cfirst += PAGE_SIZE;
PAGE_SIZE1316arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1333arch/sparc/mm/srmmu.csparc_alloc_io(iommu_promregs[0].phys_addr, 0, (PAGE_SIZE * 3),
PAGE_SIZE1389arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1397arch/sparc/mm/srmmu.ciommu->plow = start + PAGE_SIZE;
PAGE_SIZE1417arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1426arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1439arch/sparc/mm/srmmu.cif(len > PAGE_SIZE)
PAGE_SIZE1576arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1584arch/sparc/mm/srmmu.cif(srmmu_hwprobe((start-PAGE_SIZE) + SRMMU_PMD_SIZE) == prompte)
PAGE_SIZE1589arch/sparc/mm/srmmu.cif(srmmu_hwprobe((start-PAGE_SIZE) + SRMMU_PGDIR_SIZE) ==
PAGE_SIZE1616arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1640arch/sparc/mm/srmmu.cfirst += PAGE_SIZE;
PAGE_SIZE1641arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1653arch/sparc/mm/srmmu.cfirst += PAGE_SIZE;
PAGE_SIZE1668arch/sparc/mm/srmmu.cif(start == (KERNBASE + PAGE_SIZE)) {
PAGE_SIZE1695arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1699arch/sparc/mm/srmmu.cif(tmp != last_page + PAGE_SIZE)
PAGE_SIZE1739arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1773arch/sparc/mm/srmmu.cbaddr += PAGE_SIZE;
PAGE_SIZE1774arch/sparc/mm/srmmu.cstart += PAGE_SIZE;
PAGE_SIZE1775arch/sparc/mm/srmmu.cbtg -= PAGE_SIZE;
PAGE_SIZE1844arch/sparc/mm/srmmu.cmemset(swapper_pg_dir, 0, PAGE_SIZE);
PAGE_SIZE1848arch/sparc/mm/srmmu.ckbpage = srmmu_hwprobe(KERNBASE + PAGE_SIZE);
PAGE_SIZE1850arch/sparc/mm/srmmu.ckbpage -= PAGE_SIZE;
PAGE_SIZE1851arch/sparc/mm/srmmu.cfirst_mapped_page += PAGE_SIZE;
PAGE_SIZE1864arch/sparc/mm/srmmu.clast_dvma_page = (mempool + (DVMA_LEN) - PAGE_SIZE);
PAGE_SIZE1865arch/sparc/mm/srmmu.cmempool = last_dvma_page + PAGE_SIZE;
PAGE_SIZE1870arch/sparc/mm/srmmu.csrmmu_inherit_prom_mappings(0xfe400000,(LINUX_OPPROM_ENDVM-PAGE_SIZE));
PAGE_SIZE1885arch/sparc/mm/srmmu.cfor( ; ptables_start < start_mem; ptables_start += PAGE_SIZE) {
PAGE_SIZE62arch/sparc/mm/sun4c.cfor(vaddr=0; vaddr < sun4c_vacinfo.num_bytes; vaddr+=PAGE_SIZE)
PAGE_SIZE82arch/sparc/mm/sun4c.cfor( ; addr < end; addr += PAGE_SIZE)
PAGE_SIZE103arch/sparc/mm/sun4c.cunsigned long end = addr + PAGE_SIZE;
PAGE_SIZE136arch/sparc/mm/sun4c.cfor(vaddr = 0; vaddr < SUN4C_REAL_PGDIR_SIZE; vaddr+=PAGE_SIZE)
PAGE_SIZE224arch/sparc/mm/sun4c.cfor(addr = DVMA_VADDR; addr < DVMA_END; addr += PAGE_SIZE) {
PAGE_SIZE228arch/sparc/mm/sun4c.cstart_mem += PAGE_SIZE;
PAGE_SIZE263arch/sparc/mm/sun4c.cfor(start = vaddr; start < end; start += PAGE_SIZE)
PAGE_SIZE464arch/sparc/mm/sun4c.cstart += PAGE_SIZE;
PAGE_SIZE607arch/sparc/mm/sun4c.caddress += PAGE_SIZE;
PAGE_SIZE616arch/sparc/mm/sun4c.caddress += PAGE_SIZE;
PAGE_SIZE641arch/sparc/mm/sun4c.cchar _unused1[PAGE_SIZE - sizeof(struct task_struct)];
PAGE_SIZE642arch/sparc/mm/sun4c.cchar kstack[(PAGE_SIZE*3)];
PAGE_SIZE648arch/sparc/mm/sun4c.c#define BUCKET_SIZE      (PAGE_SIZE << 2)
PAGE_SIZE750arch/sparc/mm/sun4c.csaddr += PAGE_SIZE;
PAGE_SIZE752arch/sparc/mm/sun4c.csun4c_put_pte(saddr + PAGE_SIZE, BUCKET_PTE(page[1]));
PAGE_SIZE753arch/sparc/mm/sun4c.csun4c_put_pte(saddr + (PAGE_SIZE<<1), BUCKET_PTE(page[2]));
PAGE_SIZE762arch/sparc/mm/sun4c.cpage[1] = BUCKET_PTE_PAGE(sun4c_get_pte(stack+PAGE_SIZE));
PAGE_SIZE763arch/sparc/mm/sun4c.cpage[2] = BUCKET_PTE_PAGE(sun4c_get_pte(stack+(PAGE_SIZE<<1)));
PAGE_SIZE766arch/sparc/mm/sun4c.csun4c_put_pte(stack + PAGE_SIZE, 0);
PAGE_SIZE767arch/sparc/mm/sun4c.csun4c_put_pte(stack + (PAGE_SIZE<<1), 0);
PAGE_SIZE790arch/sparc/mm/sun4c.cif(sizeof(struct task_bucket) != (PAGE_SIZE << 2)) {
PAGE_SIZE817arch/sparc/mm/sun4c.csize + (PAGE_SIZE-1)) >> PAGE_SHIFT;
PAGE_SIZE841arch/sparc/mm/sun4c.cvpage += PAGE_SIZE;
PAGE_SIZE858arch/sparc/mm/sun4c.csize + (PAGE_SIZE-1)) >> PAGE_SHIFT;
PAGE_SIZE864arch/sparc/mm/sun4c.cvpage += PAGE_SIZE;
PAGE_SIZE1007arch/sparc/mm/sun4c.cif(size <= (PAGE_SIZE << 1)) {
PAGE_SIZE1011arch/sparc/mm/sun4c.cstart += PAGE_SIZE;
PAGE_SIZE1530arch/sparc/mm/sun4c.cmemset(swapper_pg_dir, 0, PAGE_SIZE);
PAGE_SIZE1531arch/sparc/mm/sun4c.cmemset(pg0, 0, PAGE_SIZE);
PAGE_SIZE91drivers/block/ide-tape.h#if PAGE_SIZE == 4096
PAGE_SIZE93drivers/block/ide-tape.h#elif PAGE_SIZE == 8192
PAGE_SIZE538drivers/block/ll_rw_blk.cbuffersize = PAGE_SIZE / nb;
PAGE_SIZE173drivers/block/md.cdevices[minor][index].size=gen_real->sizes[MINOR(dev)] & ~((PAGE_SIZE >> 10)-1);
PAGE_SIZE197drivers/block/rd.cfor (i = initrd_start; i < initrd_end; i += PAGE_SIZE)
PAGE_SIZE144drivers/block/triton.c#define PRD_ENTRIES  (PAGE_SIZE / (2 * PRD_BYTES))
PAGE_SIZE905drivers/char/cyclades.c& (PAGE_SIZE - 1);
PAGE_SIZE911drivers/char/cyclades.c& (PAGE_SIZE - 1);
PAGE_SIZE1578drivers/char/cyclades.cif (info->xmit_cnt >= PAGE_SIZE - 1) {
PAGE_SIZE1584drivers/char/cyclades.cinfo->xmit_head &= PAGE_SIZE - 1;
PAGE_SIZE1698drivers/char/cyclades.cret = PAGE_SIZE - info->xmit_cnt - 1;
PAGE_SIZE57drivers/char/mem.cwhile (p < PAGE_OFFSET + PAGE_SIZE && count > 0) {
PAGE_SIZE85drivers/char/mem.cwhile (PAGE_OFFSET + p < PAGE_SIZE && count > 0) {
PAGE_SIZE36drivers/char/pty.c#define PTY_BUF_SIZE PAGE_SIZE/2
PAGE_SIZE846drivers/char/suncons.cmap_size = PAGE_SIZE;
PAGE_SIZE850drivers/char/suncons.cmap_size = PAGE_SIZE;
PAGE_SIZE854drivers/char/suncons.cmap_size = PAGE_SIZE;
PAGE_SIZE858drivers/char/suncons.cmap_size = PAGE_SIZE;
PAGE_SIZE862drivers/char/suncons.cmap_size = PAGE_SIZE;
PAGE_SIZE867drivers/char/suncons.cmap_size = PAGE_SIZE * 40;
PAGE_SIZE886drivers/char/suncons.cpage += PAGE_SIZE;
PAGE_SIZE1109drivers/char/suncons.cpage += PAGE_SIZE;
PAGE_SIZE1828drivers/char/tty_io.cif (sizeof(struct tty_struct) > PAGE_SIZE)
PAGE_SIZE469drivers/isdn/teles/teles.h#define PART_SIZE(order,bpps) (( (PAGE_SIZE<<order) -\
PAGE_SIZE50drivers/net/loopback.c#define LOOPBACK_MTU (PAGE_SIZE*7/8)
PAGE_SIZE728drivers/pci/pci.csize  = PAGE_SIZE - (strlen(MSG) + 1);
PAGE_SIZE77drivers/sbus/dvma.cPAGE_SIZE, "dma",
PAGE_SIZE389drivers/scsi/esp.cPAGE_SIZE, "ESP Registers",
PAGE_SIZE78drivers/scsi/scsi.c#define SECTORS_PER_PAGE  (PAGE_SIZE/SECTOR_SIZE)
PAGE_SIZE2308drivers/scsi/scsi.cif(len % SECTOR_SIZE != 0 || len > PAGE_SIZE)
PAGE_SIZE2344drivers/scsi/scsi.c(unsigned long) obj <  page_addr + PAGE_SIZE)
PAGE_SIZE2379drivers/scsi/scsi.cif ((size % PAGE_SIZE) == 0) {
PAGE_SIZE2381drivers/scsi/scsi.cfor (order = 0, a_size = PAGE_SIZE;
PAGE_SIZE2402drivers/scsi/scsi.cif ((size % PAGE_SIZE) == 0) {
PAGE_SIZE2405drivers/scsi/scsi.cfor (order = 0, a_size = PAGE_SIZE;
PAGE_SIZE2778drivers/scsi/scsi.cscsi_init_free(dma_malloc_pages[i], PAGE_SIZE);
PAGE_SIZE2815drivers/scsi/scsi.cnew_dma_sectors += (PAGE_SIZE >> 9) * host->sg_tablesize *
PAGE_SIZE2849drivers/scsi/scsi.cscsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
PAGE_SIZE3370drivers/scsi/scsi.cdma_sectors = PAGE_SIZE / SECTOR_SIZE;
PAGE_SIZE3386drivers/scsi/scsi.cscsi_init_malloc(PAGE_SIZE, GFP_ATOMIC | GFP_DMA);
PAGE_SIZE2347drivers/scsi/st.cfor (a_size = PAGE_SIZE; a_size < st_buffer_size; a_size <<= 1)
PAGE_SIZE2390drivers/scsi/st.cfor (a_size = PAGE_SIZE; a_size < new_size; a_size <<= 1)
PAGE_SIZE1519drivers/sound/dmasound.ca_size = PAGE_SIZE;
PAGE_SIZE1532drivers/sound/dmasound.ca_size = PAGE_SIZE;
PAGE_SIZE646drivers/sound/soundcard.cwhile (start_addr == NULL && audio_devs[dev]->buffsize > PAGE_SIZE)
PAGE_SIZE650drivers/sound/soundcard.cfor (sz = 0, size = PAGE_SIZE;
PAGE_SIZE654drivers/sound/soundcard.caudio_devs[dev]->buffsize = PAGE_SIZE * (1 << sz);
PAGE_SIZE711drivers/sound/soundcard.cfor (sz = 0, size = PAGE_SIZE;
PAGE_SIZE99fs/binfmt_aout.cif (current->rlim[RLIMIT_CORE].rlim_cur < PAGE_SIZE)
PAGE_SIZE140fs/binfmt_aout.cif ((dump.u_dsize+dump.u_ssize+1) * PAGE_SIZE >
PAGE_SIZE145fs/binfmt_aout.cif ((dump.u_ssize+1) * PAGE_SIZE >
PAGE_SIZE160fs/binfmt_aout.cDUMP_SEEK(PAGE_SIZE);
PAGE_SIZE319fs/binfmt_aout.cex.a_text+ex.a_data + PAGE_SIZE - 1,
PAGE_SIZE76fs/binfmt_elf.cnbyte = elf_bss & (PAGE_SIZE-1);
PAGE_SIZE78fs/binfmt_elf.cnbyte = PAGE_SIZE - nbyte;
PAGE_SIZE120fs/binfmt_elf.cNEW_AUX_ENT (AT_PAGESZ, PAGE_SIZE);
PAGE_SIZE186fs/binfmt_elf.cif(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > PAGE_SIZE) 
PAGE_SIZE750fs/binfmt_elf.cif(sizeof(struct elf_phdr) * elf_ex.e_phnum > PAGE_SIZE)
PAGE_SIZE955fs/binfmt_elf.cif (!current->dumpable || limit < PAGE_SIZE)
PAGE_SIZE1148fs/binfmt_elf.cdataoff = offset = roundup(offset, PAGE_SIZE);
PAGE_SIZE1170fs/binfmt_elf.cphdr.p_align = PAGE_SIZE;
PAGE_SIZE20fs/block_dev.c#define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
PAGE_SIZE54fs/block_dev.cblocks_per_cluster = PAGE_SIZE / blocksize;
PAGE_SIZE196fs/block_dev.cblocks_per_cluster = PAGE_SIZE / blocksize;
PAGE_SIZE44fs/buffer.c#define MAX_BUF_PER_PAGE (PAGE_SIZE / 512)
PAGE_SIZE510fs/buffer.cif (size > PAGE_SIZE)
PAGE_SIZE580fs/buffer.cneeded -= PAGE_SIZE;
PAGE_SIZE591fs/buffer.cneeded -= PAGE_SIZE;
PAGE_SIZE725fs/buffer.cneeded -= PAGE_SIZE;
PAGE_SIZE999fs/buffer.cfor (nr_buffer_heads+=i=PAGE_SIZE/sizeof*bh ; i>0; i--) {
PAGE_SIZE1064fs/buffer.coffset = PAGE_SIZE;
PAGE_SIZE1065fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
PAGE_SIZE1289fs/buffer.cint *p, nr[PAGE_SIZE/512];
PAGE_SIZE1297fs/buffer.ci = PAGE_SIZE >> inode->i_sb->s_blocksize_bits;
PAGE_SIZE1323fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
PAGE_SIZE1362fs/buffer.cbuffermem += PAGE_SIZE;
PAGE_SIZE1409fs/buffer.cbuffermem -= PAGE_SIZE;
PAGE_SIZE1662fs/buffer.cwhile((unsigned long) tmp->b_data & (PAGE_SIZE - 1)) 
PAGE_SIZE1738fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
PAGE_SIZE1760fs/buffer.cbuffermem += PAGE_SIZE;
PAGE_SIZE1779fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
PAGE_SIZE143fs/dquot.ccnt = PAGE_SIZE / sizeof(struct dquot);
PAGE_SIZE253fs/exec.coffset = p % PAGE_SIZE;
PAGE_SIZE256fs/exec.cif (!(pag = (char *) page[p/PAGE_SIZE]) &&
PAGE_SIZE257fs/exec.c!(pag = (char *) page[p/PAGE_SIZE] =
PAGE_SIZE287fs/exec.cstack_base = STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE;
PAGE_SIZE314fs/exec.cstack_base += PAGE_SIZE;
PAGE_SIZE511fs/exec.coffset = bprm->p % PAGE_SIZE;
PAGE_SIZE512fs/exec.cpage = (char*)bprm->page[bprm->p/PAGE_SIZE];
PAGE_SIZE514fs/exec.cif(offset==PAGE_SIZE){
PAGE_SIZE516fs/exec.cpage = (char*)bprm->page[bprm->p/PAGE_SIZE];
PAGE_SIZE603fs/exec.cbprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
PAGE_SIZE468fs/ext2/ialloc.cinode->i_blksize = PAGE_SIZE;  /* This is the optimal IO size (for stat), not the fs block size */
PAGE_SIZE338fs/ext2/inode.cif((nr & ((PAGE_SIZE >> EXT2_BLOCK_SIZE_BITS(inode->i_sb)) - 1)) != 0)
PAGE_SIZE342fs/ext2/inode.cfor(i=0; i< (PAGE_SIZE >> EXT2_BLOCK_SIZE_BITS(inode->i_sb)); i++) {
PAGE_SIZE536fs/ext2/inode.cinode->i_blksize = PAGE_SIZE;  /* This is the optimal IO size (for stat), not the fs block size */
PAGE_SIZE48fs/fat/mmap.cclear = PAGE_SIZE;
PAGE_SIZE53fs/fat/mmap.cif (gap < PAGE_SIZE){
PAGE_SIZE54fs/fat/mmap.cclear = PAGE_SIZE - gap;
PAGE_SIZE58fs/fat/mmap.cneed_read = PAGE_SIZE - clear;
PAGE_SIZE72fs/fat/mmap.cmemset ((char*)page+PAGE_SIZE-clear,0,clear);
PAGE_SIZE78fs/file_table.cnr_files += i = PAGE_SIZE/sizeof(struct file);
PAGE_SIZE121fs/inode.ci=PAGE_SIZE / sizeof(struct inode);
PAGE_SIZE569fs/inode.cinode->i_blksize = PAGE_SIZE;
PAGE_SIZE39fs/namei.cif (address > PAGE_SIZE)
PAGE_SIZE66fs/namei.ci = PAGE_SIZE;
PAGE_SIZE51fs/ncpfs/mmap.cif (address + PAGE_SIZE > area->vm_end)
PAGE_SIZE53fs/ncpfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
PAGE_SIZE64fs/ncpfs/mmap.cclear = PAGE_SIZE;
PAGE_SIZE69fs/ncpfs/mmap.cint count = PAGE_SIZE - clear;
PAGE_SIZE109fs/ncpfs/mmap.ctmp = page + PAGE_SIZE;
PAGE_SIZE47fs/nfs/bio.cint    count = PAGE_SIZE;
PAGE_SIZE134fs/nfs/bio.cpage->offset, PAGE_SIZE, 
PAGE_SIZE163fs/nfs/bio.cif (!PageError(page) && NFS_SERVER(inode)->rsize >= PAGE_SIZE)
PAGE_SIZE67fs/proc/array.c#  define FIRST_MAPPED  PAGE_SIZE  /* we don't have page 0 mapped on x86.. */
PAGE_SIZE81fs/proc/array.cmemsize = MAP_NR(high_memory + PAGE_SIZE) << PAGE_SHIFT;
PAGE_SIZE100fs/proc/array.cwhile (count > 0 && p < PAGE_SIZE + FIRST_MAPPED) {
PAGE_SIZE107fs/proc/array.cmemcpy_tofs(buf, (void *) (PAGE_OFFSET + p - PAGE_SIZE), count);
PAGE_SIZE282fs/proc/array.ci.totalram, i.totalram-i.freeram, i.freeram, i.sharedram, i.bufferram, page_cache_size*PAGE_SIZE,
PAGE_SIZE378fs/proc/array.cif (size < PAGE_SIZE)
PAGE_SIZE469fs/proc/array.c# define PT_REG(reg)    (PAGE_SIZE - sizeof(struct pt_regs)  \
PAGE_SIZE751fs/proc/array.caddress += PAGE_SIZE;
PAGE_SIZE122fs/proc/inode.ctmp.f_bsize = PAGE_SIZE/sizeof(long);
PAGE_SIZE181fs/proc/inode.cinode->i_size = (MAP_NR(high_memory) << PAGE_SHIFT) + PAGE_SIZE;
PAGE_SIZE104fs/proc/mem.ci = PAGE_SIZE-(addr & ~PAGE_MASK);
PAGE_SIZE168fs/proc/mem.ci = PAGE_SIZE-(addr & ~PAGE_MASK);
PAGE_SIZE263fs/proc/mem.cstmp += PAGE_SIZE;
PAGE_SIZE298fs/proc/mem.cstmp += PAGE_SIZE;
PAGE_SIZE299fs/proc/mem.cdtmp += PAGE_SIZE;
PAGE_SIZE45fs/smbfs/mmap.cif (address + PAGE_SIZE > area->vm_end) {
PAGE_SIZE46fs/smbfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
PAGE_SIZE53fs/smbfs/mmap.cclear = PAGE_SIZE;
PAGE_SIZE58fs/smbfs/mmap.cfor (i = 0; i < (PAGE_SIZE - clear); i += n) {
PAGE_SIZE61fs/smbfs/mmap.chunk = PAGE_SIZE - i;
PAGE_SIZE81fs/smbfs/mmap.ctmp = page + PAGE_SIZE;
PAGE_SIZE303fs/super.cwhile ( tmp && len < PAGE_SIZE - 160)
PAGE_SIZE370fs/super.cwhile (tmp && len < PAGE_SIZE - 80) {
PAGE_SIZE802fs/super.cif (PAGE_SIZE <= (unsigned long) i)
PAGE_SIZE803fs/super.ci = PAGE_SIZE-1;
PAGE_SIZE242fs/ufs/ufs_super.ctmp.f_bsize = PAGE_SIZE;
PAGE_SIZE7include/asm-alpha/page.h#define PAGE_MASK  (~(PAGE_SIZE-1))
PAGE_SIZE52include/asm-alpha/page.h#define PAGE_ALIGN(addr)    (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE47include/asm-alpha/shmparam.h#define  SHMLBA PAGE_SIZE    /* attach addr a multiple of this */
PAGE_SIZE46include/asm-alpha/user.h#define NBPG      PAGE_SIZE
PAGE_SIZE7include/asm-i386/page.h#define PAGE_MASK  (~(PAGE_SIZE-1))
PAGE_SIZE54include/asm-i386/page.h#define PAGE_ALIGN(addr)  (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE41include/asm-i386/shmparam.h#define  SHMLBA PAGE_SIZE    /* attach addr a multiple of this */
PAGE_SIZE73include/asm-i386/user.h#define NBPG PAGE_SIZE
PAGE_SIZE7include/asm-m68k/page.h#define PAGE_MASK  (~(PAGE_SIZE-1))
PAGE_SIZE63include/asm-m68k/page.h#define PAGE_ALIGN(addr)  (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE79include/asm-m68k/pgtable.h#define PTRS_PER_PAGE  (PAGE_SIZE/sizeof(void*))
PAGE_SIZE41include/asm-m68k/shmparam.h#define  SHMLBA PAGE_SIZE    /* attach addr a multiple of this */
PAGE_SIZE67include/asm-m68k/user.h#define NBPG PAGE_SIZE
PAGE_SIZE7include/asm-mips/page.h#define PAGE_MASK  (~(PAGE_SIZE-1))
PAGE_SIZE66include/asm-mips/page.h#define PAGE_ALIGN(addr)  (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE209include/asm-mips/pgtable.hextern pmd_t invalid_pte_table[PAGE_SIZE/sizeof(pmd_t)];
PAGE_SIZE386include/asm-mips/pgtable.hmemset((void *) page, 0, PAGE_SIZE);
PAGE_SIZE387include/asm-mips/pgtable.hsys_cacheflush((void *)page, PAGE_SIZE, DCACHE);
PAGE_SIZE436include/asm-mips/pgtable.hmemset((void *) page, 0, PAGE_SIZE);
PAGE_SIZE437include/asm-mips/pgtable.hsys_cacheflush((void *)page, PAGE_SIZE, DCACHE);
PAGE_SIZE510include/asm-mips/pgtable.h"1" (PAGE_SIZE/(sizeof(pmd_t)*2))
PAGE_SIZE525include/asm-mips/pgtable.h"1" (PAGE_SIZE/sizeof(pmd_t)));
PAGE_SIZE536include/asm-mips/pgtable.hsys_cacheflush((void *)page, PAGE_SIZE, DCACHE);
PAGE_SIZE46include/asm-mips/user.h#define NBPG      PAGE_SIZE
PAGE_SIZE7include/asm-ppc/page.h#define PAGE_MASK  (~(PAGE_SIZE-1))
PAGE_SIZE56include/asm-ppc/page.h#define PAGE_ALIGN(addr)  (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE41include/asm-ppc/shmparam.h#define  SHMLBA PAGE_SIZE    /* attach addr a multiple of this */
PAGE_SIZE54include/asm-sparc/irq.hunsigned char space[PAGE_SIZE - 12];
PAGE_SIZE15include/asm-sparc/mp.hchar *kernel_stack[PAGE_SIZE<<1];
PAGE_SIZE20include/asm-sparc/mp.hchar filler[PERCPU_ENTSIZE-(PAGE_SIZE*2)-0xc];
PAGE_SIZE16include/asm-sparc/page.h#define PAGE_MASK    (~(PAGE_SIZE-1))
PAGE_SIZE109include/asm-sparc/page.h#define PAGE_ALIGN(addr)  (((addr)+PAGE_SIZE-1)&PAGE_MASK)
PAGE_SIZE106include/asm-sparc/pgtable.h#define PTRS_PER_PAGE   (PAGE_SIZE/sizeof(void*))
PAGE_SIZE166include/asm-sparc/ross.hend = page + PAGE_SIZE;
PAGE_SIZE42include/asm-sparc/shmparam.h#define  SHMLBA PAGE_SIZE    /* attach addr a multiple of this */
PAGE_SIZE45include/asm-sparc/swift.hfor(addr = 0; addr < (PAGE_SIZE << 2); addr += 16)
PAGE_SIZE53include/asm-sparc/swift.hfor(addr = 0; addr < (PAGE_SIZE << 2); addr += 16)
PAGE_SIZE61include/asm-sparc/swift.hfor(addr = 0; addr < (PAGE_SIZE << 2); addr += 16) {
PAGE_SIZE59include/asm-sparc/timer.hvolatile unsigned char space[PAGE_SIZE - 16];
PAGE_SIZE50include/asm-sparc/user.h#define NBPG                   PAGE_SIZE
PAGE_SIZE110include/linux/a.out.h#define N_TXTADDR(x) (N_MAGIC(x) == QMAGIC ? PAGE_SIZE : 0)
PAGE_SIZE127include/linux/a.out.h#define SEGMENT_SIZE PAGE_SIZE
PAGE_SIZE136include/linux/a.out.h#define SEGMENT_SIZE  PAGE_SIZE
PAGE_SIZE242include/linux/mm.hmemset((void *) page, 0, PAGE_SIZE);
PAGE_SIZE17include/linux/pagemap.hreturn PAGE_OFFSET + PAGE_SIZE * page->map_nr;
PAGE_SIZE77ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
PAGE_SIZE441ipc/shm.ctmp += PAGE_SIZE, shm_sgn += SWP_ENTRY(0, 1 << SHM_IDX_SHIFT))
PAGE_SIZE498ipc/shm.caddr > current->mm->start_stack - PAGE_SIZE*(shp->shm_npages + 4))
PAGE_SIZE525ipc/shm.cshmd->vm_end = addr + shp->shm_npages * PAGE_SIZE;
PAGE_SIZE112kernel/module.cnpages = (size + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE;
PAGE_SIZE113kernel/module.cif ((addr = vmalloc(npages * PAGE_SIZE)) == 0) {
PAGE_SIZE183kernel/module.cif ((codesize + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE > mp->size)
PAGE_SIZE187kernel/module.cmp->size * PAGE_SIZE - (codesize + sizeof (long)));
PAGE_SIZE1372kernel/sched.cfor (free = 1; free < PAGE_SIZE/sizeof(long) ; free++) {
PAGE_SIZE578kernel/sys.cif (find_vma_intersection(current, oldbrk, newbrk+PAGE_SIZE))
PAGE_SIZE107mm/filemap.cif (offset < PAGE_SIZE) {
PAGE_SIZE108mm/filemap.cmemset((void *) (offset + page_address(page)), 0, PAGE_SIZE - offset);
PAGE_SIZE217mm/filemap.clen = PAGE_SIZE - offset;
PAGE_SIZE234mm/filemap.clen = PAGE_SIZE;
PAGE_SIZE236mm/filemap.cpos += PAGE_SIZE;
PAGE_SIZE427mm/filemap.c#define MAX_READWINDOW (PAGE_SIZE*32)
PAGE_SIZE428mm/filemap.c#define MAX_READAHEAD (PAGE_SIZE*16)
PAGE_SIZE429mm/filemap.c#define MIN_READAHEAD (PAGE_SIZE)
PAGE_SIZE453mm/filemap.cfilp->f_ralen = PAGE_SIZE;
PAGE_SIZE463mm/filemap.celse if (try_async == 1 && rapos >= PAGE_SIZE &&
PAGE_SIZE470mm/filemap.crapos -= PAGE_SIZE;
PAGE_SIZE472mm/filemap.cmax_ahead = filp->f_ramax + PAGE_SIZE;
PAGE_SIZE487mm/filemap.cahead += PAGE_SIZE;
PAGE_SIZE506mm/filemap.cfilp->f_rapos = rapos + ahead + PAGE_SIZE;
PAGE_SIZE509mm/filemap.cfilp->f_ramax += PAGE_SIZE;
PAGE_SIZE510mm/filemap.celse if (filp->f_rawin > MAX_READWINDOW && filp->f_ramax > PAGE_SIZE)
PAGE_SIZE511mm/filemap.cfilp->f_ramax -= PAGE_SIZE;
PAGE_SIZE588mm/filemap.cif (pos + count <= (PAGE_SIZE >> 1)) {
PAGE_SIZE608mm/filemap.cnr = PAGE_SIZE - offset;
PAGE_SIZE652mm/filemap.cfilp->f_ramax -= PAGE_SIZE;
PAGE_SIZE734mm/filemap.cnew_page = try_to_read_ahead(inode, offset + PAGE_SIZE, 0);
PAGE_SIZE762mm/filemap.cmemcpy((void *) new_page, (void *) page, PAGE_SIZE);
PAGE_SIZE782mm/filemap.csize = offset + PAGE_SIZE;
PAGE_SIZE947mm/filemap.caddress += PAGE_SIZE;
PAGE_SIZE1055mm/filemap.cif (vma->vm_offset & (PAGE_SIZE - 1))
PAGE_SIZE96mm/kmalloc.c#if PAGE_SIZE == 4096
PAGE_SIZE131mm/kmalloc.c#elif PAGE_SIZE == 8192
PAGE_SIZE172mm/kmalloc.c#define AREASIZE(order)    (PAGE_SIZE<<(sizes[order].gfporder))
PAGE_SIZE63mm/memory.cmemset((void *) to, 0, PAGE_SIZE);
PAGE_SIZE66mm/memory.cmemcpy((void *) to, (void *) from, PAGE_SIZE);
PAGE_SIZE234mm/memory.caddress += PAGE_SIZE;
PAGE_SIZE339mm/memory.caddress += PAGE_SIZE;
PAGE_SIZE399mm/memory.caddress += PAGE_SIZE;
PAGE_SIZE469mm/memory.caddress += PAGE_SIZE;
PAGE_SIZE470mm/memory.coffset += PAGE_SIZE;
PAGE_SIZE728mm/memory.cstart += PAGE_SIZE;
PAGE_SIZE803mm/memory.cmemset((void *) address, 0, PAGE_SIZE - (address & ~PAGE_MASK));
PAGE_SIZE131mm/mlock.cstart += PAGE_SIZE;
PAGE_SIZE181mm/mmap.clen -= PAGE_SIZE;
PAGE_SIZE182mm/mmap.cstart += PAGE_SIZE;
PAGE_SIZE42mm/mprotect.caddress += PAGE_SIZE;
PAGE_SIZE105mm/mremap.coffset -= PAGE_SIZE;
PAGE_SIZE120mm/mremap.cwhile ((offset += PAGE_SIZE) < len)
PAGE_SIZE224mm/page_alloc.ctotal += nr * ((PAGE_SIZE>>10) << order);
PAGE_SIZE225mm/page_alloc.cprintk("%lu*%lukB ", nr, (PAGE_SIZE>>10) << order);
PAGE_SIZE95mm/page_io.cunsigned int zones[PAGE_SIZE/512];
PAGE_SIZE114mm/page_io.cfor (i=0, j=0; j< PAGE_SIZE ; i++, j += 512){
PAGE_SIZE125mm/page_io.cfor (i=0, j=0; j< PAGE_SIZE ; i++, j +=swapf->i_sb->s_blocksize)
PAGE_SIZE184mm/page_io.cbrw_page(rw, (unsigned long) buffer, dev, &block, PAGE_SIZE, 0);
PAGE_SIZE218mm/swapfile.caddress += PAGE_SIZE;
PAGE_SIZE440mm/swapfile.cset_blocksize(p->swap_device, PAGE_SIZE);
PAGE_SIZE468mm/swapfile.cif (memcmp("SWAP-SPACE",p->swap_lockmap+PAGE_SIZE-10,10)) {
PAGE_SIZE473mm/swapfile.cmemset(p->swap_lockmap+PAGE_SIZE-10,0,10);
PAGE_SIZE477mm/swapfile.cfor (i = 1 ; i < 8*PAGE_SIZE ; i++) {
PAGE_SIZE503mm/swapfile.cmemset(p->swap_lockmap,0,PAGE_SIZE);
PAGE_SIZE61mm/vmalloc.caddress += PAGE_SIZE;
PAGE_SIZE128mm/vmalloc.caddress += PAGE_SIZE;
PAGE_SIZE188mm/vmalloc.caddress += PAGE_SIZE;
PAGE_SIZE189mm/vmalloc.coffset += PAGE_SIZE;
PAGE_SIZE246mm/vmalloc.carea->size = size + PAGE_SIZE;
PAGE_SIZE265mm/vmalloc.cif ((PAGE_SIZE-1) & (unsigned long) addr) {
PAGE_SIZE340mm/vmalloc.cn = tmp->size - PAGE_SIZE;
PAGE_SIZE181mm/vmscan.ctsk->swap_address = address + PAGE_SIZE;
PAGE_SIZE185mm/vmscan.caddress += PAGE_SIZE;