taglinefilesource code
address46arch/alpha/boot/main.cunsigned long address = (unsigned long) pcb;
address49arch/alpha/boot/main.cresult = vptb[address >> 13];
address52arch/alpha/boot/main.cresult |= address & 0x1fff;
address45arch/alpha/mm/fault.casmlinkage void do_page_fault(unsigned long address, unsigned long mmcsr, long cause,
address51arch/alpha/mm/fault.cvma = find_vma(current, address);
address54arch/alpha/mm/fault.cif (vma->vm_start <= address)
address58arch/alpha/mm/fault.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address60arch/alpha/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address61arch/alpha/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address78arch/alpha/mm/fault.ctbis(address);
address79arch/alpha/mm/fault.chandle_mm_fault(vma, address, cause > 0);
address88arch/alpha/mm/fault.cprintk("memory violation at pc=%08lx (%08lx)\n", regs.pc, address);
address97arch/alpha/mm/fault.cprintk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\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;
address435arch/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 ;
address38arch/i386/mm/fault.cunsigned long address;
address42arch/i386/mm/fault.c__asm__("movl %%cr2,%0":"=r" (address));
address43arch/i386/mm/fault.cvma = find_vma(current, address);
address46arch/i386/mm/fault.cif (vma->vm_start <= address)
address50arch/i386/mm/fault.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address52arch/i386/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address53arch/i386/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address76arch/i386/mm/fault.cunsigned long bit = (address - 0xA0000) >> PAGE_SHIFT;
address85arch/i386/mm/fault.cdo_wp_page(vma, address, error_code & 2);
address88arch/i386/mm/fault.cdo_no_page(vma, address, error_code & 2);
address97arch/i386/mm/fault.ccurrent->tss.cr2 = address;
address109arch/i386/mm/fault.cif (wp_works_ok < 0 && address == TASK_SIZE && (error_code & 1)) {
address116arch/i386/mm/fault.cif ((unsigned long) (address-TASK_SIZE) < PAGE_SIZE) {
address121arch/i386/mm/fault.cprintk(" at virtual address %08lx\n",address);
address125arch/i386/mm/fault.cpage = ((unsigned long *) page)[address >> 22];
address129arch/i386/mm/fault.caddress &= 0x003ff000;
address130arch/i386/mm/fault.cpage = ((unsigned long *) page)[address >> PAGE_SHIFT];
address107arch/i386/mm/init.cunsigned long address;
address122arch/i386/mm/init.caddress = 0;
address124arch/i386/mm/init.cwhile (address < end_mem) {
address126arch/i386/mm/init.cif (address <= end_mem + 4*1024*1024 &&
address140arch/i386/mm/init.cpgd_val(pg_dir[0]) = _PAGE_TABLE | _PAGE_4M | address;
address141arch/i386/mm/init.cpgd_val(pg_dir[768]) = _PAGE_TABLE | _PAGE_4M | address;
address143arch/i386/mm/init.caddress += 4*1024*1024;
address159arch/i386/mm/init.cif (address < end_mem)
address160arch/i386/mm/init.c*pg_table = mk_pte(address, PAGE_SHARED);
address163arch/i386/mm/init.caddress += PAGE_SIZE;
address40arch/mips/mm/fault.cunsigned long address;
address45arch/mips/mm/fault.c: "=r" (address));
address50arch/mips/mm/fault.cif (vma->vm_end > address)
address53arch/mips/mm/fault.cif (vma->vm_start <= address)
address57arch/mips/mm/fault.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address59arch/mips/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address60arch/mips/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address80arch/mips/mm/fault.cdo_wp_page(vma, address, error_code & 2);
address83arch/mips/mm/fault.cdo_no_page(vma, address, error_code & 2);
address92arch/mips/mm/fault.ccurrent->tss.cp0_badvaddr = address;
address104arch/mips/mm/fault.cif ((unsigned long) (address-TASK_SIZE) < PAGE_SIZE) {
address109arch/mips/mm/fault.cprintk(" at virtual address %08lx\n",address);
address112arch/mips/mm/fault.cpage = ((unsigned long *) page)[address >> PGDIR_SHIFT];
address116arch/mips/mm/fault.caddress &= 0x003ff000;
address117arch/mips/mm/fault.cpage = ((unsigned long *) page)[address >> PAGE_SHIFT];
address148arch/mips/mm/init.cunsigned long address;
address151arch/mips/mm/init.caddress = 0;
address153arch/mips/mm/init.cwhile (address < end_mem) {
address165arch/mips/mm/init.cif (address < end_mem)
address166arch/mips/mm/init.c*pg_table = mk_pte(address, PAGE_SHARED);
address169arch/mips/mm/init.caddress += PAGE_SIZE;
address46arch/sparc/kernel/ioport.cvoid *sparc_alloc_io (void *address, void *virtual, int len, char *name,
address50arch/sparc/kernel/ioport.cunsigned long addr = (unsigned long) address;
address131arch/sparc/mm/fault.cunsigned long address;
address133arch/sparc/mm/fault.caddress = sync_vaddr;
address136arch/sparc/mm/fault.c(unsigned long) address, (unsigned long) sync_err_reg);
address141arch/sparc/mm/fault.cvma = find_vma(current, address);
address145arch/sparc/mm/fault.cif(vma->vm_start <= address)
address154arch/sparc/mm/fault.chandle_mm_fault(vma, address, 0);
address162arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
address166arch/sparc/mm/fault.cprintk(" at virtual address %08lx\n",address);
address195arch/sparc/mm/fault.cunsigned long address;
address198arch/sparc/mm/fault.caddress = sync_vaddr;
address201arch/sparc/mm/fault.c(unsigned long) address, (unsigned long) sync_err_reg);
address203arch/sparc/mm/fault.cprintk("PTE = %08lx\n", (unsigned long) get_pte(address));
address205arch/sparc/mm/fault.cvma = find_vma(current, address);
address212arch/sparc/mm/fault.cif(vma->vm_start <= address)
address218arch/sparc/mm/fault.cif(vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur) {
address222arch/sparc/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address223arch/sparc/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address263arch/sparc/mm/fault.c(unsigned long) vma, (unsigned long) address,
address266arch/sparc/mm/fault.chandle_mm_fault(vma, address, error_code);
address274arch/sparc/mm/fault.cif (wp_works_ok < 0 && address == 0x0) {
address282arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
address286arch/sparc/mm/fault.cprintk(" at virtual address %08lx\n",address);
address363arch/sparc/mm/fault.cunsigned long address;
address383arch/sparc/mm/fault.caddress = faddr;
address386arch/sparc/mm/fault.c(unsigned long) address, (unsigned long) fstatus);
address396arch/sparc/mm/fault.caddress = regs->pc;
address401arch/sparc/mm/fault.cvma = find_vma(current, address);
address405arch/sparc/mm/fault.cif(vma->vm_start <= address)
address414arch/sparc/mm/fault.cdo_no_page(vma, address, 0);
address422arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
address426arch/sparc/mm/fault.cprintk(" at virtual address %08lx\n",address);
address441arch/sparc/mm/fault.cunsigned long address, pc, psr;
address446arch/sparc/mm/fault.caddress = faddr;
address449arch/sparc/mm/fault.c(unsigned long) address, (unsigned long) fstatus);
address470arch/sparc/mm/fault.cvma = find_vma(current, address);
address477arch/sparc/mm/fault.cif(vma->vm_start <= address)
address483arch/sparc/mm/fault.cif(vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur) {
address487arch/sparc/mm/fault.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address488arch/sparc/mm/fault.cvma->vm_start = (address & PAGE_MASK);
address528arch/sparc/mm/fault.c(unsigned long) vma, (unsigned long) address,
address531arch/sparc/mm/fault.cdo_no_page(vma, address, error_code);
address539arch/sparc/mm/fault.cif (wp_works_ok < 0 && address == 0x0) {
address548arch/sparc/mm/fault.cif((unsigned long) address < PAGE_SIZE) {
address552arch/sparc/mm/fault.cprintk(" at virtual address %08lx\n",address);
address217arch/sparc/mm/srmmu.csrmmu_pgd_offset(struct task_struct * tsk, unsigned long address)
address220arch/sparc/mm/srmmu.c((address >> SRMMU_PGDIR_SHIFT) & (SRMMU_PTRS_PER_PGD - 1));
address225arch/sparc/mm/srmmu.csrmmu_pmd_offset(pgd_t * dir, unsigned long address)
address228arch/sparc/mm/srmmu.c((address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1));
address233arch/sparc/mm/srmmu.csrmmu_pte_offset(pmd_t * dir, unsigned long address)
address236arch/sparc/mm/srmmu.c((address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1));
address271arch/sparc/mm/srmmu.csrmmu_pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address275arch/sparc/mm/srmmu.caddress = (address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1);
address282arch/sparc/mm/srmmu.creturn page + address;
address294arch/sparc/mm/srmmu.creturn (pte_t *) srmmu_pmd_page(*pmd) + address;
address306arch/sparc/mm/srmmu.csrmmu_pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address310arch/sparc/mm/srmmu.caddress = (address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1);
address317arch/sparc/mm/srmmu.creturn page + address;
address329arch/sparc/mm/srmmu.creturn (pmd_t *) srmmu_pgd_page(*pgd) + address;
address339arch/sparc/mm/srmmu.csrmmu_pte_alloc(pmd_t * pmd, unsigned long address)
address343arch/sparc/mm/srmmu.caddress = (address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1);
address350arch/sparc/mm/srmmu.creturn page + address;
address362arch/sparc/mm/srmmu.creturn (pte_t *) srmmu_pmd_page(*pmd) + address;
address376arch/sparc/mm/srmmu.csrmmu_pmd_alloc(pgd_t * pgd, unsigned long address)
address380arch/sparc/mm/srmmu.caddress = (address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1);
address387arch/sparc/mm/srmmu.creturn page + address;
address399arch/sparc/mm/srmmu.creturn (pmd_t *) srmmu_pgd_page(*pgd) + address;
address207arch/sparc/mm/sun4c.csun4c_pgd_offset(struct task_struct * tsk, unsigned long address)
address210arch/sparc/mm/sun4c.c(address >> SUN4C_PGDIR_SHIFT);
address215arch/sparc/mm/sun4c.csun4c_pmd_offset(pgd_t * dir, unsigned long address)
address222arch/sparc/mm/sun4c.csun4c_pte_offset(pmd_t * dir, unsigned long address)
address224arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*dir) +  ((address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1));
address248arch/sparc/mm/sun4c.csun4c_pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address253arch/sparc/mm/sun4c.caddress = (address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1);
address261arch/sparc/mm/sun4c.creturn page + address;
address274arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*pmd) + address;
address288arch/sparc/mm/sun4c.csun4c_pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address300arch/sparc/mm/sun4c.csun4c_pte_alloc(pmd_t * pmd, unsigned long address)
address304arch/sparc/mm/sun4c.caddress = (address >> PAGE_SHIFT) & (SUN4C_PTRS_PER_PTE - 1);
address310arch/sparc/mm/sun4c.creturn page + address;
address324arch/sparc/mm/sun4c.creturn (pte_t *) sun4c_pmd_page(*pmd) + address;
address338arch/sparc/mm/sun4c.csun4c_pmd_alloc(pgd_t * pgd, unsigned long address)
address20arch/sparc/mm/vac-flush.cregister char* address;
address23arch/sparc/mm/vac-flush.caddress = (char *) 0;
address29arch/sparc/mm/vac-flush.chw_flush_vac_context_entry(address);
address30arch/sparc/mm/vac-flush.caddress += PAGE_SIZE;
address38arch/sparc/mm/vac-flush.csw_flush_vac_context_entry(address);
address39arch/sparc/mm/vac-flush.caddress += offset;
address48arch/sparc/mm/vac-flush.cregister char* address = (char *) 0;
address53arch/sparc/mm/vac-flush.c: "=r" (segment) : "0" (address));
address59arch/sparc/mm/vac-flush.chw_flush_vac_segment_entry(address);
address60arch/sparc/mm/vac-flush.caddress += PAGE_SIZE;
address68arch/sparc/mm/vac-flush.csw_flush_vac_segment_entry(address);
address69arch/sparc/mm/vac-flush.caddress += offset;
address1953drivers/block/cdu31a.cschi.cdsc_adr = last_sony_subcode.address;
address2473drivers/block/cdu31a.cloc_entry.cdte_adr = sony_toc.tracks[track_idx].address;
address707drivers/block/floppy.cif(FDCS->address == -1)
address1615drivers/block/floppy.cif ( fdc >= N_FDC || FDCS->address == -1){
address1716drivers/block/floppy.cif(FDCS->address != -1){
address1718drivers/block/floppy.coutb_p(fdc_state[i].address+2, fdc_state[i].dor);
address2790drivers/block/floppy.cstatic int fd_copyout(void *param, volatile void *address, int size)
address2797drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
address3596drivers/block/floppy.cfdc_state[0].address = FDC1;
address3599drivers/block/floppy.cfdc_state[1].address = FDC2;
address3635drivers/block/floppy.cif (FDCS->address == -1 )
address3639drivers/block/floppy.cFDCS->address = -1;
address3645drivers/block/floppy.cFDCS->address = -1;
address3649drivers/block/floppy.crequest_region(FDCS->address, 6, "floppy");
address3650drivers/block/floppy.crequest_region(FDCS->address+7, 1, "floppy DIR");
address3685drivers/block/floppy.cif(FDCS->address != -1){  
address3705drivers/block/floppy.cif(FDCS->address != -1)
address3832drivers/block/floppy.cif (FDCS->address != -1){
address3833drivers/block/floppy.crelease_region(FDCS->address, 6);
address3834drivers/block/floppy.crelease_region(FDCS->address+7, 1);
address659drivers/block/sbpcd.cu_int address;
address3581drivers/block/sbpcd.cD_S[d].TocBuffer[j].address=D_S[d].TocEnt_address;
address3589drivers/block/sbpcd.cD_S[d].TocBuffer[j].address=D_S[d].size_msf;
address3920drivers/block/sbpcd.cD_S[d].pos_audio_start=D_S[d].TocBuffer[ti.cdti_trk0].address;
address3921drivers/block/sbpcd.cD_S[d].pos_audio_end=D_S[d].TocBuffer[ti.cdti_trk1+1].address;
address3951drivers/block/sbpcd.ctocentry.cdte_addr.msf.minute=(D_S[d].TocBuffer[i].address>>16)&0x00FF;
address3952drivers/block/sbpcd.ctocentry.cdte_addr.msf.second=(D_S[d].TocBuffer[i].address>>8)&0x00FF;
address3953drivers/block/sbpcd.ctocentry.cdte_addr.msf.frame=D_S[d].TocBuffer[i].address&0x00FF;
address3956drivers/block/sbpcd.ctocentry.cdte_addr.lba=msf2blk(D_S[d].TocBuffer[i].address);
address1083drivers/block/sonycd535.cschi.cdsc_adr = last_sony_subcode->address;
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);
address523drivers/block/xd.cstatic void xd_dtc_init_controller (u_char *address)
address525drivers/block/xd.cswitch ((u_long) address) {
address528drivers/block/xd.cdefault:        printk("xd_dtc_init_controller: unsupported BIOS address %p\n",address);
address563drivers/block/xd.cstatic void xd_wd_init_controller (u_char *address)
address565drivers/block/xd.cswitch ((u_long) address) {
address572drivers/block/xd.cdefault:        printk("xd_wd_init_controller: unsupported BIOS address %p\n",address);
address604drivers/block/xd.cstatic void xd_seagate_init_controller (u_char *address)
address606drivers/block/xd.cswitch ((u_long) address) {
address611drivers/block/xd.cdefault:  printk("xd_seagate_init_controller: unsupported BIOS address %p\n",address);
address637drivers/block/xd.cstatic void xd_omti_init_controller (u_char *address)
address639drivers/block/xd.cswitch ((u_long) address) {
address644drivers/block/xd.cdefault:  printk("xd_omti_init_controller: unsupported BIOS address %p\n",address);
address437drivers/net/de4x5.cstatic short   srom_rd(u_long address, u_char offset);
address438drivers/net/de4x5.cstatic void    srom_latch(u_int command, u_long address);
address439drivers/net/de4x5.cstatic void    srom_command(u_int command, u_long address);
address440drivers/net/de4x5.cstatic void    srom_address(u_int command, u_long address, u_char offset);
address441drivers/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
address1075drivers/scsi/53c7,8xx.cvirt_to_bus(EXTERNAL_PATCHES[i].address);
address1510drivers/scsi/53c7,8xx.cfor (bp = hostdata->breakpoints; bp && bp->address != dsp; 
address2113drivers/scsi/53c7,8xx.cbp->address = (u32 *) args[0];
address2114drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
address2119drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
address2597drivers/scsi/53c7,8xx.cvirt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) :
address958drivers/scsi/53c7,8xx.hvoid *address;
address1009drivers/scsi/53c7,8xx.hu32 *address, old_instruction[2];
address1328drivers/scsi/53c7,8xx.h#define NCR53c7x0_read8(address)           \
address1330drivers/scsi/53c7,8xx.hncr_readb(NCR53c7x0_address_memory + (address))  :    \
address1331drivers/scsi/53c7,8xx.hinb(NCR53c7x0_address_io + (address)))
address1333drivers/scsi/53c7,8xx.h#define NCR53c7x0_read16(address)           \
address1335drivers/scsi/53c7,8xx.hncr_readw(NCR53c7x0_address_memory + (address))  :    \
address1336drivers/scsi/53c7,8xx.hinw(NCR53c7x0_address_io + (address)))
address1338drivers/scsi/53c7,8xx.h#define NCR53c7x0_read32(address)           \
address1340drivers/scsi/53c7,8xx.hncr_readl(NCR53c7x0_address_memory + (address))  :    \
address1341drivers/scsi/53c7,8xx.hinl(NCR53c7x0_address_io + (address)))
address1343drivers/scsi/53c7,8xx.h#define NCR53c7x0_write8(address,value)         \
address1345drivers/scsi/53c7,8xx.hncr_writeb((value), NCR53c7x0_address_memory + (address)) :  \
address1346drivers/scsi/53c7,8xx.houtb((value), NCR53c7x0_address_io + (address)))
address1348drivers/scsi/53c7,8xx.h#define NCR53c7x0_write16(address,value)         \
address1350drivers/scsi/53c7,8xx.hncr_writew((value), NCR53c7x0_address_memory + (address)) :  \
address1351drivers/scsi/53c7,8xx.houtw((value), NCR53c7x0_address_io + (address)))
address1353drivers/scsi/53c7,8xx.h#define NCR53c7x0_write32(address,value)         \
address1355drivers/scsi/53c7,8xx.hncr_writel((value), NCR53c7x0_address_memory + (address)) :  \
address1356drivers/scsi/53c7,8xx.houtl((value), NCR53c7x0_address_io + (address)))
address2254drivers/scsi/53c8xx_d.hvoid    *address;
address308drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
address1969drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
address816drivers/scsi/aha152x.cSCpnt->SCp.ptr              = SCpnt->SCp.buffer->address;
address2004drivers/scsi/aha152x.ccurrent_SC->SCp.buffer->address;
address2140drivers/scsi/aha152x.ccurrent_SC->SCp.buffer->address;
address614drivers/scsi/aha1542.c(((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
address618drivers/scsi/aha1542.cprintk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
address626drivers/scsi/aha1542.cany2scsi(cptr[i].dataptr, sgpnt[i].address);
address627drivers/scsi/aha1542.cif(((unsigned  int) sgpnt[i].address) & 0xff000000) goto baddma;
address333drivers/scsi/aha1740.ccptr[i].dataptr = (long) sgpnt[i].address;
address731drivers/scsi/aic7xxx.c((char *)&(sg).address - (char *)&(sg) != 0 ||  \
address733drivers/scsi/aic7xxx.csizeof((sg).address) != 4 ||                   \
address1840drivers/scsi/aic7xxx.cscb->sense_sg.address = (char *) &cmd->sense_buffer;
address3502drivers/scsi/aic7xxx.cscb->sg.address = (char *) cmd->request_buffer;
address704drivers/scsi/buslogic.cCHECK_DMA_ADDR(shpnt->unchecked_isa_dma, sgpnt[i].address,
address706drivers/scsi/buslogic.ccptr[i].dataptr = sgpnt[i].address;
address288drivers/scsi/eata.cunsigned int address;     /* Segment Address */
address589drivers/scsi/eata.ccpp->sglist[k].address = htonl((unsigned int) sgpnt[k].address);
address457drivers/scsi/eata_dma.ccp->sg_list[i].data = htonl(virt_to_bus(sl->address));
address116drivers/scsi/eata_pio.cSCp->ptr=SCp->buffer->address;
address367drivers/scsi/eata_pio.ccmd->SCp.ptr = cmd->SCp.buffer->address;
address1446drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1479drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1563drivers/scsi/fdomain.ccurrent_SC->SCp.ptr              = current_SC->SCp.buffer->address;
address211drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address268drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address501drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address393drivers/scsi/qlogic.cif (ql_pdma(phase, sglist->address, sglist->length))
address351drivers/scsi/scsi.hchar *  address;    /* Location data is to be transferred to */
address142drivers/scsi/scsi_debug.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address165drivers/scsi/scsi_debug.clpnt = (unsigned int *) sgpnt[0].address;
address282drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address353drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address381drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address232drivers/scsi/sd.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, 
address237drivers/scsi/sd.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, 
address239drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address296drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address659drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
address663drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length - 1 > 
address666drivers/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
address672drivers/scsi/sd.csgpnt[count].address = NULL;
address674drivers/scsi/sd.csgpnt[count].address = 
address682drivers/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address688drivers/scsi/sd.cscsi_free(sgpnt[count].address, 
address711drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length +
address725drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address726drivers/scsi/sd.csgpnt[count].address = tmp;
address756drivers/scsi/sd.csgpnt[count].address,
address765drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
address909drivers/scsi/seagate.chostno, i, buffer[i].address, buffer[i].length);
address915drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1151drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1297drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address194drivers/scsi/sr.cif (sgpnt[i].alt_address != sgpnt[i].address) {
address195drivers/scsi/sr.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address197drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address233drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address739drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address740drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address741drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
address748drivers/scsi/sr.csgpnt[count].address = bh->b_data;
address752drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(end_rec);
address753drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address755drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address759drivers/scsi/sr.cif (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD &&
address761drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address766drivers/scsi/sr.csgpnt[count].address = NULL;
address768drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address774drivers/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address779drivers/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address794drivers/scsi/sr.csgpnt[count].address, 
address124drivers/scsi/t128.cunsigned char *address;
address137drivers/scsi/t128.cunsigned char *address;
address170drivers/scsi/t128.coverrides[commandline_current].address = (unsigned char *) ints[1];
address173drivers/scsi/t128.cif (bases[i].address == (unsigned char *) ints[1]) {
address203drivers/scsi/t128.cif (overrides[current_override].address)
address204drivers/scsi/t128.cbase = overrides[current_override].address;
address208drivers/scsi/t128.cprintk("scsi : probing address %08x\n", (unsigned int) bases[current_base].address);
address212drivers/scsi/t128.c(bases[current_base].address + signatures[sig].offset, 
address214drivers/scsi/t128.cbase = bases[current_base].address;
address250drivers/scsi/u14-34f.cunsigned int address;     /* Segment Address */
address548drivers/scsi/u14-34f.ccpp->sglist[k].address = (unsigned int) sgpnt[k].address;
address170drivers/scsi/ultrastor.cunsigned int address;
address658drivers/scsi/ultrastor.cmscp->sglist[i].address = (unsigned int)sl[i].address;
address930drivers/scsi/wd7000.cany2scsi(sgb[i].ptr, (int) sg[i].address);
address320drivers/sound/gus_wave.cgus_write_addr (int reg, unsigned long address, int is16bit)
address332drivers/sound/gus_wave.chold_address = address;
address333drivers/sound/gus_wave.caddress = address >> 1;
address334drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address335drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address338drivers/sound/gus_wave.cgus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
address339drivers/sound/gus_wave.cgus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
address342drivers/sound/gus_wave.cgus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
address343drivers/sound/gus_wave.cgus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
address1676drivers/sound/gus_wave.cunsigned long   address, hold_address;
address1699drivers/sound/gus_wave.caddress = target;
address1703drivers/sound/gus_wave.chold_address = address;
address1704drivers/sound/gus_wave.caddress = address >> 1;
address1705drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address1706drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address1709drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address2227drivers/sound/gus_wave.cunsigned long   address, hold_address;
address2249drivers/sound/gus_wave.caddress = this_one * pcm_bsize;
address2250drivers/sound/gus_wave.caddress += chn * pcm_banksize;
address2254drivers/sound/gus_wave.chold_address = address;
address2255drivers/sound/gus_wave.caddress = address >> 1;
address2256drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address2257drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address2260drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address1003fs/buffer.cunsigned long address)
address1010fs/buffer.cstatic unsigned long check_aligned(struct buffer_head * first, unsigned long address,
address1037fs/buffer.creturn try_to_align(bh, nrbuf, address);
address1042fs/buffer.cfree_page(address);
address1051fs/buffer.cstatic unsigned long try_to_load_aligned(unsigned long address,
address1060fs/buffer.cbh = create_buffers(address, size);
address1096fs/buffer.cmem_map[MAP_NR(address)]++;
address1097fs/buffer.cbuffer_pages[MAP_NR(address)] = bh;
address1102fs/buffer.creturn address;
address1122fs/buffer.cstatic inline unsigned long try_to_share_buffers(unsigned long address,
address1133fs/buffer.creturn check_aligned(bh, address, dev, b, size);
address1134fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
address1144fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int no_share)
address1151fs/buffer.cwhere = try_to_share_buffers(address, dev, b, size);
address1162fs/buffer.cwhere = address;
address1171fs/buffer.creturn address;
address1179fs/buffer.cvoid bwrite_page(unsigned long address, dev_t dev, int b[], int size)
address1189fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size, address += size) {
address1191fs/buffer.cmemcpy(bh[i]->b_data, (void *) address, size);
address1196fs/buffer.cmemset((void *) address, 0, size); /* ???!?!! */
address31fs/msdos/mmap.cunsigned long address,
address40fs/msdos/mmap.caddress &= PAGE_MASK;
address41fs/msdos/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/nfs/mmap.cunsigned long address, unsigned long page, int no_share)
address44fs/nfs/mmap.caddress &= PAGE_MASK;
address45fs/nfs/mmap.cpos = address - area->vm_start + area->vm_offset;
address48fs/nfs/mmap.cif (address + PAGE_SIZE > area->vm_end) {
address49fs/nfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
address474fs/proc/array.cstatic inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
address487fs/proc/array.cpte = pte_offset(pmd, address);
address488fs/proc/array.caddress &= ~PMD_MASK;
address489fs/proc/array.cend = address + size;
address495fs/proc/array.caddress += PAGE_SIZE;
address509fs/proc/array.c} while (address < end);
address512fs/proc/array.cstatic inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
address525fs/proc/array.cpmd = pmd_offset(pgd, address);
address526fs/proc/array.caddress &= ~PGDIR_MASK;
address527fs/proc/array.cend = address + size;
address531fs/proc/array.cstatm_pte_range(pmd, address, end - address, pages, shared, dirty, total);
address532fs/proc/array.caddress = (address + PMD_SIZE) & PMD_MASK;
address534fs/proc/array.c} while (address < end);
address537fs/proc/array.cstatic void statm_pgd_range(pgd_t * pgd, unsigned long address, unsigned long end,
address540fs/proc/array.cwhile (address < end) {
address541fs/proc/array.cstatm_pmd_range(pgd, address, end - address, pages, shared, dirty, total);
address542fs/proc/array.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address34fs/smbfs/mmap.cunsigned long address, unsigned long page, int no_share)
address43fs/smbfs/mmap.caddress &= PAGE_MASK;
address44fs/smbfs/mmap.cpos = address - area->vm_start + area->vm_offset;
address47fs/smbfs/mmap.cif (address + PAGE_SIZE > area->vm_end) {
address48fs/smbfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
address79include/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);
address137include/asm-alpha/lca.hextern inline unsigned long virt_to_bus(void * address)
address139include/asm-alpha/lca.hreturn virt_to_phys(address) + LCA_DMA_WIN_BASE;
address142include/asm-alpha/lca.hextern inline void * bus_to_virt(unsigned long address)
address144include/asm-alpha/lca.hreturn phys_to_virt(address - LCA_DMA_WIN_BASE);
address142include/asm-alpha/pgtable.h#define PAGE_PTR(address)    \
address143include/asm-alpha/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address249include/asm-alpha/pgtable.h#define PAGE_DIR_OFFSET(tsk,address) pgd_offset((tsk),(address))
address252include/asm-alpha/pgtable.hextern inline pgd_t * pgd_offset(struct task_struct * tsk, unsigned long address)
address255include/asm-alpha/pgtable.h((address >> PGDIR_SHIFT) & (PTRS_PER_PAGE - 1));
address259include/asm-alpha/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address261include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*dir) + ((address >> PMD_SHIFT) & (PTRS_PER_PAGE - 1));
address265include/asm-alpha/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address267include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PAGE - 1));
address281include/asm-alpha/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t *pmd, unsigned long address)
address283include/asm-alpha/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address290include/asm-alpha/pgtable.hreturn page + address;
address302include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address311include/asm-alpha/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t *pgd, unsigned long address)
address313include/asm-alpha/pgtable.haddress = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
address320include/asm-alpha/pgtable.hreturn page + address;
address332include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*pgd) + address;
address340include/asm-alpha/pgtable.hextern inline pte_t * pte_alloc(pmd_t *pmd, unsigned long address)
address342include/asm-alpha/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address348include/asm-alpha/pgtable.hreturn page + address;
address360include/asm-alpha/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address368include/asm-alpha/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t *pgd, unsigned long address)
address370include/asm-alpha/pgtable.haddress = (address >> PMD_SHIFT) & (PTRS_PER_PMD - 1);
address376include/asm-alpha/pgtable.hreturn page + address;
address388include/asm-alpha/pgtable.hreturn (pmd_t *) pgd_page(*pgd) + address;
address408include/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;
address133include/asm-i386/pgtable.h#define PAGE_PTR(address) \
address134include/asm-i386/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address222include/asm-i386/pgtable.hextern inline pgd_t * pgd_offset(struct task_struct * tsk, unsigned long address)
address224include/asm-i386/pgtable.hreturn (pgd_t *) tsk->tss.cr3 + (address >> PGDIR_SHIFT);
address228include/asm-i386/pgtable.hextern inline pmd_t * pmd_offset(pgd_t * dir, unsigned long address)
address234include/asm-i386/pgtable.hextern inline pte_t * pte_offset(pmd_t * dir, unsigned long address)
address236include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*dir) + ((address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1));
address250include/asm-i386/pgtable.hextern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
address252include/asm-i386/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address259include/asm-i386/pgtable.hreturn page + address;
address271include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address283include/asm-i386/pgtable.hextern inline pmd_t * pmd_alloc_kernel(pgd_t * pgd, unsigned long address)
address293include/asm-i386/pgtable.hextern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
address295include/asm-i386/pgtable.haddress = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
address301include/asm-i386/pgtable.hreturn page + address;
address313include/asm-i386/pgtable.hreturn (pte_t *) pmd_page(*pmd) + address;
address325include/asm-i386/pgtable.hextern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
address347include/asm-i386/pgtable.hunsigned long address, pte_t pte)
address162include/asm-mips/page.h#define PAGE_DIR_OFFSET(tsk,address) \
address163include/asm-mips/page.h((((unsigned long)(address)) >> PGDIR_SHIFT) + (pgd_t *) (tsk)->tss.pg_dir)
address166include/asm-mips/page.h#define PAGE_PTR(address) \
address167include/asm-mips/page.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address182include/asm-sparc/pgtable.h#define PAGE_PTR(address) \
address183include/asm-sparc/pgtable.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address328include/asm-sparc/pgtable.hunsigned long address, pte_t pte)
address333include/asm-sparc/pgtable.hsegmap = (int) get_segmap(address & SUN4C_REAL_PGDIR_MASK);
address336include/asm-sparc/pgtable.hput_segmap((address & SUN4C_REAL_PGDIR_MASK), segmap);
address340include/asm-sparc/pgtable.hfor(clr_addr=(address&SUN4C_REAL_PGDIR_MASK); clr_addr<((address&SUN4C_REAL_PGDIR_MASK) + SUN4C_REAL_PGDIR_SIZE); 
address347include/asm-sparc/pgtable.hput_pte((address & PAGE_MASK), pte_val(pte));
address53include/linux/atalk.hstruct at_addr address;    /* Our address */
address176include/linux/cdu31a.hunsigned char address        :4;
address211include/linux/cdu31a.hunsigned char address     :4;
address271include/linux/cdu31a.hunsigned char address     :4;
address220include/linux/fd.hint address; /* io address */
address11include/linux/fdreg.h#define FD_IOPORT fdc_state[fdc].address
address100include/linux/mm.hunsigned long (*nopage)(struct vm_area_struct * area, unsigned long address,
address102include/linux/mm.hunsigned long (*wppage)(struct vm_area_struct * area, unsigned long address,
address173include/linux/mm.hunsigned long address);
address183include/linux/mm.hextern void handle_mm_fault(struct vm_area_struct *vma, unsigned long address, int write_access);
address184include/linux/mm.hextern void do_wp_page(struct vm_area_struct * vma, unsigned long address, int write_access);
address185include/linux/mm.hextern void do_no_page(struct vm_area_struct * vma, unsigned long address, int write_access);
address123include/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);
address51mm/filemap.cstatic unsigned long filemap_nopage(struct vm_area_struct * area, unsigned long address,
address57mm/filemap.cmulti_bmap(inode, (address & PAGE_MASK) - area->vm_start + area->vm_offset, nr,
address163mm/filemap.cunsigned long address, unsigned int flags)
address191mm/filemap.cerror = filemap_write_page(vma, address - vma->vm_start + vma->vm_offset, page);
address197mm/filemap.cunsigned long address, unsigned long size, 
address211mm/filemap.cpte = pte_offset(pmd, address);
address212mm/filemap.coffset += address & PMD_MASK;
address213mm/filemap.caddress &= ~PMD_MASK;
address214mm/filemap.cend = address + size;
address219mm/filemap.cerror |= filemap_sync_pte(pte, vma, address + offset, flags);
address220mm/filemap.caddress += PAGE_SIZE;
address222mm/filemap.c} while (address < end);
address227mm/filemap.cunsigned long address, unsigned long size, 
address241mm/filemap.cpmd = pmd_offset(pgd, address);
address242mm/filemap.coffset = address & PMD_MASK;
address243mm/filemap.caddress &= ~PMD_MASK;
address244mm/filemap.cend = address + size;
address249mm/filemap.cerror |= filemap_sync_pte_range(pmd, address, end - address, vma, offset, flags);
address250mm/filemap.caddress = (address + PMD_SIZE) & PMD_MASK;
address252mm/filemap.c} while (address < end);
address256mm/filemap.cstatic int filemap_sync(struct vm_area_struct * vma, unsigned long address,
address260mm/filemap.cunsigned long end = address + size;
address263mm/filemap.cdir = pgd_offset(current, address);
address264mm/filemap.cwhile (address < end) {
address265mm/filemap.cerror |= filemap_sync_pmd_range(dir, address, end - address, vma, flags);
address266mm/filemap.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address357mm/memory.cstatic inline void unmap_pte_range(pmd_t * pmd, unsigned long address, unsigned long size)
address369mm/memory.cpte = pte_offset(pmd, address);
address370mm/memory.caddress &= ~PMD_MASK;
address371mm/memory.cend = address + size;
address378mm/memory.caddress += PAGE_SIZE;
address380mm/memory.c} while (address < end);
address383mm/memory.cstatic inline void unmap_pmd_range(pgd_t * dir, unsigned long address, unsigned long size)
address395mm/memory.cpmd = pmd_offset(dir, address);
address396mm/memory.caddress &= ~PGDIR_MASK;
address397mm/memory.cend = address + size;
address401mm/memory.cunmap_pte_range(pmd, address, end - address);
address402mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK; 
address404mm/memory.c} while (address < end);
address411mm/memory.cint unmap_page_range(unsigned long address, unsigned long size)
address414mm/memory.cunsigned long end = address + size;
address416mm/memory.cdir = pgd_offset(current, address);
address417mm/memory.cwhile (address < end) {
address418mm/memory.cunmap_pmd_range(dir, address, end - address);
address419mm/memory.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address426mm/memory.cstatic inline void zeromap_pte_range(pte_t * pte, unsigned long address, unsigned long size, pte_t zero_pte)
address430mm/memory.caddress &= ~PMD_MASK;
address431mm/memory.cend = address + size;
address438mm/memory.caddress += PAGE_SIZE;
address440mm/memory.c} while (address < end);
address443mm/memory.cstatic inline int zeromap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size, pte_t zero_pte)
address447mm/memory.caddress &= ~PGDIR_MASK;
address448mm/memory.cend = address + size;
address452mm/memory.cpte_t * pte = pte_alloc(pmd, address);
address455mm/memory.czeromap_pte_range(pte, address, end - address, zero_pte);
address456mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK;
address458mm/memory.c} while (address < end);
address462mm/memory.cint zeromap_page_range(unsigned long address, unsigned long size, pgprot_t prot)
address466mm/memory.cunsigned long end = address + size;
address470mm/memory.cdir = pgd_offset(current, address);
address471mm/memory.cwhile (address < end) {
address472mm/memory.cpmd_t *pmd = pmd_alloc(dir, address);
address476mm/memory.cerror = zeromap_pmd_range(pmd, address, end - address, zero_pte);
address479mm/memory.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address491mm/memory.cstatic inline void remap_pte_range(pte_t * pte, unsigned long address, unsigned long size,
address496mm/memory.caddress &= ~PMD_MASK;
address497mm/memory.cend = address + size;
address506mm/memory.caddress += PAGE_SIZE;
address509mm/memory.c} while (address < end);
address512mm/memory.cstatic inline int remap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size,
address517mm/memory.caddress &= ~PGDIR_MASK;
address518mm/memory.cend = address + size;
address521mm/memory.coffset -= address;
address523mm/memory.cpte_t * pte = pte_alloc(pmd, address);
address526mm/memory.cremap_pte_range(pte, address, end - address, address + offset, prot);
address527mm/memory.caddress = (address + PMD_SIZE) & PMD_MASK;
address529mm/memory.c} while (address < end);
address574mm/memory.cunsigned long put_dirty_page(struct task_struct * tsk, unsigned long page, unsigned long address)
address581mm/memory.cprintk("put_dirty_page: trying to put page %08lx at %08lx\n",page,address);
address583mm/memory.cprintk("mem_map disagrees with %08lx at %08lx\n",page,address);
address584mm/memory.cpgd = pgd_offset(tsk,address);
address585mm/memory.cpmd = pmd_alloc(pgd, address);
address591mm/memory.cpte = pte_alloc(pmd, address);
address624mm/memory.cvoid do_wp_page(struct vm_area_struct * vma, unsigned long address,
address633mm/memory.cpage_dir = pgd_offset(vma->vm_task,address);
address638mm/memory.cpage_middle = pmd_offset(page_dir, address);
address643mm/memory.cpage_table = pte_offset(page_middle, address);
address678mm/memory.cprintk("do_wp_page: bogus page at address %08lx (%08lx)\n",address,old_page);
address682mm/memory.cprintk("do_wp_page: bogus page-middle at address %08lx (%08lx)\n", address, pmd_val(*page_middle));
address686mm/memory.cprintk("do_wp_page: bogus page-dir entry at address %08lx (%08lx)\n", address, pgd_val(*page_dir));
address906mm/memory.cstatic int share_page(struct vm_area_struct * area, unsigned long address,
address924mm/memory.coffset = address - area->vm_start + area->vm_offset;
address941mm/memory.cif (!try_to_share(address, area, from_address, mpnt, give_page))
address955mm/memory.cstatic inline pte_t * get_empty_pgtable(struct task_struct * tsk,unsigned long address)
address961mm/memory.cpgd = pgd_offset(tsk, address);
address962mm/memory.cpmd = pmd_alloc(pgd, address);
address967mm/memory.cpte = pte_alloc(pmd, address);
address975mm/memory.cstatic inline void do_swap_page(struct vm_area_struct * vma, unsigned long address,
address984mm/memory.cpage = vma->vm_ops->swapin(vma, address - vma->vm_start + vma->vm_offset, pte_val(entry));
address1003mm/memory.cvoid do_no_page(struct vm_area_struct * vma, unsigned long address,
address1010mm/memory.cpage_table = get_empty_pgtable(vma->vm_task,address);
address1017mm/memory.cdo_swap_page(vma, address, page_table, entry, write_access);
address1020mm/memory.caddress &= PAGE_MASK;
address1028mm/memory.cif (share_page(vma, address, write_access, page)) {
address1045mm/memory.cpage = vma->vm_ops->nopage(vma, address, page,
address1047mm/memory.cif (share_page(vma, address, write_access, 0)) {
address1082mm/memory.cstatic inline void handle_pte_fault(struct vm_area_struct * vma, unsigned long address,
address1086mm/memory.cdo_no_page(vma, address, write_access);
address1096mm/memory.cdo_wp_page(vma, address, write_access);
address1099mm/memory.cvoid handle_mm_fault(struct vm_area_struct * vma, unsigned long address,
address1106mm/memory.cpgd = pgd_offset(vma->vm_task, address);
address1107mm/memory.cpmd = pmd_alloc(pgd, address);
address1110mm/memory.cpte = pte_alloc(pmd, address);
address1113mm/memory.chandle_pte_fault(vma, address, write_access, pte);
address1114mm/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);
address355mm/swap.cstatic inline int try_to_swap_out(struct vm_area_struct* vma, unsigned long address, pte_t * page_table, unsigned long limit)
address379mm/swap.cif (vma->vm_ops->swapout(vma, address - vma->vm_start + vma->vm_offset, page_table))
address442mm/swap.cunsigned long address, unsigned long end, unsigned long limit)
address455mm/swap.cpte = pte_offset(dir, address);
address457mm/swap.cpmd_end = (address + PMD_SIZE) & PMD_MASK;
address463mm/swap.cvma->vm_task->mm->swap_address = address + PAGE_SIZE;
address464mm/swap.cresult = try_to_swap_out(vma, address, pte, limit);
address467mm/swap.caddress += PAGE_SIZE;
address469mm/swap.c} while (address < end);
address474mm/swap.cunsigned long address, unsigned long end, unsigned long limit)
address487mm/swap.cpmd = pmd_offset(dir, address);
address489mm/swap.cpgd_end = (address + PGDIR_SIZE) & PGDIR_MASK;  
address494mm/swap.cint result = swap_out_pmd(vma, pmd, address, end, limit);
address497mm/swap.caddress = (address + PMD_SIZE) & PMD_MASK;
address499mm/swap.c} while (address < end);
address526mm/swap.cunsigned long address;
address532mm/swap.caddress = p->mm->swap_address;
address538mm/swap.cvma = find_vma(p, address);
address541mm/swap.cif (address < vma->vm_start)
address542mm/swap.caddress = vma->vm_start;
address545mm/swap.cint result = swap_out_vma(vma, pgd_offset(p, address), address, limit);
address551mm/swap.caddress = vma->vm_start;
address847mm/swap.cstatic inline int unuse_pte(struct vm_area_struct * vma, unsigned long address,
address880mm/swap.cunsigned long address, unsigned long size, unsigned long offset,
address893mm/swap.cpte = pte_offset(dir, address);
address894mm/swap.coffset += address & PMD_MASK;
address895mm/swap.caddress &= ~PMD_MASK;
address896mm/swap.cend = address + size;
address900mm/swap.cif (unuse_pte(vma, offset+address-vma->vm_start, pte, type, page))
address902mm/swap.caddress += PAGE_SIZE;
address904mm/swap.c} while (address < end);
address909mm/swap.cunsigned long address, unsigned long size,
address922mm/swap.cpmd = pmd_offset(dir, address);
address923mm/swap.coffset = address & PGDIR_MASK;
address924mm/swap.caddress &= ~PGDIR_MASK;
address925mm/swap.cend = address + size;
address929mm/swap.cif (unuse_pmd(vma, pmd, address, end - address, offset, type, page))
address931mm/swap.caddress = (address + PMD_SIZE) & PMD_MASK;
address933mm/swap.c} while (address < end);
address30mm/vmalloc.cstatic inline void set_pgdir(unsigned long address, pgd_t entry)
address35mm/vmalloc.c*pgd_offset(p,address) = entry;
address38mm/vmalloc.cstatic inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)
address50mm/vmalloc.cpte = pte_offset(pmd, address);
address51mm/vmalloc.caddress &= ~PMD_MASK;
address52mm/vmalloc.cend = address + size;
address55mm/vmalloc.cwhile (address < end) {
address58mm/vmalloc.caddress += PAGE_SIZE;
address70mm/vmalloc.cstatic inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)
address82mm/vmalloc.cpmd = pmd_offset(dir, address);
address83mm/vmalloc.caddress &= ~PGDIR_MASK;
address84mm/vmalloc.cend = address + size;
address87mm/vmalloc.cwhile (address < end) {
address88mm/vmalloc.cfree_area_pte(pmd, address, end - address);
address89mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address94mm/vmalloc.cstatic void free_area_pages(unsigned long address, unsigned long size)
address97mm/vmalloc.cunsigned long end = address + size;
address99mm/vmalloc.cdir = pgd_offset(&init_task, address);
address100mm/vmalloc.cwhile (address < end) {
address101mm/vmalloc.cfree_area_pmd(dir, address, end - address);
address102mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address108mm/vmalloc.cstatic inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)
address112mm/vmalloc.caddress &= ~PMD_MASK;
address113mm/vmalloc.cend = address + size;
address116mm/vmalloc.cwhile (address < end) {
address124mm/vmalloc.caddress += PAGE_SIZE;
address130mm/vmalloc.cstatic inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)
address134mm/vmalloc.caddress &= ~PGDIR_MASK;
address135mm/vmalloc.cend = address + size;
address138mm/vmalloc.cwhile (address < end) {
address139mm/vmalloc.cpte_t * pte = pte_alloc_kernel(pmd, address);
address142mm/vmalloc.cif (alloc_area_pte(pte, address, end - address))
address144mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address150mm/vmalloc.cstatic int alloc_area_pages(unsigned long address, unsigned long size)
address153mm/vmalloc.cunsigned long end = address + size;
address155mm/vmalloc.cdir = pgd_offset(&init_task, address);
address156mm/vmalloc.cwhile (address < end) {
address157mm/vmalloc.cpmd_t *pmd = pmd_alloc_kernel(dir, address);
address160mm/vmalloc.cif (alloc_area_pmd(pmd, address, end - address))
address162mm/vmalloc.cset_pgdir(address, *dir);
address163mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address170mm/vmalloc.cstatic inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
address175mm/vmalloc.caddress &= ~PMD_MASK;
address176mm/vmalloc.cend = address + size;
address183mm/vmalloc.caddress += PAGE_SIZE;
address186mm/vmalloc.c} while (address < end);
address189mm/vmalloc.cstatic inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
address194mm/vmalloc.caddress &= ~PGDIR_MASK;
address195mm/vmalloc.cend = address + size;
address198mm/vmalloc.coffset -= address;
address200mm/vmalloc.cpte_t * pte = pte_alloc_kernel(pmd, address);
address203mm/vmalloc.cremap_area_pte(pte, address, end - address, address + offset);
address204mm/vmalloc.caddress = (address + PMD_SIZE) & PMD_MASK;
address206mm/vmalloc.c} while (address < end);
address210mm/vmalloc.cstatic int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)
address213mm/vmalloc.cunsigned long end = address + size;
address215mm/vmalloc.coffset -= address;
address216mm/vmalloc.cdir = pgd_offset(&init_task, address);
address217mm/vmalloc.cwhile (address < end) {
address218mm/vmalloc.cpmd_t *pmd = pmd_alloc_kernel(dir, address);
address221mm/vmalloc.cif (remap_area_pmd(pmd, address, end - address, offset + address))
address223mm/vmalloc.cset_pgdir(address, *dir);
address224mm/vmalloc.caddress = (address + PGDIR_SIZE) & PGDIR_MASK;
address639net/appletalk/aarp.cif(ifa->address.s_node==ea->pa_dst_node && ifa->address.s_net==ea->pa_dst_net)
address684net/appletalk/aarp.cma=&ifa->address;
address136net/appletalk/ddp.cs->at.src_net == atif->address.s_net ) {
address309net/appletalk/ddp.ciface->address= *sa;
address327net/appletalk/ddp.cint probe_net=ntohs(atif->address.s_net);
address328net/appletalk/ddp.cint probe_node=atif->address.s_node;
address359net/appletalk/ddp.catif->address.s_net=htons(probe_net);
address362net/appletalk/ddp.catif->address.s_node=((nodect+probe_node)&0xFF);
address363net/appletalk/ddp.cif(atif->address.s_node>0&&atif->address.s_node<254)
address370net/appletalk/ddp.caarp_send_probe(atif->dev, &atif->address);
address397net/appletalk/ddp.creturn &iface->address;
address406net/appletalk/ddp.creturn &iface->address;
address408net/appletalk/ddp.creturn &atalk_iface_list->address;
address439net/appletalk/ddp.cif ( node == ATADDR_BCAST || iface->address.s_node == node ) {
address455net/appletalk/ddp.cif((node==ATADDR_BCAST || iface->address.s_node==node) 
address456net/appletalk/ddp.c&& iface->address.s_net==net && !(iface->status&ATIF_PROBE))
address568net/appletalk/ddp.cif ( ga->sat_addr.s_net == iface->address.s_net &&
address569net/appletalk/ddp.cga->sat_addr.s_node == iface->address.s_node )
address715net/appletalk/ddp.catif->address.s_net=sa->sat_addr.s_net;
address716net/appletalk/ddp.catif->address.s_node=sa->sat_addr.s_node;
address743net/appletalk/ddp.csa->sat_addr.s_net=atif->address.s_net;
address744net/appletalk/ddp.csa->sat_addr.s_node=atif->address.s_node;
address755net/appletalk/ddp.csa->sat_addr.s_net=atif->address.s_net;
address777net/appletalk/ddp.c((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr=atif->address;
address783net/appletalk/ddp.c((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_net=atif->address.s_net;
address832net/appletalk/ddp.cntohs(iface->address.s_net),iface->address.s_node,
address26net/core/iovec.cint verify_iovec(struct msghdr *m, struct iovec *iov, char *address, int mode)
address35net/core/iovec.cerr=move_addr_to_kernel(m->msg_name, m->msg_namelen, address);
address84net/ipv4/igmp.cstatic void igmp_send_report(struct device *dev, unsigned long address, int type)
address92net/ipv4/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
address103net/ipv4/igmp.cih->group=address;
address125net/ipv4/igmp.cextern __inline__ void igmp_heard_report(struct device *dev, unsigned long address)
address129net/ipv4/igmp.cif(im->multiaddr==address)
address698net/socket.cchar address[MAX_SOCK_ADDR];
address707net/socket.cif((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)
address710net/socket.cif ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0) 
address758net/socket.cchar address[MAX_SOCK_ADDR];
address803net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
address804net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
address820net/socket.cchar address[MAX_SOCK_ADDR];
address828net/socket.cif((err=move_addr_to_kernel(uservaddr,addrlen,address))<0)
address853net/socket.ci = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);
address869net/socket.cchar address[MAX_SOCK_ADDR];
address878net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
address881net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address894net/socket.cchar address[MAX_SOCK_ADDR];
address903net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
address906net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address946net/socket.cchar address[MAX_SOCK_ADDR];
address960net/socket.cif((err=move_addr_to_kernel(addr,addr_len,address))<0)
address964net/socket.cflags, (struct sockaddr *)address, addr_len));
address1010net/socket.cchar address[MAX_SOCK_ADDR];
address1027net/socket.cflags, (struct sockaddr *)address, &alen);
address1031net/socket.cif(addr!=NULL && (err=move_addr_to_user(address,alen, addr, addr_len))<0)
address1101net/socket.cchar address[MAX_SOCK_ADDR];
address1118net/socket.cerr=verify_iovec(&msg_sys,iov,address, VERIFY_READ);
address1136net/socket.cchar address[MAX_SOCK_ADDR];
address1155net/socket.cerr=verify_iovec(&msg_sys,iov,address, VERIFY_WRITE);
address1168net/socket.cif(msg_sys.msg_name!=NULL && (err=move_addr_to_user(address,addr_len, msg_sys.msg_name, &msg_sys.msg_namelen))<0)