taglinefilesource code
address70arch/alpha/boot/main.cunsigned long address = (unsigned long) pcb;
address73arch/alpha/boot/main.cresult = vptb[address >> 13];
address76arch/alpha/boot/main.cresult |= address & 0x1fff;
address56arch/alpha/mm/fault.casmlinkage void do_page_fault(unsigned long address, unsigned long mmcsr, long cause,
address62arch/alpha/mm/fault.cvma = find_vma(current, address);
address65arch/alpha/mm/fault.cif (vma->vm_start <= address)
address69arch/alpha/mm/fault.cif (expand_stack(vma, address))
address87arch/alpha/mm/fault.ctbis(address);
address88arch/alpha/mm/fault.chandle_mm_fault(vma, address, cause > 0);
address98arch/alpha/mm/fault.ccurrent->comm, regs.pc, regs.r26, address);
address108arch/alpha/mm/fault.c"Unable to handle kernel paging request at virtual address %016lx\n", address);
address113arch/i386/kernel/bios32.cunsigned long address;
address125arch/i386/kernel/bios32.cunsigned long address;    /* %ebx */
address131arch/i386/kernel/bios32.c"=b" (address),
address140arch/i386/kernel/bios32.creturn address + entry;
address153arch/i386/kernel/bios32.cunsigned long address;
address167arch/i386/kernel/bios32.cpci_indirect.address = pcibios_entry;
address441arch/i386/kernel/bios32.cbios32_indirect.address = bios32_entry = check->fields.entry;
address18arch/i386/kernel/ldt.cvoid * address = current->ldt;
address24arch/i386/kernel/ldt.cif (!address) {
address25arch/i386/kernel/ldt.caddress = &default_ldt;
address33arch/i386/kernel/ldt.cmemcpy_tofs(ptr, address, size);
address40arch/i386/math-emu/errors.cunsigned long address = FPU_ORIG_EIP;
address44arch/i386/math-emu/errors.cprintk("Unimplemented FPU Opcode at eip=%p : ", (void *) address);
address49arch/i386/math-emu/errors.cbyte1 = get_fs_byte((unsigned char *) address);
address52arch/i386/math-emu/errors.caddress++;
address55arch/i386/math-emu/errors.cFPU_modrm = get_fs_byte(1 + (unsigned char *) address);
address91arch/i386/math-emu/errors.cunsigned long address = FPU_ORIG_EIP;
address95arch/i386/math-emu/errors.cprintk("At %p:", (void *) address);
address101arch/i386/math-emu/errors.cbyte1 = get_fs_byte((unsigned char *) address);
address108arch/i386/math-emu/errors.caddress++;
address114arch/i386/math-emu/errors.cFPU_modrm = get_fs_byte(1 + (unsigned char *) address);
address139arch/i386/math-emu/fpu_entry.cstruct address data_sel_off;
address140arch/i386/math-emu/fpu_entry.cstruct address entry_sel_off;
address67arch/i386/math-emu/fpu_proto.hstruct address *addr,
address70arch/i386/math-emu/fpu_proto.hstruct address *addr,
address75arch/i386/math-emu/fpu_proto.hvoid *address);
address129arch/i386/math-emu/fpu_proto.hextern char *fldenv(fpu_addr_modes addr_modes, char *address);
address130arch/i386/math-emu/fpu_proto.hextern void frstor(fpu_addr_modes addr_modes, char *address);
address132arch/i386/math-emu/fpu_proto.hextern char *fstenv(fpu_addr_modes addr_modes, char *address);
address133arch/i386/math-emu/fpu_proto.hextern void fsave(fpu_addr_modes addr_modes, char *address);
address63arch/i386/math-emu/fpu_system.h#define instruction_address     (*(struct address *)&I387.soft.fip)
address64arch/i386/math-emu/fpu_system.h#define operand_address         (*(struct address *)&I387.soft.foo)
address149arch/i386/math-emu/get_address.cunsigned long base_address, limit, address, seg_top;
address164arch/i386/math-emu/get_address.caddress = base_address + offset;
address179arch/i386/math-emu/get_address.c(address <= limit) || (address >= seg_top) ? 0 :
address180arch/i386/math-emu/get_address.c((seg_top-address) >= 255 ? 255 : seg_top-address);
address185arch/i386/math-emu/get_address.c(address > limit) || (address < base_address) ? 0 :
address186arch/i386/math-emu/get_address.c((limit-address) >= 254 ? 255 : limit-address+1);
address193arch/i386/math-emu/get_address.creturn address;
address215arch/i386/math-emu/get_address.cstruct address *addr,
address222arch/i386/math-emu/get_address.cint address = 0;     /* Initialized just to stop compiler warnings. */
address238arch/i386/math-emu/get_address.caddress = sib(mod, fpu_eip);
address251arch/i386/math-emu/get_address.caddress = get_fs_long((unsigned long *) (*fpu_eip));
address254arch/i386/math-emu/get_address.caddr->offset = address;
address255arch/i386/math-emu/get_address.creturn (void *) address;
address259arch/i386/math-emu/get_address.caddress = *cpu_reg_ptr;  /* Just return the contents
address261arch/i386/math-emu/get_address.caddr->offset = address;
address262arch/i386/math-emu/get_address.creturn (void *) address;
address268arch/i386/math-emu/get_address.caddress = (signed char) get_fs_byte((char *) (*fpu_eip));
address276arch/i386/math-emu/get_address.caddress = (signed) get_fs_long((unsigned long *) (*fpu_eip));
address284arch/i386/math-emu/get_address.caddress += *cpu_reg_ptr;
address287arch/i386/math-emu/get_address.caddr->offset = address;
address294arch/i386/math-emu/get_address.caddress += vm86_segment(addr_modes.override.segment,
address299arch/i386/math-emu/get_address.caddress = pm_address(FPU_modrm, addr_modes.override.segment,
address300arch/i386/math-emu/get_address.c(unsigned short *)&(addr->selector), address);
address306arch/i386/math-emu/get_address.creturn (void *)address;
address311arch/i386/math-emu/get_address.cstruct address *addr,
address317arch/i386/math-emu/get_address.cint address = 0;     /* Default used for mod == 0 */
address339arch/i386/math-emu/get_address.caddress = (unsigned short)get_fs_word((unsigned short *) (*fpu_eip));
address349arch/i386/math-emu/get_address.caddress = (signed char) get_fs_byte((signed char *) (*fpu_eip));
address357arch/i386/math-emu/get_address.caddress = (unsigned) get_fs_word((unsigned short *) (*fpu_eip));
address369arch/i386/math-emu/get_address.caddress += FPU_info->___ebx + FPU_info->___esi;
address372arch/i386/math-emu/get_address.caddress += FPU_info->___ebx + FPU_info->___edi;
address375arch/i386/math-emu/get_address.caddress += FPU_info->___ebp + FPU_info->___esi;
address380arch/i386/math-emu/get_address.caddress += FPU_info->___ebp + FPU_info->___edi;
address385arch/i386/math-emu/get_address.caddress += FPU_info->___esi;
address388arch/i386/math-emu/get_address.caddress += FPU_info->___edi;
address391arch/i386/math-emu/get_address.caddress += FPU_info->___ebp;
address396arch/i386/math-emu/get_address.caddress += FPU_info->___ebx;
address401arch/i386/math-emu/get_address.caddress &= 0xffff;
address403arch/i386/math-emu/get_address.caddr->offset = address;
address410arch/i386/math-emu/get_address.caddress += vm86_segment(addr_modes.override.segment,
address415arch/i386/math-emu/get_address.caddress = pm_address(FPU_modrm, addr_modes.override.segment,
address416arch/i386/math-emu/get_address.c(unsigned short *)&(addr->selector), address);
address422arch/i386/math-emu/get_address.creturn (void *)address ;
address37arch/i386/mm/fault.cunsigned long address;
address41arch/i386/mm/fault.c__asm__("movl %%cr2,%0":"=r" (address));
address42arch/i386/mm/fault.cvma = find_vma(current, address);
address45arch/i386/mm/fault.cif (vma->vm_start <= address)
address56arch/i386/mm/fault.cif (address + 32 < regs->esp)
address59arch/i386/mm/fault.cif (expand_stack(vma, address))
address83arch/i386/mm/fault.cunsigned long bit = (address - 0xA0000) >> PAGE_SHIFT;
address92arch/i386/mm/fault.cdo_wp_page(current, vma, address, error_code & 2);
address95arch/i386/mm/fault.cdo_no_page(current, vma, address, error_code & 2);
address104arch/i386/mm/fault.ccurrent->tss.cr2 = address;
address116arch/i386/mm/fault.cif (wp_works_ok < 0 && address == TASK_SIZE && (error_code & 1)) {
address123arch/i386/mm/fault.cif ((unsigned long) (address-TASK_SIZE) < PAGE_SIZE) {
address128arch/i386/mm/fault.cprintk(" at virtual address %08lx\n",address);
address132arch/i386/mm/fault.cpage = ((unsigned long *) page)[address >> 22];
address136arch/i386/mm/fault.caddress &= 0x003ff000;
address137arch/i386/mm/fault.cpage = ((unsigned long *) page)[address >> PAGE_SHIFT];
address118arch/i386/mm/init.cunsigned long address;
address152arch/i386/mm/init.caddress = 0;
address154arch/i386/mm/init.cwhile (address < end_mem) {
address175arch/i386/mm/init.cpgd_val(pg_dir[0]) = _PAGE_TABLE | _PAGE_4M | address;
address176arch/i386/mm/init.cpgd_val(pg_dir[768]) = _PAGE_TABLE | _PAGE_4M | address;
address178arch/i386/mm/init.caddress += 4*1024*1024;
address194arch/i386/mm/init.cif (address < end_mem)
address195arch/i386/mm/init.cset_pte(pg_table, mk_pte(address, PAGE_SHARED));
address198arch/i386/mm/init.caddress += PAGE_SIZE;
address34arch/mips/kernel/sysmips.cget_max_hostname(unsigned long address)
address38arch/mips/kernel/sysmips.cvma = find_vma(current, address);
address39arch/mips/kernel/sysmips.cif (!vma || vma->vm_start > address || !(vma->vm_flags & VM_READ))
address41arch/mips/kernel/sysmips.caddress = vma->vm_end - address;
address42arch/mips/kernel/sysmips.cif (address > PAGE_SIZE)
address47arch/mips/kernel/sysmips.creturn address;
address29arch/mips/mm/fault.cdo_page_fault(struct pt_regs *regs, unsigned long writeaccess, unsigned long address)
address36arch/mips/mm/fault.caddress, regs->cp0_epc, regs->reg31);
address38arch/mips/mm/fault.cvma = find_vma(current, address);
address41arch/mips/mm/fault.cif (vma->vm_start <= address)
address45arch/mips/mm/fault.cif (expand_stack(vma, address))
address59arch/mips/mm/fault.chandle_mm_fault(vma, address, writeaccess);
address61arch/mips/mm/fault.csys_cacheflush(address, PAGE_SIZE, BCACHE);
address71arch/mips/mm/fault.ccurrent->tss.cp0_badvaddr = address;
address81arch/mips/mm/fault.c"address %08lx\n", address);
address183arch/ppc/mm/fault.cvoid do_page_fault(struct pt_regs *regs, unsigned long address, unsigned long error_code)
address195arch/ppc/mm/fault.cregs->nip, current,current->pid,current->mm,current->mm->mmap, address, error_code);
address198arch/ppc/mm/fault.cif (vma->vm_end > address)
address202arch/ppc/mm/fault.cvma = find_vma(current, address);
address208arch/ppc/mm/fault.cif (vma->vm_start <= address){
address213arch/ppc/mm/fault.cprintk("stack: gpr[1]=%x ip = %x; current=%x[%d]; mm=%x; mmap=%x; address = %x error_code = %x\n",regs->gpr[1],regs->nip, current,current->pid,current->mm,current->mm->mmap, address, error_code);
address217arch/ppc/mm/fault.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address219arch/ppc/mm/fault.cprintk("stack2: vma->vm_end-address %x rlim %x\n", vma->vm_end - address,
address221arch/ppc/mm/fault.cprintk("stack2: vm_end %x address = %x\n", vma->vm_end,address);
address222arch/ppc/mm/fault.cprintk("stack2: gpr[1]=%x ip = %x; current=%x[%d]; mm=%x; mmap=%x; address = %x error_code = %x\n",regs->gpr[1],regs->nip, current,current->pid,current->mm,current->mm->mmap, address, error_code);
address226arch/ppc/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address227arch/ppc/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address242arch/ppc/mm/fault.ccurrent,address,vma->vm_flags,current->mm,vma,vma->vm_start,vma->vm_end);
address273arch/ppc/mm/fault.chandle_mm_fault(vma, address, error_code & 2); 
address284arch/ppc/mm/fault.cprintk("Task: %x, PC: %x, bad area! - Addr: %x\n", current, regs->nip, address);
address290arch/ppc/mm/fault.ccurrent, regs->nip, address, current->tss.pg_tables);
address296arch/ppc/mm/fault.ccurrent,address,vma->vm_flags,current->mm,vma,vma->vm_start,vma->vm_end);
address304arch/ppc/mm/fault.cva_to_phys(unsigned long address)
address309arch/ppc/mm/fault.cdir = pgd_offset(current->mm, address & PAGE_MASK);
address312arch/ppc/mm/fault.cpmd = pmd_offset(dir, address & PAGE_MASK);
address315arch/ppc/mm/fault.cpte = pte_offset(pmd, address & PAGE_MASK);
address318arch/ppc/mm/fault.creturn(pte_page(*pte) | (address & ~(PAGE_MASK-1)));
address169arch/ppc/mm/init.cunsigned long address;
address172arch/ppc/mm/init.caddress = 0;
address174arch/ppc/mm/init.cwhile (address < end_mem) {
address186arch/ppc/mm/init.cif (address < end_mem)
address187arch/ppc/mm/init.c*pg_table = mk_pte(address, PAGE_SHARED);
address190arch/ppc/mm/init.caddress += PAGE_SIZE;
address724arch/ppc/mm/init.cunsigned long address;
address732arch/ppc/mm/init.caddress = 0;
address733arch/ppc/mm/init.cfor (i = 0 ; (i < PTRS_PER_PGD) && (address < KERNELBASE); i++)
address745arch/ppc/mm/init.cflags = MMU_hash_page(&current->tss, address, 0);
address749arch/ppc/mm/init.caddress += PAGE_SIZE;
address753arch/ppc/mm/init.caddress += PAGE_SIZE*PTRS_PER_PTE;
address757arch/ppc/mm/init.caddress += PAGE_SIZE*PTRS_PER_PTE;
address50arch/sparc/kernel/ioport.cvoid *sparc_alloc_io (void *address, void *virtual, int len, char *name,
address54arch/sparc/kernel/ioport.cunsigned long addr = (unsigned long) address;
address234arch/sparc/kernel/sys_sunos.casmlinkage void sunos_madvise(unsigned long address, unsigned long len,
address241arch/sparc/kernel/sys_sunos.caddress, len);
address120arch/sparc/mm/fault.cunsigned long address)
address126arch/sparc/mm/fault.caddress = regs->pc;
address133arch/sparc/mm/fault.cif(!from_user && address >= KERNBASE) {
address134arch/sparc/mm/fault.cquick_kernel_fault(address);
address138arch/sparc/mm/fault.cvma = find_vma(current, address);
address141arch/sparc/mm/fault.cif(vma->vm_start <= address)
address145arch/sparc/mm/fault.cif(expand_stack(vma, address))
address160arch/sparc/mm/fault.chandle_mm_fault(vma, address, write);
address168arch/sparc/mm/fault.ccurrent->tss.sig_address = address;
address174arch/sparc/mm/fault.cif (wp_works_ok < 0 && address == 0x0) {
address183arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
address187arch/sparc/mm/fault.cprintk(" at virtual address %08lx\n",address);
address196arch/sparc/mm/fault.cinline void force_user_fault(unsigned long address, int write)
address200arch/sparc/mm/fault.cvma = find_vma(current, address);
address203arch/sparc/mm/fault.cif(vma->vm_start <= address)
address207arch/sparc/mm/fault.cif(expand_stack(vma, address))
address216arch/sparc/mm/fault.chandle_mm_fault(vma, address, write);
address219arch/sparc/mm/fault.ccurrent->tss.sig_address = address;
address35arch/sparc/mm/loadmmu.cvoid (*update_mmu_cache)(struct vm_area_struct *vma, unsigned long address, pte_t pte);
address40arch/sparc/mm/loadmmu.cvoid (*invalidate_page)(struct vm_area_struct *, unsigned long address);
address207arch/sparc/mm/srmmu.cstatic pgd_t *srmmu_pgd_offset(struct mm_struct * mm, unsigned long address)
address209arch/sparc/mm/srmmu.creturn mm->pgd + ((address >> SRMMU_PGDIR_SHIFT) & (SRMMU_PTRS_PER_PGD - 1));
address213arch/sparc/mm/srmmu.cstatic pmd_t *srmmu_pmd_offset(pgd_t * dir, unsigned long address)
address215arch/sparc/mm/srmmu.creturn (pmd_t *) pgd_page(*dir) + ((address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1));
address219arch/sparc/mm/srmmu.cstatic pte_t *srmmu_pte_offset(pmd_t * dir, unsigned long address)
address221arch/sparc/mm/srmmu.creturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1));
address242arch/sparc/mm/srmmu.cstatic pte_t *srmmu_pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address244arch/sparc/mm/srmmu.caddress = (address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1);
address251arch/sparc/mm/srmmu.creturn page + address;
address263arch/sparc/mm/srmmu.creturn (pte_t *) srmmu_pmd_page(*pmd) + address;
address272arch/sparc/mm/srmmu.cstatic pmd_t *srmmu_pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address274arch/sparc/mm/srmmu.caddress = (address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1);
address281arch/sparc/mm/srmmu.creturn page + address;
address293arch/sparc/mm/srmmu.creturn (pmd_t *) pgd_page(*pgd) + address;
address301arch/sparc/mm/srmmu.cstatic pte_t *srmmu_pte_alloc(pmd_t * pmd, unsigned long address)
address303arch/sparc/mm/srmmu.caddress = (address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1);
address309arch/sparc/mm/srmmu.creturn page + address;
address321arch/sparc/mm/srmmu.creturn (pte_t *) pmd_page(*pmd) + address;
address330arch/sparc/mm/srmmu.cstatic pmd_t *srmmu_pmd_alloc(pgd_t * pgd, unsigned long address)
address332arch/sparc/mm/srmmu.caddress = (address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1);
address338arch/sparc/mm/srmmu.creturn page + address;
address350arch/sparc/mm/srmmu.creturn (pmd_t *) srmmu_pgd_page(*pgd) + address;
address663arch/sparc/mm/srmmu.cstatic void srmmu_quick_kernel_fault(unsigned long address)
address665arch/sparc/mm/srmmu.cprintk("SRMMU: quick_kernel_fault called for %08lx\n", address);
address1126arch/sparc/mm/srmmu.cstatic void srmmu_update_mmu_cache(struct vm_area_struct * vma, unsigned long address, pte_t pte)
address525arch/sparc/mm/sun4c.cstatic inline void alloc_user_segment(unsigned long address, unsigned char ctx)
address529arch/sparc/mm/sun4c.caddress &= SUN4C_REAL_PGDIR_MASK;
address532arch/sparc/mm/sun4c.centry->vaddr = address;
address536arch/sparc/mm/sun4c.cstatic inline void alloc_kernel_segment(unsigned long address)
address540arch/sparc/mm/sun4c.caddress &= SUN4C_REAL_PGDIR_MASK;
address544arch/sparc/mm/sun4c.centry->vaddr = address;
address555arch/sparc/mm/sun4c.cstatic void sun4c_update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t pte)
address560arch/sparc/mm/sun4c.caddress &= PAGE_MASK;
address561arch/sparc/mm/sun4c.cif(sun4c_get_segmap(address) == invalid_segment)
address562arch/sparc/mm/sun4c.calloc_user_segment(address, sun4c_get_context());
address563arch/sparc/mm/sun4c.csun4c_put_pte(address, pte_val(pte));
address577arch/sparc/mm/sun4c.cstatic void sun4c_quick_kernel_fault(unsigned long address)
address582arch/sparc/mm/sun4c.caddress &= SUN4C_REAL_PGDIR_MASK;
address583arch/sparc/mm/sun4c.cend = address + SUN4C_REAL_PGDIR_SIZE;
address584arch/sparc/mm/sun4c.cif(sun4c_get_segmap(address) == invalid_segment)
address585arch/sparc/mm/sun4c.calloc_kernel_segment(address);
address587arch/sparc/mm/sun4c.cif(address < SUN4C_VMALLOC_START) {
address589arch/sparc/mm/sun4c.cpte = (address - PAGE_OFFSET) >> PAGE_SHIFT;
address592arch/sparc/mm/sun4c.cwhile(address < end) {
address593arch/sparc/mm/sun4c.csun4c_put_pte(address, pte++);
address594arch/sparc/mm/sun4c.caddress += PAGE_SIZE;
address599arch/sparc/mm/sun4c.cptep = (pte_t *) (PAGE_MASK & pgd_val(swapper_pg_dir[address>>SUN4C_PGDIR_SHIFT]));
address600arch/sparc/mm/sun4c.cptep = (ptep + ((address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1)));
address601arch/sparc/mm/sun4c.cwhile(address < end) {
address602arch/sparc/mm/sun4c.csun4c_put_pte(address, pte_val(*ptep++));
address603arch/sparc/mm/sun4c.caddress += PAGE_SIZE;
address1187arch/sparc/mm/sun4c.cstatic pgd_t *sun4c_pgd_offset(struct mm_struct * mm, unsigned long address)
address1189arch/sparc/mm/sun4c.creturn mm->pgd + (address >> SUN4C_PGDIR_SHIFT);
address1193arch/sparc/mm/sun4c.cstatic pmd_t *sun4c_pmd_offset(pgd_t * dir, unsigned long address)
address1199arch/sparc/mm/sun4c.cstatic pte_t *sun4c_pte_offset(pmd_t * dir, unsigned long address)
address1201arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*dir) +  ((address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1));
address1219arch/sparc/mm/sun4c.cstatic pte_t *sun4c_pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address1221arch/sparc/mm/sun4c.caddress = (address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1);
address1228arch/sparc/mm/sun4c.creturn page + address;
address1240arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*pmd) + address;
address1252arch/sparc/mm/sun4c.cstatic pmd_t *sun4c_pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address1262arch/sparc/mm/sun4c.cstatic pte_t *sun4c_pte_alloc(pmd_t * pmd, unsigned long address)
address1264arch/sparc/mm/sun4c.caddress = (address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1);
address1270arch/sparc/mm/sun4c.creturn page + address;
address1282arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*pmd) + address;
address1294arch/sparc/mm/sun4c.cstatic pmd_t *sun4c_pmd_alloc(pgd_t * pgd, unsigned long address)
address726drivers/block/floppy.cif (FDCS->address == -1)
address1032drivers/block/floppy.cvirtual_dma_port = FDCS->address;
address1670drivers/block/floppy.cif (fdc >= N_FDC || FDCS->address == -1){
address2832drivers/block/floppy.cstatic int fd_copyout(void *param, const void *address, int size)
address2837drivers/block/floppy.cfd_cacheflush(address, size); /* is this necessary ??? */
address2840drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
address2844drivers/block/floppy.cstatic int fd_copyin(void *param, void *address, int size)
address2849drivers/block/floppy.cmemcpy_fromfs((void *) address, param, size);
address3981drivers/block/floppy.cfdc_state[0].address = FDC1;
address3983drivers/block/floppy.cfdc_state[1].address = FDC2;
address4006drivers/block/floppy.cif (FDCS->address == -1)
address4010drivers/block/floppy.cFDCS->address = -1;
address4016drivers/block/floppy.cFDCS->address = -1;
address4020drivers/block/floppy.crequest_region(FDCS->address, 6, "floppy");
address4021drivers/block/floppy.crequest_region(FDCS->address+7, 1, "floppy DIR");
address4056drivers/block/floppy.cif (FDCS->address != -1){
address4076drivers/block/floppy.cif (FDCS->address != -1)
address4218drivers/block/floppy.cif (FDCS->address != -1){
address4219drivers/block/floppy.crelease_region(FDCS->address, 6);
address4220drivers/block/floppy.crelease_region(FDCS->address+7, 1);
address133drivers/block/xd.cstatic u_char xd_detect (u_char *controller,u_char **address)
address140drivers/block/xd.c*address = NULL;
address148drivers/block/xd.c*address = xd_bases[i];
address158drivers/block/xd.cu_char i,controller,*address;
address160drivers/block/xd.cif (xd_detect(&controller,&address)) {
address162drivers/block/xd.cprintk("xd_geninit: detected a%s controller (type %d) at address %p\n",xd_sigs[controller].name,controller,address);
address164drivers/block/xd.cxd_sigs[controller].init_controller(address);
address533drivers/block/xd.cstatic void xd_dtc_init_controller (u_char *address)
address535drivers/block/xd.cswitch ((u_long) address) {
address538drivers/block/xd.cdefault:        printk("xd_dtc_init_controller: unsupported BIOS address %p\n",address);
address573drivers/block/xd.cstatic void xd_wd_init_controller (u_char *address)
address575drivers/block/xd.cswitch ((u_long) address) {
address582drivers/block/xd.cdefault:        printk("xd_wd_init_controller: unsupported BIOS address %p\n",address);
address614drivers/block/xd.cstatic void xd_seagate_init_controller (u_char *address)
address616drivers/block/xd.cswitch ((u_long) address) {
address621drivers/block/xd.cdefault:  printk("xd_seagate_init_controller: unsupported BIOS address %p\n",address);
address647drivers/block/xd.cstatic void xd_omti_init_controller (u_char *address)
address649drivers/block/xd.cswitch ((u_long) address) {
address654drivers/block/xd.cdefault:  printk("xd_omti_init_controller: unsupported BIOS address %p\n",address);
address2008drivers/cdrom/cdu31a.cschi.cdsc_adr = last_sony_subcode.address;
address2529drivers/cdrom/cdu31a.cloc_entry.cdte_adr = sony_toc.tracks[track_idx].address;
address694drivers/cdrom/sbpcd.cu_int address;
address3619drivers/cdrom/sbpcd.cD_S[d].TocBuffer[j].address=D_S[d].TocEnt_address;
address3627drivers/cdrom/sbpcd.cD_S[d].TocBuffer[j].address=D_S[d].size_msf;
address3958drivers/cdrom/sbpcd.cD_S[d].pos_audio_start=D_S[d].TocBuffer[ti.cdti_trk0].address;
address3959drivers/cdrom/sbpcd.cD_S[d].pos_audio_end=D_S[d].TocBuffer[ti.cdti_trk1+1].address;
address3989drivers/cdrom/sbpcd.ctocentry.cdte_addr.msf.minute=(D_S[d].TocBuffer[i].address>>16)&0x00FF;
address3990drivers/cdrom/sbpcd.ctocentry.cdte_addr.msf.second=(D_S[d].TocBuffer[i].address>>8)&0x00FF;
address3991drivers/cdrom/sbpcd.ctocentry.cdte_addr.msf.frame=D_S[d].TocBuffer[i].address&0x00FF;
address3994drivers/cdrom/sbpcd.ctocentry.cdte_addr.lba=msf2blk(D_S[d].TocBuffer[i].address);
address1046drivers/cdrom/sonycd535.cschi.cdsc_adr = last_sony_subcode->address;
address1132drivers/char/cyclades.cget_auto_irq(unsigned char *address)
address1139drivers/char/cyclades.cbase_addr = address;
address1140drivers/char/cyclades.cintr_base_addr = address;
address1167drivers/char/cyclades.cdo_auto_irq(unsigned char *address)
address1185drivers/char/cyclades.cirq_try_1 = get_auto_irq(address);
address1187drivers/char/cyclades.cirq_try_2 = get_auto_irq(address);
address402drivers/char/ftape/fdc-isr.cbuff->bytes = buff->ptr - buff->address;
address415drivers/char/ftape/fdc-isr.cbuff->bytes = buff->ptr - buff->address;
address366drivers/char/ftape/ftape-eof.cvoid extract_file_marks(byte * address)
address373drivers/char/ftape/ftape-eof.cbyte *start = find_end_of_bsm_list(address + 256,
address374drivers/char/ftape/ftape-eof.caddress + 29 * SECTOR_SIZE);
address380drivers/char/ftape/ftape-eof.cend = find_end_of_eof_list(start, address + 29 * SECTOR_SIZE);
address391drivers/char/ftape/ftape-eof.cmemcpy(eof_map, address + 256, sizeof(eof_map));
address392drivers/char/ftape/ftape-eof.cnr_of_eof_marks = GET2(address, 144);
address48drivers/char/ftape/ftape-eof.hextern void extract_file_marks(byte * address);
address62drivers/char/ftape/ftape-read.cbuffer[i].address = tape_buffer[i];
address119drivers/char/ftape/ftape-read.cmseg.data = buffer[tail].address;
address158drivers/char/ftape/ftape-read.cint read_segment(unsigned segment_id, byte * address, int *eof_mark,
address224drivers/char/ftape/ftape-read.cresult = correct_and_copy(tail, address);
address364drivers/char/ftape/ftape-read.cint read_header_segment(byte * address)
address398drivers/char/ftape/ftape-read.cresult = read_segment(header_segment, address, &status, 0);
address416drivers/char/ftape/ftape-read.cif (GET4(address, 0) != 0xaa55aa55) {
address421drivers/char/ftape/ftape-read.cheader_segment_1 = GET2(address, 6);
address422drivers/char/ftape/ftape-read.cheader_segment_2 = GET2(address, 8);
address440drivers/char/ftape/ftape-read.cformat_code = (format_type) * (address + 4);
address441drivers/char/ftape/ftape-read.csegments_per_track = GET2(address, 24);
address442drivers/char/ftape/ftape-read.ctracks_per_tape = *(address + 26);
address443drivers/char/ftape/ftape-read.cmax_floppy_side = *(address + 27);
address444drivers/char/ftape/ftape-read.cmax_floppy_track = *(address + 28);
address445drivers/char/ftape/ftape-read.cmax_floppy_sector = *(address + 29);
address543drivers/char/ftape/ftape-read.cfirst_data_segment = GET2(address, 10);    /* first data segment */
address545drivers/char/ftape/ftape-read.cextract_bad_sector_map(address);
address570drivers/char/ftape/ftape-read.cextract_file_marks(address);
address40drivers/char/ftape/ftape-read.hextern int read_header_segment(byte * address);
address41drivers/char/ftape/ftape-read.hextern int read_segment(unsigned segment, byte * address, int *eof_mark,
address128drivers/char/ftape/ftape-rw.cbuff->ptr = buff->address + buff->data_offset * SECTOR_SIZE;
address37drivers/char/ftape/ftape-rw.h#define GET2( address, offset) *(short*)(address + offset)
address38drivers/char/ftape/ftape-rw.h#define GET4( address, offset) *(long*)(address + offset)
address39drivers/char/ftape/ftape-rw.h#define PUT2( address, offset, value) *(short*)(address + offset) = value
address40drivers/char/ftape/ftape-rw.h#define PUT4( address, offset, value) *(long*)(address + offset) = value
address54drivers/char/ftape/ftape-rw.hbyte *address;
address193drivers/char/ftape/ftape-write.cint write_segment(unsigned segment_id, byte * address, int flushing)
address272drivers/char/ftape/ftape-write.cresult = copy_and_gen_ecc(buffer[tail].address, address,
address43drivers/char/ftape/ftape-write.hextern int write_segment(unsigned segment, byte * address, int flushing);
address1289drivers/char/keyboard.cstatic void kbd_write(int address, int data)
address1296drivers/char/keyboard.coutb(data, address);               /* write out the data*/
address589drivers/net/de4x5.cstatic short   srom_rd(u_long address, u_char offset);
address590drivers/net/de4x5.cstatic void    srom_latch(u_int command, u_long address);
address591drivers/net/de4x5.cstatic void    srom_command(u_int command, u_long address);
address592drivers/net/de4x5.cstatic void    srom_address(u_int command, u_long address, u_char offset);
address593drivers/net/de4x5.cstatic short   srom_data(u_int command, u_long address);
address274drivers/net/i82586.hLinux packets are passed down with the destination MAC address
address221drivers/net/ppp.c__u8 address;
address1866drivers/net/ppp.cint  address, control;
address1884drivers/net/ppp.caddress = PPP_ADDRESS  (data);
address1888drivers/net/ppp.cif (address != PPP_ALLSTATIONS ||
address1891drivers/net/ppp.cppp_stuff_char (ppp, buf, address);
address1954drivers/net/ppp.cint  address, control;
address1967drivers/net/ppp.caddress = PPP_ADDRESS  (data);
address1972drivers/net/ppp.c(address == PPP_ALLSTATIONS)  &&
address2958drivers/net/ppp.chdr->address   = PPP_ALLSTATIONS;
address3026drivers/net/ppp.chdr->address   = PPP_ALLSTATIONS;
address988drivers/net/smc9194.cword  address;
address990drivers/net/smc9194.caddress = inw( ioaddr + ADDR0 + i  );
address991drivers/net/smc9194.cdev->dev_addr[ i + 1] = address >> 8;
address992drivers/net/smc9194.cdev->dev_addr[ i ] = address & 0xFF;  
address1209drivers/net/smc9194.cword  address;
address1211drivers/net/smc9194.caddress = dev->dev_addr[ i + 1 ] << 8 ;
address1212drivers/net/smc9194.caddress  |= dev->dev_addr[ i ];
address1213drivers/net/smc9194.coutw( address, ioaddr + ADDR0 + i );
address1648drivers/scsi/53c7,8xx.cvirt_to_bus(EXTERNAL_PATCHES[i].address);
address2236drivers/scsi/53c7,8xx.cfor (bp = hostdata->breakpoints; bp && bp->address != dsp; 
address3177drivers/scsi/53c7,8xx.cbp->address = (u32 *) args[0];
address3178drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
address3183drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
address3777drivers/scsi/53c7,8xx.cvirt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) :
address5720drivers/scsi/53c7,8xx.cbuffers && !((found = ((ptr >= segment->address) && 
address5721drivers/scsi/53c7,8xx.c(ptr < (segment->address + segment->length)))));
address5725drivers/scsi/53c7,8xx.ccmd->host->host_no, saved, segment->address);
address5729drivers/scsi/53c7,8xx.coffset += ptr - segment->address;
address96drivers/scsi/53c7,8xx.hextern inline unsigned long virt_to_phys(volatile void * address)
address98drivers/scsi/53c7,8xx.hreturn (unsigned long) address;
address101drivers/scsi/53c7,8xx.hextern inline void * phys_to_virt(unsigned long address)
address103drivers/scsi/53c7,8xx.hreturn (void *) address;      
address1024drivers/scsi/53c7,8xx.hvoid *address;
address1165drivers/scsi/53c7,8xx.hu32 *address, old_instruction[2];
address1507drivers/scsi/53c7,8xx.h#define NCR53c7x0_read8(address)           \
address1509drivers/scsi/53c7,8xx.h(unsigned int)readb(NCR53c7x0_address_memory + (address)) :  \
address1510drivers/scsi/53c7,8xx.hinb(NCR53c7x0_address_io + (address)))
address1512drivers/scsi/53c7,8xx.h#define NCR53c7x0_read16(address)           \
address1514drivers/scsi/53c7,8xx.h(unsigned int)readw(NCR53c7x0_address_memory + (address)) :  \
address1515drivers/scsi/53c7,8xx.hinw(NCR53c7x0_address_io + (address)))
address1517drivers/scsi/53c7,8xx.h#define NCR53c7x0_read32(address)           \
address1519drivers/scsi/53c7,8xx.h(unsigned int) readl(NCR53c7x0_address_memory + (address)) :   \
address1520drivers/scsi/53c7,8xx.hinl(NCR53c7x0_address_io + (address)))
address1522drivers/scsi/53c7,8xx.h#define NCR53c7x0_write8(address,value)         \
address1524drivers/scsi/53c7,8xx.h({writeb((value), NCR53c7x0_address_memory + (address)); mb();}) :  \
address1525drivers/scsi/53c7,8xx.houtb((value), NCR53c7x0_address_io + (address)))
address1527drivers/scsi/53c7,8xx.h#define NCR53c7x0_write16(address,value)         \
address1529drivers/scsi/53c7,8xx.h({writew((value), NCR53c7x0_address_memory + (address)); mb();}) :  \
address1530drivers/scsi/53c7,8xx.houtw((value), NCR53c7x0_address_io + (address)))
address1532drivers/scsi/53c7,8xx.h#define NCR53c7x0_write32(address,value)         \
address1534drivers/scsi/53c7,8xx.h({writel((value), NCR53c7x0_address_memory + (address)); mb();}) :  \
address1535drivers/scsi/53c7,8xx.houtl((value), NCR53c7x0_address_io + (address)))
address2671drivers/scsi/53c8xx_d.hvoid    *address;
address762drivers/scsi/AM53C974.ccmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
address1417drivers/scsi/AM53C974.ccmd->SCp.ptr = (unsigned char *)cmd->SCp.buffer->address;
address2458drivers/scsi/BusLogic.cScatterList[Segment].address;
address330drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
address2412drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
address874drivers/scsi/NCR53c406a.cNCR53c406a_pio_write(sglist->address, sglist->length);
address903drivers/scsi/NCR53c406a.cNCR53c406a_pio_read(sglist->address, sglist->length);
address3772drivers/scsi/advansys.csghead.sg_list[sgcnt].addr = (ulong) slp->address;
address4238drivers/scsi/advansys.culong address;
address4285drivers/scsi/advansys.caddress = (ulong) ((lbus << 16) | (lslot << 11) |
address4291drivers/scsi/advansys.coutl(address, 0xCF8);
address4312drivers/scsi/advansys.culong address;
address4362drivers/scsi/advansys.caddress = (ulong) ((lbus << 16) | (lslot << 11) |
address4368drivers/scsi/advansys.coutl(address, 0xCF8);
address907drivers/scsi/aha152x.cSCpnt->SCp.ptr              = SCpnt->SCp.buffer->address;
address2121drivers/scsi/aha152x.cCURRENT_SC->SCp.buffer->address;
address2261drivers/scsi/aha152x.cCURRENT_SC->SCp.buffer->address;
address618drivers/scsi/aha1542.c(((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
address622drivers/scsi/aha1542.cprintk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
address630drivers/scsi/aha1542.cany2scsi(cptr[i].dataptr, sgpnt[i].address);
address631drivers/scsi/aha1542.cif(((unsigned  int) sgpnt[i].address) & 0xff000000) goto baddma;
address339drivers/scsi/aha1740.ccptr[i].dataptr = (long) sgpnt[i].address;
address449drivers/scsi/aic7xxx.c((char *) &(sg).address - (char *) &(sg) != 0 ||  \
address451drivers/scsi/aic7xxx.csizeof((sg).address) != 4 ||                   \
address2111drivers/scsi/aic7xxx.cscb->sense_sg.address = (char *) &cmd->sense_buffer;
address2128drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(scb->sense_sg.address), 4);
address4176drivers/scsi/aic7xxx.cmemcpy(scb->data_pointer, &(sg[0].address), sizeof(scb->data_pointer));
address4204drivers/scsi/aic7xxx.cscb->sg.address = (char *) cmd->request_buffer;
address97drivers/scsi/dtc.cunsigned char *address;
address110drivers/scsi/dtc.cunsigned char *address;
address141drivers/scsi/dtc.coverrides[commandline_current].address = (unsigned char *) ints[1];
address144drivers/scsi/dtc.cif (bases[i].address == (unsigned char *) ints[1]) {
address178drivers/scsi/dtc.cif (overrides[current_override].address)
address179drivers/scsi/dtc.cbase = overrides[current_override].address;
address183drivers/scsi/dtc.cprintk("scsi : probing address %08x\n", (unsigned int) bases[current_base].address);
address187drivers/scsi/dtc.c(bases[current_base].address + signatures[sig].offset,
address189drivers/scsi/dtc.cbase = bases[current_base].address;
address297drivers/scsi/eata.cunsigned int address;     /* Segment Address */
address600drivers/scsi/eata.ccpp->sglist[k].address = htonl((unsigned int) sgpnt[k].address);
address483drivers/scsi/eata_dma.ccp->sg_list[i].data = htonl(virt_to_bus(sl->address));
address121drivers/scsi/eata_pio.cSCp->ptr=SCp->buffer->address;
address372drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->SCp.buffer->address;
address1612drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1645drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1729drivers/scsi/fdomain.ccurrent_SC->SCp.ptr              = current_SC->SCp.buffer->address;
address217drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address274drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address507drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address396drivers/scsi/qlogic.cif (ql_pdma(phase, sglist->address, sglist->length))
address226drivers/scsi/scsi.hchar *  address;    /* Location data is to be transferred to */
address140drivers/scsi/scsi_debug.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address163drivers/scsi/scsi_debug.clpnt = (unsigned int *) sgpnt[0].address;
address289drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address360drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address388drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address245drivers/scsi/sd.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, 
address250drivers/scsi/sd.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, 
address252drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address309drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address705drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
address709drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length - 1 > 
address712drivers/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
address718drivers/scsi/sd.csgpnt[count].address = NULL;
address720drivers/scsi/sd.csgpnt[count].address = 
address728drivers/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address734drivers/scsi/sd.cscsi_free(sgpnt[count].address, 
address757drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length +
address771drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address772drivers/scsi/sd.csgpnt[count].address = tmp;
address802drivers/scsi/sd.csgpnt[count].address,
address811drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
address943drivers/scsi/seagate.chostno, i, buffer[i].address, buffer[i].length);
address949drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1185drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1331drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address191drivers/scsi/sr.cif (sgpnt[i].alt_address != sgpnt[i].address) {
address192drivers/scsi/sr.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address194drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address230drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address769drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address770drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address771drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
address778drivers/scsi/sr.csgpnt[count].address = bh->b_data;
address782drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(end_rec);
address783drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address785drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address789drivers/scsi/sr.cif (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD &&
address791drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address796drivers/scsi/sr.csgpnt[count].address = NULL;
address798drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address804drivers/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address809drivers/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address824drivers/scsi/sr.csgpnt[count].address, 
address130drivers/scsi/t128.cunsigned char *address;
address143drivers/scsi/t128.cunsigned char *address;
address176drivers/scsi/t128.coverrides[commandline_current].address = (unsigned char *) ints[1];
address179drivers/scsi/t128.cif (bases[i].address == (unsigned char *) ints[1]) {
address212drivers/scsi/t128.cif (overrides[current_override].address)
address213drivers/scsi/t128.cbase = overrides[current_override].address;
address217drivers/scsi/t128.cprintk("scsi : probing address %08x\n", (unsigned int) bases[current_base].address);
address221drivers/scsi/t128.c(bases[current_base].address + signatures[sig].offset, 
address223drivers/scsi/t128.cbase = bases[current_base].address;
address264drivers/scsi/u14-34f.cunsigned int address;     /* Segment Address */
address564drivers/scsi/u14-34f.ccpp->sglist[k].address = (unsigned int) sgpnt[k].address;
address176drivers/scsi/ultrastor.cunsigned int address;
address665drivers/scsi/ultrastor.cmscp->sglist[i].address = (unsigned int)sl[i].address;
address937drivers/scsi/wd7000.cany2scsi(sgb[i].ptr, (int) sg[i].address);
address341drivers/sound/gus_wave.cgus_write_addr (int reg, unsigned long address, int is16bit)
address354drivers/sound/gus_wave.chold_address = address;
address355drivers/sound/gus_wave.caddress = address >> 1;
address356drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address357drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address360drivers/sound/gus_wave.cgus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
address361drivers/sound/gus_wave.cgus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
address364drivers/sound/gus_wave.cgus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
address365drivers/sound/gus_wave.cgus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
address1682drivers/sound/gus_wave.cunsigned long   address, hold_address;
address1704drivers/sound/gus_wave.caddress = target;
address1708drivers/sound/gus_wave.chold_address = address;
address1709drivers/sound/gus_wave.caddress = address >> 1;
address1710drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address1711drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address1714drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address2267drivers/sound/gus_wave.cunsigned long   address, hold_address;
address2290drivers/sound/gus_wave.caddress = this_one * pcm_bsize;
address2291drivers/sound/gus_wave.caddress += chn * pcm_banksize;
address2295drivers/sound/gus_wave.chold_address = address;
address2296drivers/sound/gus_wave.caddress = address >> 1;
address2297drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address2298drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address2301drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address1135fs/buffer.cint brw_page(int rw, unsigned long address, kdev_t dev, int b[], int size, int bmap)
address1141fs/buffer.cpage = mem_map + MAP_NR(address);
address1150fs/buffer.cbh = create_buffers(address, size);
address1294fs/buffer.cunsigned long block, address;
address1298fs/buffer.caddress = page_address(page);
address1314fs/buffer.cbrw_page(READ, address, inode->i_dev, nr, inode->i_sb->s_blocksize, 1);
address29fs/fat/mmap.cunsigned long address,
address41fs/fat/mmap.caddress &= PAGE_MASK;
address42fs/fat/mmap.cpos = address - area->vm_start + area->vm_offset;
address29fs/namei.cstatic inline int get_max_filename(unsigned long address)
address35fs/namei.cvma = find_vma(current, address);
address36fs/namei.cif (!vma || vma->vm_start > address || !(vma->vm_flags & VM_READ))
address38fs/namei.caddress = vma->vm_end - address;
address39fs/namei.cif (address > PAGE_SIZE)
address44fs/namei.creturn address;
address34fs/ncpfs/mmap.cunsigned long address, int no_share)
address47fs/ncpfs/mmap.caddress &= PAGE_MASK;
address48fs/ncpfs/mmap.cpos = address - area->vm_start + area->vm_offset;
address51fs/ncpfs/mmap.cif (address + PAGE_SIZE > area->vm_end)
address53fs/ncpfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
address157fs/nfs/bio.cunsigned long  address;
address161fs/nfs/bio.caddress = page_address(page);
address167fs/nfs/bio.cfree_page(address);
address730fs/proc/array.cstatic inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
address743fs/proc/array.cpte = pte_offset(pmd, address);
address744fs/proc/array.caddress &= ~PMD_MASK;
address745fs/proc/array.cend = address + size;
address751fs/proc/array.caddress += PAGE_SIZE;
address765fs/proc/array.c} while (address < end);
address768fs/proc/array.cstatic inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
address781fs/proc/array.cpmd = pmd_offset(pgd, address);
address782fs/proc/array.caddress &= ~PGDIR_MASK;
address783fs/proc/array.cend = address + size;
address787fs/proc/array.cstatm_pte_range(pmd, address, end - address, pages, shared, dirty, total);
address788fs/proc/array.caddress = (address + PMD_SIZE) & PMD_MASK;
address790fs/proc/array.c} while (address < end);
address793fs/proc/array.cstatic void statm_pgd_range(pgd_t * pgd, unsigned long address, unsigned long end,
address796fs/proc/array.cwhile (address < end) {
address797fs/proc/array.cstatm_pmd_range(pgd, address, end - address, pages, shared, dirty, total);
address798fs/proc/array.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address28fs/smbfs/mmap.cunsigned long address, int no_share)
address41fs/smbfs/mmap.caddress &= PAGE_MASK;
address42fs/smbfs/mmap.cpos = address - area->vm_start + area->vm_offset;
address45fs/smbfs/mmap.cif (address + PAGE_SIZE > area->vm_end) {
address46fs/smbfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
address180include/asm-alpha/alcor.hextern inline unsigned long virt_to_bus(void * address)
address182include/asm-alpha/alcor.hreturn virt_to_phys(address) + ALCOR_DMA_WIN_BASE;
address185include/asm-alpha/alcor.hextern inline void * bus_to_virt(unsigned long address)
address187include/asm-alpha/alcor.hreturn phys_to_virt(address - ALCOR_DMA_WIN_BASE);
address217include/asm-alpha/apecs.hextern inline unsigned long virt_to_bus(void * address)
address219include/asm-alpha/apecs.hunsigned long paddr = virt_to_phys(address);
address230include/asm-alpha/apecs.hextern inline void * bus_to_virt(unsigned long address)
address239include/asm-alpha/apecs.hif (address < APECS_XL_DMA_WIN1_BASE)
address241include/asm-alpha/apecs.helse if (address < (APECS_XL_DMA_WIN1_BASE + APECS_XL_DMA_WIN1_SIZE))
address242include/asm-alpha/apecs.hreturn phys_to_virt(address - APECS_XL_DMA_WIN1_BASE);
address244include/asm-alpha/apecs.hreturn phys_to_virt(address - APECS_XL_DMA_WIN2_BASE);
address246include/asm-alpha/apecs.hif (address < APECS_DMA_WIN_BASE)
address248include/asm-alpha/apecs.hreturn phys_to_virt(address - APECS_DMA_WIN_BASE);
address84include/asm-alpha/hwrpb.hunsigned long address;
address47include/asm-alpha/io.hextern inline unsigned long virt_to_phys(volatile void * address)
address49include/asm-alpha/io.hreturn 0xffffffffUL & (unsigned long) address;
address52include/asm-alpha/io.hextern inline void * phys_to_virt(unsigned long address)
address54include/asm-alpha/io.hreturn (void *) (address + IDENT_ADDR);
address139include/asm-alpha/lca.hextern inline unsigned long virt_to_bus(void * address)
address141include/asm-alpha/lca.hreturn virt_to_phys(address) + LCA_DMA_WIN_BASE;
address144include/asm-alpha/lca.hextern inline void * bus_to_virt(unsigned long address)
address152include/asm-alpha/lca.hif (address < LCA_DMA_WIN_BASE)
address154include/asm-alpha/lca.hreturn phys_to_virt(address - LCA_DMA_WIN_BASE);
address266include/asm-alpha/pgtable.h#define PAGE_PTR(address)    \
address267include/asm-alpha/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address347include/asm-alpha/pgtable.h#define PAGE_DIR_OFFSET(tsk,address) pgd_offset((tsk),(address))
address350include/asm-alpha/pgtable.hextern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
address352include/asm-alpha/pgtable.hreturn mm->pgd + ((address >> PGDIR_SHIFT) & (PTRS_PER_PAGE - 1));
address356include/asm-alpha/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address358include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*dir) + ((address >> PMD_SHIFT) & (PTRS_PER_PAGE - 1));
address362include/asm-alpha/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address364include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PAGE - 1));
address377include/asm-alpha/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address379include/asm-alpha/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address385include/asm-alpha/pgtable.hreturn page + address;
address397include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address405include/asm-alpha/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address407include/asm-alpha/pgtable.haddress = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
address413include/asm-alpha/pgtable.hreturn page + address;
address425include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*pgd) + address;
address433include/asm-alpha/pgtable.hextern inline pte_t * pte_alloc(pmd_t *pmd, unsigned long address)
address435include/asm-alpha/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address441include/asm-alpha/pgtable.hreturn page + address;
address453include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address461include/asm-alpha/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t *pgd, unsigned long address)
address463include/asm-alpha/pgtable.haddress = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
address469include/asm-alpha/pgtable.hreturn page + address;
address481include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*pgd) + address;
address501include/asm-alpha/pgtable.hunsigned long address, pte_t pte)
address46include/asm-i386/io.hextern inline unsigned long virt_to_phys(volatile void * address)
address48include/asm-i386/io.hreturn (unsigned long) address;
address51include/asm-i386/io.hextern inline void * phys_to_virt(unsigned long address)
address53include/asm-i386/io.hreturn (void *) address;
address285include/asm-i386/pgtable.h#define PAGE_PTR(address) \
address286include/asm-i386/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address353include/asm-i386/pgtable.hextern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
address355include/asm-i386/pgtable.hreturn mm->pgd + (address >> PGDIR_SHIFT);
address359include/asm-i386/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address365include/asm-i386/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address367include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
address380include/asm-i386/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
address382include/asm-i386/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address388include/asm-i386/pgtable.hreturn page + address;
address400include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address412include/asm-i386/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
address422include/asm-i386/pgtable.hextern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
address424include/asm-i386/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address430include/asm-i386/pgtable.hreturn page + address;
address442include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address454include/asm-i386/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
address476include/asm-i386/pgtable.hunsigned long address, pte_t pte)
address53include/asm-mips/io.hextern inline unsigned long virt_to_phys(volatile void * address)
address55include/asm-mips/io.hreturn (unsigned long) address - KSEG0;
address58include/asm-mips/io.hextern inline void * phys_to_virt(unsigned long address)
address60include/asm-mips/io.hreturn (void *) address + KSEG0;
address193include/asm-mips/pgtable.h#define PAGE_PTR(address) \
address194include/asm-mips/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address344include/asm-mips/pgtable.hextern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
address346include/asm-mips/pgtable.hreturn mm->pgd + (address >> PGDIR_SHIFT);
address350include/asm-mips/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address356include/asm-mips/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address359include/asm-mips/pgtable.h((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
address378include/asm-mips/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address380include/asm-mips/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address391include/asm-mips/pgtable.hreturn ((pte_t *)page) + address;
address403include/asm-mips/pgtable.hreturn (pte_t *) (pmd_page(*pmd) + (PT_OFFSET - PAGE_OFFSET)) + address;
address414include/asm-mips/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
address429include/asm-mips/pgtable.hextern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
address431include/asm-mips/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address441include/asm-mips/pgtable.hreturn ((pte_t *)page) + address;
address453include/asm-mips/pgtable.hreturn (pte_t *) (pmd_page(*pmd) + (PT_OFFSET - PAGE_OFFSET)) + address;
address464include/asm-mips/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
address552include/asm-mips/pgtable.hunsigned long address, pte_t pte);
address22include/asm-ppc/io.hextern inline unsigned long virt_to_bus(volatile void * address)
address24include/asm-ppc/io.hif (address == (void *)0) return 0;
address25include/asm-ppc/io.hreturn ((unsigned long)((long)address - KERNELBASE + PCI_DRAM_OFFSET));
address28include/asm-ppc/io.hextern inline void * bus_to_virt(unsigned long address)
address30include/asm-ppc/io.hif (address == 0) return 0;
address31include/asm-ppc/io.hreturn ((void *)(address - PCI_DRAM_OFFSET + KERNELBASE));
address53include/asm-ppc/io.hextern inline unsigned long virt_to_phys(volatile void * address)
address55include/asm-ppc/io.hreturn (unsigned long) address;
address58include/asm-ppc/io.hextern inline void * phys_to_virt(unsigned long address)
address60include/asm-ppc/io.hreturn (void *) address;
address183include/asm-ppc/pgtable.h#define PAGE_PTR(address) \
address184include/asm-ppc/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address288include/asm-ppc/pgtable.hextern inline pgd_t * pgd_offset(struct mm_struct * mm, unsigned long address)
address290include/asm-ppc/pgtable.hreturn mm->pgd + (address >> PGDIR_SHIFT);
address294include/asm-ppc/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address300include/asm-ppc/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address302include/asm-ppc/pgtable.hreturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
address385include/asm-ppc/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
address387include/asm-ppc/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address395include/asm-ppc/pgtable.hreturn page + address;
address409include/asm-ppc/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address420include/asm-ppc/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
address430include/asm-ppc/pgtable.hextern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
address432include/asm-ppc/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address438include/asm-ppc/pgtable.hreturn page + address;
address450include/asm-ppc/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address461include/asm-ppc/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
address484include/asm-ppc/pgtable.hunsigned long address, pte_t _pte)
address487include/asm-ppc/pgtable.hprintk("Update MMU cache - VMA: %x, Addr: %x, PTE: %x\n", vma, address, *(long *)&_pte);
address488include/asm-ppc/pgtable.h_printk("Update MMU cache - VMA: %x, Addr: %x, PTE: %x\n", vma, address, *(long *)&_pte);
address491include/asm-ppc/pgtable.hMMU_hash_page(&(current)->tss, address & PAGE_MASK, (pte *)&_pte);
address152include/asm-sparc/pgtable.h#define PAGE_PTR(address) \
address153include/asm-sparc/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address249include/asm-sparc/pgtable.hextern void (*invalidate_page)(struct vm_area_struct *, unsigned long address);
address269include/asm-sparc/pgtable.hextern void (*update_mmu_cache)(struct vm_area_struct *vma, unsigned long address, pte_t pte);
address53include/linux/atalk.hstruct at_addr address;    /* Our address */
address183include/linux/cdu31a.hunsigned char address        :4;
address218include/linux/cdu31a.hunsigned char address     :4;
address278include/linux/cdu31a.hunsigned char address     :4;
address250include/linux/fd.hint address;    /* io address */
address11include/linux/fdreg.h#define FD_IOPORT fdc_state[fdc].address
address102include/linux/mm.hunsigned long (*nopage)(struct vm_area_struct * area, unsigned long address, int write_access);
address103include/linux/mm.hunsigned long (*wppage)(struct vm_area_struct * area, unsigned long address,
address253include/linux/mm.hunsigned long address);
address260include/linux/mm.hextern int zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size);
address266include/linux/mm.hextern void handle_mm_fault(struct vm_area_struct *vma, unsigned long address, int write_access);
address267include/linux/mm.hextern void do_wp_page(struct task_struct * tsk, struct vm_area_struct * vma, unsigned long address, int write_access);
address268include/linux/mm.hextern void do_no_page(struct task_struct * tsk, struct vm_area_struct * vma, unsigned long address, int write_access);
address315include/linux/mm.hstatic inline int expand_stack(struct vm_area_struct * vma, unsigned long address)
address319include/linux/mm.haddress &= PAGE_MASK;
address320include/linux/mm.hif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address322include/linux/mm.hgrow = vma->vm_start - address;
address323include/linux/mm.hvma->vm_start = address;
address133include/linux/socket.hextern int verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode);
address136include/linux/sonycd535.hunsigned char address        :4;
address102include/linux/xd.hvoid (*init_controller)(u_char *address);
address108include/linux/xd.hstatic u_char xd_detect (u_char *controller,u_char **address);
address127include/linux/xd.hstatic void xd_dtc_init_controller (u_char *address);
address129include/linux/xd.hstatic void xd_wd_init_controller (u_char *address);
address131include/linux/xd.hstatic void xd_seagate_init_controller (u_char *address);
address133include/linux/xd.hstatic void xd_omti_init_controller (u_char *address);
address739mm/filemap.cstatic unsigned long filemap_nopage(struct vm_area_struct * area, unsigned long address, int no_share)
address745mm/filemap.coffset = (address & PAGE_MASK) - area->vm_start + area->vm_offset;
address873mm/filemap.cunsigned long address, unsigned int flags)
address884mm/filemap.cflush_cache_page(vma, address);
address886mm/filemap.cflush_tlb_page(vma, address);
address892mm/filemap.cflush_cache_page(vma, address);
address894mm/filemap.cflush_tlb_page(vma, address);
address905mm/filemap.cerror = filemap_write_page(vma, address - vma->vm_start + vma->vm_offset, page);
address911mm/filemap.cunsigned long address, unsigned long size, 
address925mm/filemap.cpte = pte_offset(pmd, address);
address926mm/filemap.coffset += address & PMD_MASK;
address927mm/filemap.caddress &= ~PMD_MASK;
address928mm/filemap.cend = address + size;
address933mm/filemap.cerror |= filemap_sync_pte(pte, vma, address + offset, flags);
address934mm/filemap.caddress += PAGE_SIZE;
address936mm/filemap.c} while (address < end);
address941mm/filemap.cunsigned long address, unsigned long size, 
address955mm/filemap.cpmd = pmd_offset(pgd, address);
address956mm/filemap.coffset = address & PGDIR_MASK;
address957mm/filemap.caddress &= ~PGDIR_MASK;
address958mm/filemap.cend = address + size;
address963mm/filemap.cerror |= filemap_sync_pte_range(pmd, address, end - address, vma, offset, flags);
address964mm/filemap.caddress = (address + PMD_SIZE) & PMD_MASK;
address966mm/filemap.c} while (address < end);
address970mm/filemap.cstatic int filemap_sync(struct vm_area_struct * vma, unsigned long address,
address974mm/filemap.cunsigned long end = address + size;
address977mm/filemap.cdir = pgd_offset(current->mm, address);
address979mm/filemap.cwhile (address < end) {
address980mm/filemap.cerror |= filemap_sync_pmd_range(dir, address, end - address, vma, flags);
address981mm/filemap.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address211mm/memory.cstatic inline int copy_pte_range(pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long address, unsigned long size, int cow)
address223mm/memory.csrc_pte = pte_offset(src_pmd, address);
address228mm/memory.cdst_pte = pte_offset(dst_pmd, address);
address229mm/memory.caddress &= ~PMD_MASK;
address230mm/memory.cend = address + size;
address238mm/memory.caddress += PAGE_SIZE;
address239mm/memory.c} while (address < end);
address243mm/memory.cstatic inline int copy_pmd_range(pgd_t *dst_pgd, pgd_t *src_pgd, unsigned long address, unsigned long size, int cow)
address256mm/memory.csrc_pmd = pmd_offset(src_pgd, address);
address261mm/memory.cdst_pmd = pmd_offset(dst_pgd, address);
address262mm/memory.caddress &= ~PGDIR_MASK;
address263mm/memory.cend = address + size;
address267mm/memory.cerror = copy_pte_range(dst_pmd++, src_pmd++, address, end - address, cow);
address270mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK; 
address271mm/memory.c} while (address < end);
address284mm/memory.cunsigned long address = vma->vm_start;
address289mm/memory.csrc_pgd = pgd_offset(src, address);
address290mm/memory.cdst_pgd = pgd_offset(dst, address);
address293mm/memory.cwhile (address < end) {
address294mm/memory.cerror = copy_pmd_range(dst_pgd++, src_pgd++, address, end - address, cow);
address297mm/memory.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address322mm/memory.cstatic inline void zap_pte_range(pmd_t * pmd, unsigned long address, unsigned long size)
address334mm/memory.cpte = pte_offset(pmd, address);
address335mm/memory.caddress &= ~PMD_MASK;
address336mm/memory.cend = address + size;
address343mm/memory.caddress += PAGE_SIZE;
address345mm/memory.c} while (address < end);
address348mm/memory.cstatic inline void zap_pmd_range(pgd_t * dir, unsigned long address, unsigned long size)
address360mm/memory.cpmd = pmd_offset(dir, address);
address361mm/memory.caddress &= ~PGDIR_MASK;
address362mm/memory.cend = address + size;
address366mm/memory.czap_pte_range(pmd, address, end - address);
address367mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK; 
address369mm/memory.c} while (address < end);
address375mm/memory.cint zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size)
address378mm/memory.cunsigned long end = address + size;
address380mm/memory.cdir = pgd_offset(mm, address);
address382mm/memory.cwhile (address < end) {
address383mm/memory.czap_pmd_range(dir, address, end - address);
address384mm/memory.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address391mm/memory.cstatic inline void zeromap_pte_range(pte_t * pte, unsigned long address, unsigned long size, pte_t zero_pte)
address395mm/memory.caddress &= ~PMD_MASK;
address396mm/memory.cend = address + size;
address403mm/memory.caddress += PAGE_SIZE;
address405mm/memory.c} while (address < end);
address408mm/memory.cstatic inline int zeromap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size, pte_t zero_pte)
address412mm/memory.caddress &= ~PGDIR_MASK;
address413mm/memory.cend = address + size;
address417mm/memory.cpte_t * pte = pte_alloc(pmd, address);
address420mm/memory.czeromap_pte_range(pte, address, end - address, zero_pte);
address421mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK;
address423mm/memory.c} while (address < end);
address427mm/memory.cint zeromap_page_range(unsigned long address, unsigned long size, pgprot_t prot)
address431mm/memory.cunsigned long beg = address;
address432mm/memory.cunsigned long end = address + size;
address436mm/memory.cdir = pgd_offset(current->mm, address);
address438mm/memory.cwhile (address < end) {
address439mm/memory.cpmd_t *pmd = pmd_alloc(dir, address);
address443mm/memory.cerror = zeromap_pmd_range(pmd, address, end - address, zero_pte);
address446mm/memory.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address458mm/memory.cstatic inline void remap_pte_range(pte_t * pte, unsigned long address, unsigned long size,
address463mm/memory.caddress &= ~PMD_MASK;
address464mm/memory.cend = address + size;
address473mm/memory.caddress += PAGE_SIZE;
address476mm/memory.c} while (address < end);
address479mm/memory.cstatic inline int remap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size,
address484mm/memory.caddress &= ~PGDIR_MASK;
address485mm/memory.cend = address + size;
address488mm/memory.coffset -= address;
address490mm/memory.cpte_t * pte = pte_alloc(pmd, address);
address493mm/memory.cremap_pte_range(pte, address, end - address, address + offset, prot);
address494mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK;
address496mm/memory.c} while (address < end);
address543mm/memory.cunsigned long put_dirty_page(struct task_struct * tsk, unsigned long page, unsigned long address)
address550mm/memory.cprintk("put_dirty_page: trying to put page %08lx at %08lx\n",page,address);
address552mm/memory.cprintk("mem_map disagrees with %08lx at %08lx\n",page,address);
address553mm/memory.cpgd = pgd_offset(tsk->mm,address);
address554mm/memory.cpmd = pmd_alloc(pgd, address);
address560mm/memory.cpte = pte_alloc(pmd, address);
address594mm/memory.cunsigned long address, int write_access)
address602mm/memory.cpage_dir = pgd_offset(vma->vm_mm, address);
address607mm/memory.cpage_middle = pmd_offset(page_dir, address);
address612mm/memory.cpage_table = pte_offset(page_middle, address);
address632mm/memory.cflush_cache_page(vma, address);
address635mm/memory.cflush_tlb_page(vma, address);
address638mm/memory.cflush_cache_page(vma, address);
address640mm/memory.cflush_tlb_page(vma, address);
address645mm/memory.cflush_cache_page(vma, address);
address647mm/memory.cflush_tlb_page(vma, address);
address652mm/memory.cprintk("do_wp_page: bogus page at address %08lx (%08lx)\n",address,old_page);
address656mm/memory.cprintk("do_wp_page: bogus page-middle at address %08lx (%08lx)\n", address, pmd_val(*page_middle));
address660mm/memory.cprintk("do_wp_page: bogus page-dir entry at address %08lx (%08lx)\n", address, pgd_val(*page_dir));
address774mm/memory.cstatic void partial_clear(struct vm_area_struct *vma, unsigned long address)
address780mm/memory.cpage_dir = pgd_offset(vma->vm_mm, address);
address788mm/memory.cpage_middle = pmd_offset(page_dir, address);
address796mm/memory.cpage_table = pte_offset(page_middle, address);
address800mm/memory.caddress &= ~PAGE_MASK;
address801mm/memory.caddress += pte_page(pte);
address802mm/memory.cif (address >= high_memory)
address804mm/memory.cmemset((void *) address, 0, PAGE_SIZE - (address & ~PAGE_MASK));
address851mm/memory.cstatic inline pte_t * get_empty_pgtable(struct task_struct * tsk,unsigned long address)
address857mm/memory.cpgd = pgd_offset(tsk->mm, address);
address858mm/memory.cpmd = pmd_alloc(pgd, address);
address863mm/memory.cpte = pte_alloc(pmd, address);
address872mm/memory.cstruct vm_area_struct * vma, unsigned long address,
address881mm/memory.cpage = vma->vm_ops->swapin(vma, address - vma->vm_start + vma->vm_offset, pte_val(entry));
address901mm/memory.cunsigned long address, int write_access)
address907mm/memory.cpage_table = get_empty_pgtable(tsk, address);
address914mm/memory.cdo_swap_page(tsk, vma, address, page_table, entry, write_access);
address917mm/memory.caddress &= PAGE_MASK;
address919mm/memory.cflush_cache_page(vma, address);
address930mm/memory.cpage = vma->vm_ops->nopage(vma, address, write_access && !(vma->vm_flags & VM_SHARED));
address933mm/memory.cflush_cache_page(vma, address);
address935mm/memory.cflush_tlb_page(vma, address);
address953mm/memory.cflush_cache_page(vma, address);
address955mm/memory.cflush_tlb_page(vma, address);
address971mm/memory.cstatic inline void handle_pte_fault(struct vm_area_struct * vma, unsigned long address,
address975mm/memory.cdo_no_page(current, vma, address, write_access);
address985mm/memory.cdo_wp_page(current, vma, address, write_access);
address988mm/memory.cvoid handle_mm_fault(struct vm_area_struct * vma, unsigned long address,
address995mm/memory.cpgd = pgd_offset(vma->vm_mm, address);
address996mm/memory.cpmd = pmd_alloc(pgd, address);
address999mm/memory.cpte = pte_alloc(pmd, address);
address1002mm/memory.chandle_pte_fault(vma, address, write_access, pte);
address1003mm/memory.cupdate_mmu_cache(vma, address, *pte);
address20mm/mprotect.cstatic inline void change_pte_range(pmd_t * pmd, unsigned long address,
address33mm/mprotect.cpte = pte_offset(pmd, address);
address34mm/mprotect.caddress &= ~PMD_MASK;
address35mm/mprotect.cend = address + size;
address42mm/mprotect.caddress += PAGE_SIZE;
address44mm/mprotect.c} while (address < end);
address47mm/mprotect.cstatic inline void change_pmd_range(pgd_t * pgd, unsigned long address,
address60mm/mprotect.cpmd = pmd_offset(pgd, address);
address61mm/mprotect.caddress &= ~PGDIR_MASK;
address62mm/mprotect.cend = address + size;
address66mm/mprotect.cchange_pte_range(pmd, address, end - address, newprot);
address67mm/mprotect.caddress = (address + PMD_SIZE) & PMD_MASK;
address69mm/mprotect.c} while (address < end);
address163mm/swapfile.cstatic inline int unuse_pte(struct vm_area_struct * vma, unsigned long address,
address196mm/swapfile.cunsigned long address, unsigned long size, unsigned long offset,
address209mm/swapfile.cpte = pte_offset(dir, address);
address210mm/swapfile.coffset += address & PMD_MASK;
address211mm/swapfile.caddress &= ~PMD_MASK;
address212mm/swapfile.cend = address + size;
address216mm/swapfile.cif (unuse_pte(vma, offset+address-vma->vm_start, pte, type, page))
address218mm/swapfile.caddress += PAGE_SIZE;
address220mm/swapfile.c} while (address < end);
address225mm/swapfile.cunsigned long address, unsigned long size,
address238mm/swapfile.cpmd = pmd_offset(dir, address);
address239mm/swapfile.coffset = address & PGDIR_MASK;
address240mm/swapfile.caddress &= ~PGDIR_MASK;
address241mm/swapfile.cend = address + size;
address245mm/swapfile.cif (unuse_pmd(vma, pmd, address, end - address, offset, type, page))
address247mm/swapfile.caddress = (address + PMD_SIZE) & PMD_MASK;
address249mm/swapfile.c} while (address < end);
address30mm/vmalloc.cstatic inline void set_pgdir(unsigned long address, pgd_t entry)
address37mm/vmalloc.c*pgd_offset(p->mm,address) = entry;
address41mm/vmalloc.cstatic inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)
address53mm/vmalloc.cpte = pte_offset(pmd, address);
address54mm/vmalloc.caddress &= ~PMD_MASK;
address55mm/vmalloc.cend = address + size;
address58mm/vmalloc.cwhile (address < end) {
address61mm/vmalloc.caddress += PAGE_SIZE;
address73mm/vmalloc.cstatic inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)
address85mm/vmalloc.cpmd = pmd_offset(dir, address);
address86mm/vmalloc.caddress &= ~PGDIR_MASK;
address87mm/vmalloc.cend = address + size;
address90mm/vmalloc.cwhile (address < end) {
address91mm/vmalloc.cfree_area_pte(pmd, address, end - address);
address92mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address97mm/vmalloc.cstatic void free_area_pages(unsigned long address, unsigned long size)
address100mm/vmalloc.cunsigned long end = address + size;
address102mm/vmalloc.cdir = pgd_offset(&init_mm, address);
address104mm/vmalloc.cwhile (address < end) {
address105mm/vmalloc.cfree_area_pmd(dir, address, end - address);
address106mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address112mm/vmalloc.cstatic inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)
address116mm/vmalloc.caddress &= ~PMD_MASK;
address117mm/vmalloc.cend = address + size;
address120mm/vmalloc.cwhile (address < end) {
address128mm/vmalloc.caddress += PAGE_SIZE;
address134mm/vmalloc.cstatic inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)
address138mm/vmalloc.caddress &= ~PGDIR_MASK;
address139mm/vmalloc.cend = address + size;
address142mm/vmalloc.cwhile (address < end) {
address143mm/vmalloc.cpte_t * pte = pte_alloc_kernel(pmd, address);
address146mm/vmalloc.cif (alloc_area_pte(pte, address, end - address))
address148mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address154mm/vmalloc.cstatic int alloc_area_pages(unsigned long address, unsigned long size)
address157mm/vmalloc.cunsigned long end = address + size;
address159mm/vmalloc.cdir = pgd_offset(&init_mm, address);
address161mm/vmalloc.cwhile (address < end) {
address162mm/vmalloc.cpmd_t *pmd = pmd_alloc_kernel(dir, address);
address165mm/vmalloc.cif (alloc_area_pmd(pmd, address, end - address))
address167mm/vmalloc.cset_pgdir(address, *dir);
address168mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address175mm/vmalloc.cstatic inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
address180mm/vmalloc.caddress &= ~PMD_MASK;
address181mm/vmalloc.cend = address + size;
address188mm/vmalloc.caddress += PAGE_SIZE;
address191mm/vmalloc.c} while (address < end);
address194mm/vmalloc.cstatic inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
address199mm/vmalloc.caddress &= ~PGDIR_MASK;
address200mm/vmalloc.cend = address + size;
address203mm/vmalloc.coffset -= address;
address205mm/vmalloc.cpte_t * pte = pte_alloc_kernel(pmd, address);
address208mm/vmalloc.cremap_area_pte(pte, address, end - address, address + offset);
address209mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address211mm/vmalloc.c} while (address < end);
address215mm/vmalloc.cstatic int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)
address218mm/vmalloc.cunsigned long end = address + size;
address220mm/vmalloc.coffset -= address;
address221mm/vmalloc.cdir = pgd_offset(&init_mm, address);
address223mm/vmalloc.cwhile (address < end) {
address224mm/vmalloc.cpmd_t *pmd = pmd_alloc_kernel(dir, address);
address227mm/vmalloc.cif (remap_area_pmd(pmd, address, end - address, offset + address))
address229mm/vmalloc.cset_pgdir(address, *dir);
address230mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address71mm/vmscan.cunsigned long address, pte_t * page_table, int dma, int wait)
address106mm/vmscan.cif (vma->vm_ops->swapout(vma, address - vma->vm_start + vma->vm_offset, page_table))
address114mm/vmscan.cflush_cache_page(vma, address);
address116mm/vmscan.cflush_tlb_page(vma, address);
address130mm/vmscan.cflush_cache_page(vma, address);
address132mm/vmscan.cflush_tlb_page(vma, address);
address137mm/vmscan.cflush_cache_page(vma, address);
address139mm/vmscan.cflush_tlb_page(vma, address);
address160mm/vmscan.cpmd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
address173mm/vmscan.cpte = pte_offset(dir, address);
address175mm/vmscan.cpmd_end = (address + PMD_SIZE) & PMD_MASK;
address181mm/vmscan.ctsk->swap_address = address + PAGE_SIZE;
address182mm/vmscan.cresult = try_to_swap_out(tsk, vma, address, pte, dma, wait);
address185mm/vmscan.caddress += PAGE_SIZE;
address187mm/vmscan.c} while (address < end);
address192mm/vmscan.cpgd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
address205mm/vmscan.cpmd = pmd_offset(dir, address);
address207mm/vmscan.cpgd_end = (address + PGDIR_SIZE) & PGDIR_MASK;  
address212mm/vmscan.cint result = swap_out_pmd(tsk, vma, pmd, address, end, dma, wait);
address215mm/vmscan.caddress = (address + PMD_SIZE) & PMD_MASK;
address217mm/vmscan.c} while (address < end);
address244mm/vmscan.cunsigned long address;
address250mm/vmscan.caddress = p->swap_address;
address256mm/vmscan.cvma = find_vma(p, address);
address259mm/vmscan.cif (address < vma->vm_start)
address260mm/vmscan.caddress = vma->vm_start;
address263mm/vmscan.cint result = swap_out_vma(p, vma, pgd_offset(p->mm, address), address, dma, wait);
address269mm/vmscan.caddress = vma->vm_start;
address714net/appletalk/aarp.cif(ifa->address.s_node==ea->pa_dst_node && ifa->address.s_net==ea->pa_dst_net)
address761net/appletalk/aarp.cma=&ifa->address;
address148net/appletalk/ddp.cs->protinfo.af_at.src_net == atif->address.s_net ) 
address336net/appletalk/ddp.ciface->address= *sa;
address354net/appletalk/ddp.cint probe_net=ntohs(atif->address.s_net);
address355net/appletalk/ddp.cint probe_node=atif->address.s_node;
address379net/appletalk/ddp.catif->address.s_net=htons(sa->sat_addr.s_net);
address380net/appletalk/ddp.catif->address.s_node=sa->sat_addr.s_node;
address417net/appletalk/ddp.catif->address.s_net=htons(probe_net);
address420net/appletalk/ddp.catif->address.s_node=((nodect+probe_node)&0xFF);
address421net/appletalk/ddp.cif(atif->address.s_node>0&&atif->address.s_node<254)
address428net/appletalk/ddp.caarp_send_probe(atif->dev, &atif->address);
address455net/appletalk/ddp.creturn &iface->address;
address464net/appletalk/ddp.creturn &iface->address;
address466net/appletalk/ddp.creturn &atalk_iface_list->address;
address497net/appletalk/ddp.cif ( node == ATADDR_BCAST || iface->address.s_node == node ) 
address512net/appletalk/ddp.cif((node==ATADDR_BCAST || iface->address.s_node==node) 
address513net/appletalk/ddp.c&& iface->address.s_net==net && !(iface->status&ATIF_PROBE))
address627net/appletalk/ddp.cif ( ga->sat_addr.s_net == iface->address.s_net && ga->sat_addr.s_node == iface->address.s_node )
address783net/appletalk/ddp.catif->address.s_net=sa->sat_addr.s_net;
address784net/appletalk/ddp.catif->address.s_node=sa->sat_addr.s_node;
address811net/appletalk/ddp.csa->sat_addr.s_net=atif->address.s_net;
address812net/appletalk/ddp.csa->sat_addr.s_node=atif->address.s_node;
address824net/appletalk/ddp.csa->sat_addr.s_net=atif->address.s_net;
address848net/appletalk/ddp.c((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr=atif->address;
address854net/appletalk/ddp.c((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_net=atif->address.s_net;
address903net/appletalk/ddp.cntohs(iface->address.s_net),iface->address.s_node,
address28net/core/iovec.cint verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode)
address37net/core/iovec.cerr=move_addr_to_kernel(m->msg_name, m->msg_namelen, address);
address38net/core/iovec.cm->msg_name = address;
address238net/ipv4/igmp.cstatic void igmp_send_report(struct device *dev, unsigned long address, int type)
address246net/ipv4/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
address257net/ipv4/igmp.cih->group=address;
address287net/ipv4/igmp.cstatic void igmp_heard_report(struct device *dev, unsigned long address)
address291net/ipv4/igmp.cif ((address & IGMP_LOCAL_GROUP_MASK) != IGMP_LOCAL_GROUP) {
address294net/ipv4/igmp.cif(im->multiaddr==address && im->tm_running) {
address677net/socket.cchar address[MAX_SOCK_ADDR];
address686net/socket.cif((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)
address689net/socket.cif ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0) 
address739net/socket.cchar address[MAX_SOCK_ADDR];
address785net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
address786net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
address802net/socket.cchar address[MAX_SOCK_ADDR];
address810net/socket.cif((err=move_addr_to_kernel(uservaddr,addrlen,address))<0)
address835net/socket.ci = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);
address851net/socket.cchar address[MAX_SOCK_ADDR];
address860net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
address863net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address876net/socket.cchar address[MAX_SOCK_ADDR];
address885net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
address888net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address937net/socket.cchar address[MAX_SOCK_ADDR];
address953net/socket.cif((err=move_addr_to_kernel(addr,addr_len,address))<0)
address958net/socket.cmsg.msg_name=address;
address1017net/socket.cchar address[MAX_SOCK_ADDR];
address1038net/socket.cmsg.msg_name=address;
address1045net/socket.cif(addr!=NULL && (err=move_addr_to_user(address,alen, addr, addr_len))<0)
address1115net/socket.cchar address[MAX_SOCK_ADDR];
address1140net/socket.cerr=verify_iovec(&msg_sys,iov,address, VERIFY_READ);
address1156net/socket.cchar address[MAX_SOCK_ADDR];
address1175net/socket.cerr=verify_iovec(&msg_sys,iov,address, VERIFY_WRITE);
address1188net/socket.cif(msg_sys.msg_name!=NULL && (err=move_addr_to_user(address,addr_len, msg_sys.msg_name, &msg_sys.msg_namelen))<0)
address110scripts/ksymoops.ccKSym* find(long address);
address118scripts/ksymoops.ccNameList::find(long address)
address124scripts/ksymoops.ccif (address < start->address_ || address >= end->address_)
address130scripts/ksymoops.ccif (mid->address_ < address)
address132scripts/ksymoops.ccelse if (mid->address_ > address)
address137scripts/ksymoops.ccwhile (mid->address_ > address)
address139scripts/ksymoops.ccmid->offset_ = address - mid->address_;
address295scripts/ksymoops.cclong address;
address297scripts/ksymoops.cc(sscanf(buffer, " [<%x>]", &address) == 1) &&
address298scripts/ksymoops.ccaddress > 0xc) {
address300scripts/ksymoops.ccKSym* ksym = names.find(address);
address304scripts/ksymoops.cccout << ::hex << address;