taglinefilesource code
address40drivers/FPU-emu/errors.cunsigned long address = FPU_ORIG_EIP;
address44drivers/FPU-emu/errors.cprintk("Unimplemented FPU Opcode at eip=%p : ", (void *) address);
address49drivers/FPU-emu/errors.cbyte1 = get_fs_byte((unsigned char *) address);
address52drivers/FPU-emu/errors.caddress++;
address55drivers/FPU-emu/errors.cFPU_modrm = get_fs_byte(1 + (unsigned char *) address);
address91drivers/FPU-emu/errors.cunsigned long address = FPU_ORIG_EIP;
address95drivers/FPU-emu/errors.cprintk("At %p:", (void *) address);
address101drivers/FPU-emu/errors.cbyte1 = get_fs_byte((unsigned char *) address);
address108drivers/FPU-emu/errors.caddress++;
address114drivers/FPU-emu/errors.cFPU_modrm = get_fs_byte(1 + (unsigned char *) address);
address139drivers/FPU-emu/fpu_entry.cstruct address data_sel_off;
address140drivers/FPU-emu/fpu_entry.cstruct address entry_sel_off;
address67drivers/FPU-emu/fpu_proto.hstruct address *addr,
address70drivers/FPU-emu/fpu_proto.hstruct address *addr,
address75drivers/FPU-emu/fpu_proto.hvoid *address);
address129drivers/FPU-emu/fpu_proto.hextern char *fldenv(fpu_addr_modes addr_modes, char *address);
address130drivers/FPU-emu/fpu_proto.hextern void frstor(fpu_addr_modes addr_modes, char *address);
address132drivers/FPU-emu/fpu_proto.hextern char *fstenv(fpu_addr_modes addr_modes, char *address);
address133drivers/FPU-emu/fpu_proto.hextern void fsave(fpu_addr_modes addr_modes, char *address);
address62drivers/FPU-emu/fpu_system.h#define instruction_address     (*(struct address *)&I387.soft.fip)
address63drivers/FPU-emu/fpu_system.h#define operand_address         (*(struct address *)&I387.soft.foo)
address149drivers/FPU-emu/get_address.cunsigned long base_address, limit, address, seg_top;
address164drivers/FPU-emu/get_address.caddress = base_address + offset;
address179drivers/FPU-emu/get_address.c(address <= limit) || (address >= seg_top) ? 0 :
address180drivers/FPU-emu/get_address.c((seg_top-address) >= 255 ? 255 : seg_top-address);
address185drivers/FPU-emu/get_address.c(address > limit) || (address < base_address) ? 0 :
address186drivers/FPU-emu/get_address.c((limit-address) >= 254 ? 255 : limit-address+1);
address193drivers/FPU-emu/get_address.creturn address;
address215drivers/FPU-emu/get_address.cstruct address *addr,
address222drivers/FPU-emu/get_address.cint address = 0;     /* Initialized just to stop compiler warnings. */
address238drivers/FPU-emu/get_address.caddress = sib(mod, fpu_eip);
address251drivers/FPU-emu/get_address.caddress = get_fs_long((unsigned long *) (*fpu_eip));
address254drivers/FPU-emu/get_address.caddr->offset = address;
address255drivers/FPU-emu/get_address.creturn (void *) address;
address259drivers/FPU-emu/get_address.caddress = *cpu_reg_ptr;  /* Just return the contents
address261drivers/FPU-emu/get_address.caddr->offset = address;
address262drivers/FPU-emu/get_address.creturn (void *) address;
address268drivers/FPU-emu/get_address.caddress = (signed char) get_fs_byte((char *) (*fpu_eip));
address276drivers/FPU-emu/get_address.caddress = (signed) get_fs_long((unsigned long *) (*fpu_eip));
address284drivers/FPU-emu/get_address.caddress += *cpu_reg_ptr;
address287drivers/FPU-emu/get_address.caddr->offset = address;
address294drivers/FPU-emu/get_address.caddress += vm86_segment(addr_modes.override.segment,
address299drivers/FPU-emu/get_address.caddress = pm_address(FPU_modrm, addr_modes.override.segment,
address300drivers/FPU-emu/get_address.c(unsigned short *)&(addr->selector), address);
address306drivers/FPU-emu/get_address.creturn (void *)address;
address311drivers/FPU-emu/get_address.cstruct address *addr,
address317drivers/FPU-emu/get_address.cint address = 0;     /* Default used for mod == 0 */
address339drivers/FPU-emu/get_address.caddress = (unsigned short)get_fs_word((unsigned short *) (*fpu_eip));
address349drivers/FPU-emu/get_address.caddress = (signed char) get_fs_byte((signed char *) (*fpu_eip));
address357drivers/FPU-emu/get_address.caddress = (unsigned) get_fs_word((unsigned short *) (*fpu_eip));
address369drivers/FPU-emu/get_address.caddress += FPU_info->___ebx + FPU_info->___esi;
address372drivers/FPU-emu/get_address.caddress += FPU_info->___ebx + FPU_info->___edi;
address375drivers/FPU-emu/get_address.caddress += FPU_info->___ebp + FPU_info->___esi;
address380drivers/FPU-emu/get_address.caddress += FPU_info->___ebp + FPU_info->___edi;
address385drivers/FPU-emu/get_address.caddress += FPU_info->___esi;
address388drivers/FPU-emu/get_address.caddress += FPU_info->___edi;
address391drivers/FPU-emu/get_address.caddress += FPU_info->___ebp;
address396drivers/FPU-emu/get_address.caddress += FPU_info->___ebx;
address401drivers/FPU-emu/get_address.caddress &= 0xffff;
address403drivers/FPU-emu/get_address.caddr->offset = address;
address410drivers/FPU-emu/get_address.caddress += vm86_segment(addr_modes.override.segment,
address415drivers/FPU-emu/get_address.caddress = pm_address(FPU_modrm, addr_modes.override.segment,
address416drivers/FPU-emu/get_address.c(unsigned short *)&(addr->selector), address);
address422drivers/FPU-emu/get_address.creturn (void *)address ;
address1811drivers/block/cdu31a.cschi.cdsc_adr = last_sony_subcode->address;
address2341drivers/block/cdu31a.cloc_entry.cdte_adr = ses_tocs[dev]->tracks[track_idx].address;
address574drivers/block/floppy.cif(FDCS->address == -1)
address1426drivers/block/floppy.cif ( fdc >= N_FDC || FDCS->address == -1){
address1504drivers/block/floppy.coutb_p(fdc_state[i].address+2, fdc_state[i].dor);
address2547drivers/block/floppy.cstatic int fd_copyout(void *param, volatile void *address, int size)
address2554drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
address3193drivers/block/floppy.cfdc_state[0].address = FDC1;
address3196drivers/block/floppy.cfdc_state[1].address = FDC2;
address3230drivers/block/floppy.cif (FDCS->address == -1 )
address3294drivers/block/floppy.cif(FDCS->address != -1)
address576drivers/block/sbpcd.cu_int address;
address2263drivers/block/sbpcd.cDriveStruct[d].TocBuffer[j].address=DriveStruct[d].TocEnt_address;
address2271drivers/block/sbpcd.cDriveStruct[d].TocBuffer[j].address=DriveStruct[d].size_msf;
address2649drivers/block/sbpcd.cDriveStruct[d].pos_audio_start=DriveStruct[d].TocBuffer[ti.cdti_trk0].address;
address2650drivers/block/sbpcd.cDriveStruct[d].pos_audio_end=DriveStruct[d].TocBuffer[ti.cdti_trk1+1].address;
address2679drivers/block/sbpcd.c{ tocentry.cdte_addr.msf.minute=(DriveStruct[d].TocBuffer[i].address>>16)&0x00FF;
address2680drivers/block/sbpcd.ctocentry.cdte_addr.msf.second=(DriveStruct[d].TocBuffer[i].address>>8)&0x00FF;
address2681drivers/block/sbpcd.ctocentry.cdte_addr.msf.frame=DriveStruct[d].TocBuffer[i].address&0x00FF;
address2684drivers/block/sbpcd.ctocentry.cdte_addr.lba=msf2blk(DriveStruct[d].TocBuffer[i].address);
address132drivers/block/xd.cstatic u_char xd_detect (u_char *controller,u_char **address)
address139drivers/block/xd.c*address = NULL;
address147drivers/block/xd.c*address = xd_bases[i];
address157drivers/block/xd.cu_char i,controller,*address;
address159drivers/block/xd.cif (xd_detect(&controller,&address)) {
address161drivers/block/xd.cprintk("xd_geninit: detected a%s controller (type %d) at address %p\n",xd_sigs[controller].name,controller,address);
address163drivers/block/xd.cxd_sigs[controller].init_controller(address);
address522drivers/block/xd.cstatic void xd_dtc_init_controller (u_char *address)
address524drivers/block/xd.cswitch ((u_long) address) {
address527drivers/block/xd.cdefault:        printk("xd_dtc_init_controller: unsupported BIOS address %p\n",address);
address562drivers/block/xd.cstatic void xd_wd_init_controller (u_char *address)
address564drivers/block/xd.cswitch ((u_long) address) {
address571drivers/block/xd.cdefault:        printk("xd_wd_init_controller: unsupported BIOS address %p\n",address);
address603drivers/block/xd.cstatic void xd_seagate_init_controller (u_char *address)
address605drivers/block/xd.cswitch ((u_long) address) {
address610drivers/block/xd.cdefault:  printk("xd_seagate_init_controller: unsupported BIOS address %p\n",address);
address636drivers/block/xd.cstatic void xd_omti_init_controller (u_char *address)
address638drivers/block/xd.cswitch ((u_long) address) {
address643drivers/block/xd.cdefault:  printk("xd_omti_init_controller: unsupported BIOS address %p\n",address);
address1423drivers/scsi/53c7,8xx.cfor (bp = hostdata->breakpoints; bp && bp->address != dsp; 
address2018drivers/scsi/53c7,8xx.cbp->address = (unsigned long *) args[0];
address2019drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
address2024drivers/scsi/53c7,8xx.cmemcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
address2486drivers/scsi/53c7,8xx.c((struct scatterlist *)cmd->buffer)[i].address :
address930drivers/scsi/53c7,8xx.hvoid *address;
address973drivers/scsi/53c7,8xx.hunsigned long *address, old_instruction[2];
address1263drivers/scsi/53c7,8xx.h#define NCR53c7x0_read8(address)           \
address1265drivers/scsi/53c7,8xx.h*( (NCR53c7x0_address_memory) + (address))  :       \
address1266drivers/scsi/53c7,8xx.hinb(NCR53c7x0_address_io + (address)))
address1268drivers/scsi/53c7,8xx.h#define NCR53c7x0_read16(address)           \
address1270drivers/scsi/53c7,8xx.h*((unsigned short *) (NCR53c7x0_address_memory) + (address))  :  \
address1271drivers/scsi/53c7,8xx.hinw(NCR53c7x0_address_io + (address)))
address1273drivers/scsi/53c7,8xx.h#define NCR53c7x0_read32(address)           \
address1275drivers/scsi/53c7,8xx.h*((unsigned long *) (NCR53c7x0_address_memory) + (address))  :   \
address1276drivers/scsi/53c7,8xx.hinl(NCR53c7x0_address_io + (address)))
address1278drivers/scsi/53c7,8xx.h#define NCR53c7x0_write8(address,value)         \
address1280drivers/scsi/53c7,8xx.h*((unsigned char *) (NCR53c7x0_address_memory) + (address)) =  \
address1282drivers/scsi/53c7,8xx.houtb((value), NCR53c7x0_address_io + (address)))
address1284drivers/scsi/53c7,8xx.h#define NCR53c7x0_write16(address,value)         \
address1286drivers/scsi/53c7,8xx.h*((unsigned short *) (NCR53c7x0_address_memory) + (address)) =  \
address1288drivers/scsi/53c7,8xx.houtw((value), NCR53c7x0_address_io + (address)))
address1290drivers/scsi/53c7,8xx.h#define NCR53c7x0_write32(address,value)         \
address1292drivers/scsi/53c7,8xx.h*((unsigned long *) (NCR53c7x0_address_memory) + (address)) =    \
address1294drivers/scsi/53c7,8xx.houtl((value), NCR53c7x0_address_io + (address)))
address308drivers/scsi/NCR5380.ccmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
address1965drivers/scsi/NCR5380.ccmd->SCp.ptr = cmd->SCp.buffer->address;
address775drivers/scsi/aha152x.cSCpnt->SCp.ptr              = SCpnt->SCp.buffer->address;
address1936drivers/scsi/aha152x.ccurrent_SC->SCp.buffer->address;
address2072drivers/scsi/aha152x.ccurrent_SC->SCp.buffer->address;
address600drivers/scsi/aha1542.c(((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
address604drivers/scsi/aha1542.cprintk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
address612drivers/scsi/aha1542.cany2scsi(cptr[i].dataptr, sgpnt[i].address);
address613drivers/scsi/aha1542.cif(((unsigned  int) sgpnt[i].address) & 0xff000000) goto baddma;
address324drivers/scsi/aha1740.ccptr[i].dataptr = (long) sgpnt[i].address;
address137drivers/scsi/aha274x.c((char *)&(sg).address - (char *)&(sg) != 0 ||  \
address139drivers/scsi/aha274x.csizeof((sg).address) != 4 ||      \
address699drivers/scsi/buslogic.ccptr[i].dataptr = sgpnt[i].address;
address189drivers/scsi/eata.cunsigned int address;     /* Segment Address */
address392drivers/scsi/eata.ccpp->sglist[k].address = htonl((unsigned int) sgpnt[k].address);
address1203drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1236drivers/scsi/fdomain.ccurrent_SC->SCp.ptr = current_SC->SCp.buffer->address;
address1320drivers/scsi/fdomain.ccurrent_SC->SCp.ptr              = current_SC->SCp.buffer->address;
address203drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address261drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address489drivers/scsi/in2000.cin2000_dataptr = (unsigned short*)in2000_scatter->address;
address323drivers/scsi/qlogic.cif (ql_pdma(phase, sglist->address, sglist->length))
address330drivers/scsi/scsi.hchar *  address; /* Location data is to be transferred to */
address122drivers/scsi/scsi_debug.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address145drivers/scsi/scsi_debug.clpnt = (unsigned int *) sgpnt[0].address;
address260drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address329drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address357drivers/scsi/scsi_debug.cbuff = sgpnt[sgcount].address;
address185drivers/scsi/sd.cprintk(":%x %x %d\n",sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address189drivers/scsi/sd.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address190drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address245drivers/scsi/sd.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address591drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
address595drivers/scsi/sd.cif (((int) sgpnt[count].address) + sgpnt[count].length - 1 > 
address598drivers/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
address603drivers/scsi/sd.csgpnt[count].address = NULL;
address605drivers/scsi/sd.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address611drivers/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address617drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address638drivers/scsi/sd.cif (((int) sgpnt[count].address) + sgpnt[count].length +
address651drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address652drivers/scsi/sd.csgpnt[count].address = tmp;
address677drivers/scsi/sd.csgpnt[count].address,
address686drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
address898drivers/scsi/seagate.chostno, i, buffer[i].address, buffer[i].length);
address904drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1140drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address1286drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
address174drivers/scsi/sr.cif (sgpnt[i].alt_address != sgpnt[i].address) {
address175drivers/scsi/sr.cmemcpy(sgpnt[i].alt_address, sgpnt[i].address, sgpnt[i].length);
address177drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address213drivers/scsi/sr.cscsi_free(sgpnt[i].address, sgpnt[i].length);
address619drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address620drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address621drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
address628drivers/scsi/sr.csgpnt[count].address = bh->b_data;
address632drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(end_rec);
address633drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
address635drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address639drivers/scsi/sr.cif (((int) sgpnt[count].address) + sgpnt[count].length > 
address641drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
address646drivers/scsi/sr.csgpnt[count].address = NULL;
address648drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
address654drivers/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
address659drivers/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
address674drivers/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;
address212drivers/scsi/u14-34f.cunsigned int address;     /* Segment Address */
address441drivers/scsi/u14-34f.ccpp->sglist[k].address = (unsigned int) sgpnt[k].address;
address166drivers/scsi/ultrastor.cunsigned int address;
address650drivers/scsi/ultrastor.cmscp->sglist[i].address = (unsigned int)sl[i].address;
address933drivers/scsi/wd7000.cany2scsi(sgb[i].ptr, (int) sg[i].address);
address316drivers/sound/gus_wave.cgus_write_addr (int reg, unsigned long address, int is16bit)
address328drivers/sound/gus_wave.chold_address = address;
address329drivers/sound/gus_wave.caddress = address >> 1;
address330drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address331drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address334drivers/sound/gus_wave.cgus_write16 (reg, (unsigned short) ((address >> 7) & 0xffff));
address335drivers/sound/gus_wave.cgus_write16 (reg + 1, (unsigned short) ((address << 9) & 0xffff));
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));
address1641drivers/sound/gus_wave.cunsigned long   address, hold_address;
address1663drivers/sound/gus_wave.caddress = target;
address1667drivers/sound/gus_wave.chold_address = address;
address1668drivers/sound/gus_wave.caddress = address >> 1;
address1669drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address1670drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address1673drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address2172drivers/sound/gus_wave.cunsigned long   address, hold_address;
address2194drivers/sound/gus_wave.caddress = this_one * pcm_bsize;
address2195drivers/sound/gus_wave.caddress += chn * pcm_banksize;
address2199drivers/sound/gus_wave.chold_address = address;
address2200drivers/sound/gus_wave.caddress = address >> 1;
address2201drivers/sound/gus_wave.caddress &= 0x0001ffffL;
address2202drivers/sound/gus_wave.caddress |= (hold_address & 0x000c0000L);
address2205drivers/sound/gus_wave.cgus_write16 (0x42, (address >> 4) & 0xffff);  /* DRAM DMA address */
address991fs/buffer.cunsigned long address)
address998fs/buffer.cstatic unsigned long check_aligned(struct buffer_head * first, unsigned long address,
address1025fs/buffer.creturn try_to_align(bh, nrbuf, address);
address1030fs/buffer.cfree_page(address);
address1039fs/buffer.cstatic unsigned long try_to_load_aligned(unsigned long address,
address1048fs/buffer.cbh = create_buffers(address, size);
address1083fs/buffer.cmem_map[MAP_NR(address)]++;
address1084fs/buffer.cbuffer_pages[MAP_NR(address)] = bh;
address1089fs/buffer.creturn address;
address1109fs/buffer.cstatic inline unsigned long try_to_share_buffers(unsigned long address,
address1120fs/buffer.creturn check_aligned(bh, address, dev, b, size);
address1121fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
address1131fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int no_share)
address1138fs/buffer.cwhere = try_to_share_buffers(address, dev, b, size);
address1149fs/buffer.cwhere = address;
address1157fs/buffer.creturn address;
address28fs/namei.cstatic inline int get_max_filename(unsigned long address)
address37fs/namei.cif (vma->vm_end > address)
address40fs/namei.cif (vma->vm_start > address || !(vma->vm_page_prot & PAGE_USER))
address42fs/namei.caddress = vma->vm_end - address;
address43fs/namei.cif (address > PAGE_SIZE)
address48fs/namei.creturn address;
address30fs/nfs/mmap.cunsigned long address, unsigned long page, int no_share)
address40fs/nfs/mmap.caddress &= PAGE_MASK;
address41fs/nfs/mmap.cpos = address - area->vm_start + area->vm_offset;
address44fs/nfs/mmap.cif (address + PAGE_SIZE > area->vm_end) {
address45fs/nfs/mmap.cclear = address + PAGE_SIZE - area->vm_end;
address40include/asm-alpha/page.h#define PAGE_DIR_OFFSET(base,address)  ((unsigned long*)((base)+\
address41include/asm-alpha/page.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)*2&PTR_MASK&~PAGE_MASK)))
address43include/asm-alpha/page.h#define PAGE_PTR(address)    \
address44include/asm-alpha/page.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address31include/asm-i386/page.h#define PAGE_DIR_OFFSET(base,address)  ((unsigned long*)((base)+\
address32include/asm-i386/page.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)*2&PTR_MASK&~PAGE_MASK)))
address34include/asm-i386/page.h#define PAGE_PTR(address)    \
address35include/asm-i386/page.h((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
address176include/linux/cdu31a.hunsigned char address        :4;
address211include/linux/cdu31a.hunsigned char address     :4;
address271include/linux/cdu31a.hunsigned char address     :4;
address215include/linux/fd.hint address; /* io address */
address11include/linux/fdreg.h#define FD_IOPORT fdc_state[fdc].address
address84include/linux/mm.hunsigned long (*nopage)(struct vm_area_struct * area, unsigned long address,
address86include/linux/mm.hunsigned long (*wppage)(struct vm_area_struct * area, unsigned long address,
address167include/linux/mm.hunsigned long address);
address177include/linux/mm.hextern void do_wp_page(struct vm_area_struct * vma, unsigned long address,
address179include/linux/mm.hextern void do_no_page(struct vm_area_struct * vma, unsigned long address,
address102include/linux/xd.hvoid (*init_controller)(u_char *address);
address109include/linux/xd.hstatic u_char xd_detect (u_char *controller,u_char **address);
address128include/linux/xd.hstatic void xd_dtc_init_controller (u_char *address);
address130include/linux/xd.hstatic void xd_wd_init_controller (u_char *address);
address132include/linux/xd.hstatic void xd_seagate_init_controller (u_char *address);
address134include/linux/xd.hstatic void xd_omti_init_controller (u_char *address);
address96kernel/bios32.cunsigned long address;
address108kernel/bios32.cunsigned long address;    /* %ebx */
address114kernel/bios32.c"=b" (address),
address123kernel/bios32.creturn address + entry;
address136kernel/bios32.cunsigned long address;
address151kernel/bios32.cpci_indirect.address = pcibios_entry;
address445kernel/bios32.cbios32_indirect.address = bios32_entry = check->fields.entry;
address18kernel/ldt.cvoid * address = current->ldt;
address24kernel/ldt.cif (!address) {
address25kernel/ldt.caddress = &default_ldt;
address33kernel/ldt.cmemcpy_tofs(ptr, address, size);
address30mm/filemap.cstatic unsigned long file_mmap_nopage(struct vm_area_struct * area, unsigned long address,
address38mm/filemap.caddress &= PAGE_MASK;
address39mm/filemap.cblock = address - area->vm_start + area->vm_offset;
address486mm/memory.cunsigned long address,int prot)
address493mm/memory.cprintk("put_page: trying to put page %08lx at %08lx\n",page,address);
address496mm/memory.cpage_table = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
address505mm/memory.cpage_table += (address >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
address522mm/memory.cunsigned long put_dirty_page(struct task_struct * tsk, unsigned long page, unsigned long address)
address527mm/memory.cprintk("put_dirty_page: trying to put page %08lx at %08lx\n",page,address);
address529mm/memory.cprintk("mem_map disagrees with %08lx at %08lx\n",page,address);
address530mm/memory.cpage_table = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
address544mm/memory.cpage_table += (address >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
address563mm/memory.cvoid do_wp_page(struct vm_area_struct * vma, unsigned long address,
address570mm/memory.cpde = PAGE_DIR_OFFSET(vma->vm_task->tss.cr3,address);
address577mm/memory.cpte += PAGE_PTR(address);
address610mm/memory.cprintk("do_wp_page: bogus page at address %08lx (%08lx)\n",address,old_page);
address615mm/memory.cprintk("do_wp_page: bogus page-table at address %08lx (%08lx)\n",address,pte);
address694mm/memory.cstatic inline void get_empty_page(struct task_struct * tsk, unsigned long address)
address702mm/memory.cif (!put_page(tsk,tmp,address,PAGE_PRIVATE))
address803mm/memory.cstatic int share_page(struct vm_area_struct * area, unsigned long address,
address821mm/memory.coffset = address - area->vm_start + area->vm_offset;
address838mm/memory.cif (!try_to_share(address, area, from_address, mpnt, give_page))
address852mm/memory.cstatic inline unsigned long get_empty_pgtable(struct task_struct * tsk,unsigned long address)
address857mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
address865mm/memory.cp = PAGE_DIR_OFFSET(tsk->tss.cr3,address);
address884mm/memory.cunsigned long address, unsigned long * pge, unsigned long entry)
address905mm/memory.cvoid do_no_page(struct vm_area_struct * vma, unsigned long address,
address910mm/memory.cpage = get_empty_pgtable(vma->vm_task,address);
address914mm/memory.cpage += PAGE_PTR(address);
address919mm/memory.cdo_swap_page(vma, address, (unsigned long *) page, entry);
address922mm/memory.caddress &= PAGE_MASK;
address927mm/memory.cget_empty_page(vma->vm_task,address);
address931mm/memory.cif (share_page(vma, address, error_code, page)) {
address938mm/memory.cput_page(vma->vm_task, BAD_PAGE, address, PAGE_PRIVATE);
address949mm/memory.cpage = vma->vm_ops->nopage(vma, address, page, (error_code & PAGE_RW) && (prot & PAGE_COW));
address950mm/memory.cif (share_page(vma, address, error_code, 0)) {
address962mm/memory.cif (put_page(vma->vm_task, page, address, prot))
address976mm/memory.cunsigned long address;
address980mm/memory.c__asm__("movl %%cr2,%0":"=r" (address));
address984mm/memory.cif (vma->vm_end > address)
address987mm/memory.cif (vma->vm_start <= address)
address991mm/memory.cif (vma->vm_end - address > current->rlim[RLIMIT_STACK].rlim_cur)
address993mm/memory.cvma->vm_offset -= vma->vm_start - (address & PAGE_MASK);
address994mm/memory.cvma->vm_start = (address & PAGE_MASK);
address1001mm/memory.cunsigned long bit = (address - 0xA0000) >> PAGE_SHIFT;
address1014mm/memory.cdo_wp_page(vma, address, error_code);
address1017mm/memory.cdo_no_page(vma, address, error_code);
address1026mm/memory.ccurrent->tss.cr2 = address;
address1036mm/memory.cif (wp_works_ok < 0 && address == TASK_SIZE && (error_code & PAGE_PRESENT)) {
address1043mm/memory.cif ((unsigned long) (address-TASK_SIZE) < PAGE_SIZE) {
address1048mm/memory.cprintk(" at virtual address %08lx\n",address);
address1052mm/memory.cpage = ((unsigned long *) page)[address >> 22];
address1056mm/memory.caddress &= 0x003ff000;
address1057mm/memory.cpage = ((unsigned long *) page)[address >> PAGE_SHIFT];
address1155mm/memory.cunsigned long address;
address1167mm/memory.caddress = 0;
address1169mm/memory.cwhile (address < end_mem) {
address1180mm/memory.cif (address < end_mem)
address1181mm/memory.c*pg_table = address | PAGE_SHARED;
address1184mm/memory.caddress += PAGE_SIZE;
address375mm/swap.cunsigned long address;
address384mm/swap.caddress = p->mm->swap_address;
address394mm/swap.cif (address <= vma->vm_end)
address398mm/swap.cif (address < vma->vm_start)
address399mm/swap.caddress = vma->vm_start;
address401mm/swap.cpgdir = (address >> PGDIR_SHIFT) + (unsigned long *) p->tss.cr3;
address402mm/swap.coffset = address & ~PGDIR_MASK;
address403mm/swap.caddress &= PGDIR_MASK;
address404mm/swap.cfor ( ; address < TASK_SIZE ;
address405mm/swap.cpgdir++, address = address + PGDIR_SIZE, offset = 0) {
address413mm/swap.cp->comm, address + offset, pg_table);
address427mm/swap.cif (address+offset < vma->vm_end)
address434mm/swap.cswitch(try_to_swap_out(vma, offset+address-vma->vm_start, (unsigned long *) (pg_table + (offset >> 10)))) {
address441mm/swap.cp->mm->swap_address = address + offset + PAGE_SIZE;
address74net/inet/igmp.cstatic void igmp_send_report(struct device *dev, unsigned long address, int type)
address82net/inet/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
address94net/inet/igmp.cigh->group=address;
address116net/inet/igmp.cstatic void igmp_heard_report(struct device *dev, unsigned long address)
address120net/inet/igmp.cif(im->multiaddr==address)
address759net/socket.cchar address[MAX_SOCK_ADDR];
address768net/socket.cif((err=move_addr_to_kernel(umyaddr,addrlen,address))<0)
address771net/socket.cif ((i = sock->ops->bind(sock, (struct sockaddr *)address, addrlen)) < 0) 
address819net/socket.cchar address[MAX_SOCK_ADDR];
address863net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
address864net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
address880net/socket.cchar address[MAX_SOCK_ADDR];
address888net/socket.cif((err=move_addr_to_kernel(uservaddr,addrlen,address))<0)
address914net/socket.ci = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, file->f_flags);
address930net/socket.cchar address[MAX_SOCK_ADDR];
address939net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
address942net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address955net/socket.cchar address[MAX_SOCK_ADDR];
address964net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
address967net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
address1007net/socket.cchar address[MAX_SOCK_ADDR];
address1021net/socket.cif((err=move_addr_to_kernel(addr,addr_len,address))<0)
address1025net/socket.cflags, (struct sockaddr *)address, addr_len));
address1071net/socket.cchar address[MAX_SOCK_ADDR];
address1088net/socket.cflags, (struct sockaddr *)address, &alen);
address1092net/socket.cif(addr!=NULL && (err=move_addr_to_user(address,alen, addr, addr_len))<0)