taglinefilesource code
entry95arch/i386/kernel/bios32.cunsigned long entry;    /* 32 bit physical address */
entry127arch/i386/kernel/bios32.cunsigned long entry;    /* %edx */
entry133arch/i386/kernel/bios32.c"=d" (entry)
entry140arch/i386/kernel/bios32.creturn address + entry;
entry438arch/i386/kernel/bios32.cif (check->fields.entry >= 0x100000) {
entry441arch/i386/kernel/bios32.cbios32_indirect.address = bios32_entry = check->fields.entry;
entry71arch/mips/kernel/jazzdma.cVDMA_PGTBL_ENTRY *entry = (VDMA_PGTBL_ENTRY *)vdma_pagetable_start;
entry99arch/mips/kernel/jazzdma.cwhile (entry[first].owner != VDMA_PAGE_EMPTY &&
entry106arch/mips/kernel/jazzdma.cwhile (entry[last].owner == VDMA_PAGE_EMPTY && last-first < pages)
entry120arch/mips/kernel/jazzdma.centry[i].frame = frame;
entry121arch/mips/kernel/jazzdma.centry[i].owner = laddr;
entry142arch/mips/kernel/jazzdma.cprintk("%08x ",entry[i].frame);
entry145arch/mips/kernel/jazzdma.cprintk("%08x ",entry[i].owner);
entry230arch/sparc/kernel/smp.cunsigned long *entry = &sparc_cpu_startup;
entry234arch/sparc/kernel/smp.centry += ((i-1) * 6);
entry237arch/sparc/kernel/smp.cprintk("Starting CPU %d at %p\n", i, entry);
entry241arch/sparc/kernel/smp.c&penguin_ctable, 0, (char *)entry);
entry148arch/sparc/kernel/sparc-stub.cunsigned long entry;
entry151arch/sparc/kernel/sparc-stub.c"=r" (entry) :
entry153arch/sparc/kernel/sparc-stub.creturn entry;
entry158arch/sparc/kernel/sparc-stub.cunsigned long entry;
entry161arch/sparc/kernel/sparc-stub.c"=r" (entry) :
entry163arch/sparc/kernel/sparc-stub.creturn entry;
entry885arch/sparc/kernel/sys_sunos.cstruct select_table_entry * entry = p->entry + p->nr;
entry889arch/sparc/kernel/sys_sunos.centry--;
entry890arch/sparc/kernel/sys_sunos.cremove_wait_queue(entry->wait_address,&entry->wait);
entry923arch/sparc/kernel/sys_sunos.cstruct select_table_entry *entry;
entry931arch/sparc/kernel/sys_sunos.cif (!(entry = (struct select_table_entry*)__get_free_page(GFP_KERNEL))
entry947arch/sparc/kernel/sys_sunos.cwait_table.entry = entry;
entry999arch/sparc/kernel/sys_sunos.cfree_page((unsigned long) entry);
entry338arch/sparc/mm/sun4c.cstatic inline void add_ring(struct sun4c_mmu_ring *ring, struct sun4c_mmu_entry *entry)
entry342arch/sparc/mm/sun4c.centry->prev = head;
entry343arch/sparc/mm/sun4c.c(entry->next = head->next)->prev = entry;
entry344arch/sparc/mm/sun4c.chead->next = entry;
entry348arch/sparc/mm/sun4c.cstatic inline void remove_ring(struct sun4c_mmu_ring *ring, struct sun4c_mmu_entry *entry)
entry350arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *next = entry->next;
entry352arch/sparc/mm/sun4c.c(next->prev = entry->prev)->next = next;
entry356arch/sparc/mm/sun4c.cstatic inline void recycle_ring(struct sun4c_mmu_ring *ring, struct sun4c_mmu_entry *entry)
entry359arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *next = entry->next;
entry361arch/sparc/mm/sun4c.c(next->prev = entry->prev)->next = next;
entry362arch/sparc/mm/sun4c.centry->prev = head; (entry->next = head->next)->prev = entry;
entry363arch/sparc/mm/sun4c.chead->next = entry;
entry367arch/sparc/mm/sun4c.cstatic inline void free_user_entry(int ctx, struct sun4c_mmu_entry *entry)
entry369arch/sparc/mm/sun4c.cremove_ring(sun4c_context_ring+ctx, entry);
entry370arch/sparc/mm/sun4c.cadd_ring(&sun4c_ufree_ring, entry);
entry373arch/sparc/mm/sun4c.cstatic inline void assign_user_entry(int ctx, struct sun4c_mmu_entry *entry) 
entry375arch/sparc/mm/sun4c.cremove_ring(&sun4c_ufree_ring, entry);
entry376arch/sparc/mm/sun4c.cadd_ring(sun4c_context_ring+ctx, entry);
entry379arch/sparc/mm/sun4c.cstatic inline void free_kernel_entry(struct sun4c_mmu_entry *entry, struct sun4c_mmu_ring *ring)
entry381arch/sparc/mm/sun4c.cremove_ring(ring, entry);
entry382arch/sparc/mm/sun4c.cadd_ring(&sun4c_kfree_ring, entry);
entry385arch/sparc/mm/sun4c.cstatic inline void assign_kernel_entry(struct sun4c_mmu_entry *entry, struct sun4c_mmu_ring *ring) 
entry387arch/sparc/mm/sun4c.cremove_ring(ring, entry);
entry388arch/sparc/mm/sun4c.cadd_ring(&sun4c_kernel_ring, entry);
entry391arch/sparc/mm/sun4c.cstatic inline void reassign_kernel_entry(struct sun4c_mmu_entry *entry)
entry393arch/sparc/mm/sun4c.crecycle_ring(&sun4c_kernel_ring, entry);
entry487arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *entry = crp->ringhd.next;
entry492arch/sparc/mm/sun4c.csun4c_user_unmap(entry);
entry493arch/sparc/mm/sun4c.cfree_user_entry(ctx, entry);
entry540arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *entry;
entry543arch/sparc/mm/sun4c.centry = sun4c_user_strategy();
entry544arch/sparc/mm/sun4c.cassign_user_entry(ctx, entry);
entry545arch/sparc/mm/sun4c.centry->vaddr = address;
entry546arch/sparc/mm/sun4c.csun4c_user_map(entry);
entry551arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *entry;
entry554arch/sparc/mm/sun4c.centry = sun4c_kernel_strategy();
entry556arch/sparc/mm/sun4c.cassign_kernel_entry(entry, &sun4c_kfree_ring);
entry557arch/sparc/mm/sun4c.centry->vaddr = address;
entry558arch/sparc/mm/sun4c.csun4c_kernel_map(entry);
entry673arch/sparc/mm/sun4c.cstruct sun4c_mmu_entry *entry;
entry680arch/sparc/mm/sun4c.centry = &mmu_entry_pool[pseg];
entry682arch/sparc/mm/sun4c.csun4c_kernel_unmap(entry);
entry683arch/sparc/mm/sun4c.cadd_ring(&sun4c_ufree_ring, entry);
entry687arch/sparc/mm/sun4c.cstatic inline void garbage_collect(int entry)
entry692arch/sparc/mm/sun4c.centry &= ~15;
entry693arch/sparc/mm/sun4c.cstart = entry;
entry698arch/sparc/mm/sun4c.cfree_task_segment(BUCKET_ADDR(entry));
entry704arch/sparc/mm/sun4c.cint entry;
entry714arch/sparc/mm/sun4c.cfor(entry = 0; entry < NR_TASKS; entry++)
entry715arch/sparc/mm/sun4c.cif(sun4c_bucket[entry] == BUCKET_EMPTY)
entry717arch/sparc/mm/sun4c.cif(entry == NR_TASKS) {
entry721arch/sparc/mm/sun4c.caddr = BUCKET_ADDR(entry);
entry722arch/sparc/mm/sun4c.csun4c_bucket[entry] = (struct task_bucket *) addr;
entry777arch/sparc/mm/sun4c.cint entry = BUCKET_NUM(tsaddr);
entry781arch/sparc/mm/sun4c.csun4c_bucket[entry] = BUCKET_EMPTY;
entry783arch/sparc/mm/sun4c.cgarbage_collect(entry);
entry788arch/sparc/mm/sun4c.cint entry;
entry794arch/sparc/mm/sun4c.cfor(entry = 0; entry < NR_TASKS; entry++)
entry795arch/sparc/mm/sun4c.csun4c_bucket[entry] = BUCKET_EMPTY;
entry1071drivers/cdrom/aztcd.cstruct cdrom_tocentry entry;
entry1228drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof entry);
entry1230drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof entry);
entry1232drivers/cdrom/aztcd.cmemcpy_fromfs(&entry, (void *) arg, sizeof entry);
entry1234drivers/cdrom/aztcd.cif (entry.cdte_track == CDROM_LEADOUT)
entry1236drivers/cdrom/aztcd.celse if (entry.cdte_track > DiskInfo.last
entry1237drivers/cdrom/aztcd.c|| entry.cdte_track < DiskInfo.first)
entry1241drivers/cdrom/aztcd.ctocPtr = &Toc[entry.cdte_track];
entry1242drivers/cdrom/aztcd.centry.cdte_adr = tocPtr -> ctrl_addr;
entry1243drivers/cdrom/aztcd.centry.cdte_ctrl = tocPtr -> ctrl_addr >> 4;
entry1244drivers/cdrom/aztcd.cif (entry.cdte_format == CDROM_LBA)
entry1245drivers/cdrom/aztcd.centry.cdte_addr.lba = azt_msf2hsg(&tocPtr -> diskTime);
entry1246drivers/cdrom/aztcd.celse if (entry.cdte_format == CDROM_MSF)
entry1247drivers/cdrom/aztcd.c{ entry.cdte_addr.msf.minute = azt_bcd2bin(tocPtr -> diskTime.min);
entry1248drivers/cdrom/aztcd.centry.cdte_addr.msf.second = azt_bcd2bin(tocPtr -> diskTime.sec);
entry1249drivers/cdrom/aztcd.centry.cdte_addr.msf.frame  = azt_bcd2bin(tocPtr -> diskTime.frame);
entry1254drivers/cdrom/aztcd.cmemcpy_tofs((void *) arg, &entry, sizeof entry);
entry2493drivers/cdrom/cdu31a.cstruct cdrom_tocentry *entry;
entry2504drivers/cdrom/cdu31a.centry = (struct cdrom_tocentry *) arg;
entry2505drivers/cdrom/cdu31a.ci=verify_area(VERIFY_READ, entry, sizeof(*entry));
entry2508drivers/cdrom/cdu31a.ci=verify_area(VERIFY_WRITE, entry, sizeof(*entry));
entry2512drivers/cdrom/cdu31a.cmemcpy_fromfs(&loc_entry, entry, sizeof(loc_entry));
entry2545drivers/cdrom/cdu31a.cmemcpy_tofs(entry, &loc_entry, sizeof(*entry));
entry941drivers/cdrom/cm206.cstruct cdrom_tocentry entry;
entry944drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(entry));
entry946drivers/cdrom/cm206.cmemcpy_fromfs(&entry, (struct cdrom_tocentry *) arg, sizeof entry);
entry947drivers/cdrom/cm206.cget_toc_entry(&entry);
entry948drivers/cdrom/cm206.cmemcpy_tofs((struct cdrom_tocentry *) arg, &entry, sizeof entry);
entry294drivers/cdrom/mcd.cstruct cdrom_tocentry entry;
entry463drivers/cdrom/mcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof entry);
entry467drivers/cdrom/mcd.cmemcpy_fromfs(&entry, (void *) arg, sizeof entry);
entry468drivers/cdrom/mcd.cif (entry.cdte_track == CDROM_LEADOUT)
entry472drivers/cdrom/mcd.celse if (entry.cdte_track > DiskInfo.last
entry473drivers/cdrom/mcd.c|| entry.cdte_track < DiskInfo.first)
entry477drivers/cdrom/mcd.ctocPtr = &Toc[entry.cdte_track];
entry479drivers/cdrom/mcd.centry.cdte_adr = tocPtr -> ctrl_addr;
entry480drivers/cdrom/mcd.centry.cdte_ctrl = tocPtr -> ctrl_addr >> 4;
entry482drivers/cdrom/mcd.cif (entry.cdte_format == CDROM_LBA)
entry483drivers/cdrom/mcd.centry.cdte_addr.lba = msf2hsg(&tocPtr -> diskTime);
entry485drivers/cdrom/mcd.celse if (entry.cdte_format == CDROM_MSF)
entry487drivers/cdrom/mcd.centry.cdte_addr.msf.minute = bcd2bin(tocPtr -> diskTime.min);
entry488drivers/cdrom/mcd.centry.cdte_addr.msf.second = bcd2bin(tocPtr -> diskTime.sec);
entry489drivers/cdrom/mcd.centry.cdte_addr.msf.frame = bcd2bin(tocPtr -> diskTime.frame);
entry495drivers/cdrom/mcd.cmemcpy_tofs((void *) arg, &entry, sizeof entry);
entry350drivers/cdrom/mcdx.cstruct cdrom_tocentry entry;
entry358drivers/cdrom/mcdx.cif ((ans = verify_area(VERIFY_READ, (void *) arg, sizeof(entry)))) return ans;
entry359drivers/cdrom/mcdx.cmemcpy_fromfs(&entry, (void *) arg, sizeof(entry));
entry361drivers/cdrom/mcdx.cif (entry.cdte_track == CDROM_LEADOUT) 
entry363drivers/cdrom/mcdx.celse if (entry.cdte_track > stuffp->di.n_last 
entry364drivers/cdrom/mcdx.c|| entry.cdte_track < stuffp->di.n_first) return -EINVAL;
entry365drivers/cdrom/mcdx.celse tp = &stuffp->toc[entry.cdte_track - stuffp->di.n_first];
entry369drivers/cdrom/mcdx.centry.cdte_adr = tp->control;
entry370drivers/cdrom/mcdx.centry.cdte_ctrl = tp->control >> 4;
entry372drivers/cdrom/mcdx.cif (entry.cdte_format == CDROM_MSF) {
entry373drivers/cdrom/mcdx.centry.cdte_addr.msf.minute = bcd2uint(tp->dt.minute);
entry374drivers/cdrom/mcdx.centry.cdte_addr.msf.second = bcd2uint(tp->dt.second);
entry375drivers/cdrom/mcdx.centry.cdte_addr.msf.frame = bcd2uint(tp->dt.frame);
entry376drivers/cdrom/mcdx.c} else if (entry.cdte_format == CDROM_LBA)
entry377drivers/cdrom/mcdx.centry.cdte_addr.lba = msf2log(&tp->dt);
entry380drivers/cdrom/mcdx.cif ((ans = verify_area(VERIFY_WRITE, (void*) arg, sizeof(entry)))) return ans;
entry381drivers/cdrom/mcdx.cmemcpy_tofs((void*) arg, &entry, sizeof(entry));
entry1521drivers/cdrom/optcd.cstruct cdrom_tocentry entry;
entry1524drivers/cdrom/optcd.cstatus = verify_area(VERIFY_READ, (void *) arg, sizeof entry);
entry1527drivers/cdrom/optcd.cstatus = verify_area(VERIFY_WRITE, (void *) arg, sizeof entry);
entry1530drivers/cdrom/optcd.cmemcpy_fromfs(&entry, (void *) arg, sizeof entry);
entry1532drivers/cdrom/optcd.cif (entry.cdte_track == CDROM_LEADOUT)
entry1534drivers/cdrom/optcd.celse if (entry.cdte_track > disk_info.last
entry1535drivers/cdrom/optcd.c|| entry.cdte_track < disk_info.first)
entry1538drivers/cdrom/optcd.ctocptr = &toc[entry.cdte_track];
entry1540drivers/cdrom/optcd.centry.cdte_adr = tocptr->cdsc_adr;
entry1541drivers/cdrom/optcd.centry.cdte_ctrl = tocptr->cdsc_ctrl;
entry1542drivers/cdrom/optcd.centry.cdte_addr.msf.minute = tocptr->cdsc_absaddr.msf.minute;
entry1543drivers/cdrom/optcd.centry.cdte_addr.msf.second = tocptr->cdsc_absaddr.msf.second;
entry1544drivers/cdrom/optcd.centry.cdte_addr.msf.frame = tocptr->cdsc_absaddr.msf.frame;
entry1547drivers/cdrom/optcd.cif (entry.cdte_format == CDROM_LBA)
entry1548drivers/cdrom/optcd.cmsf2lba(&entry.cdte_addr);
entry1549drivers/cdrom/optcd.celse if (entry.cdte_format != CDROM_MSF)
entry1552drivers/cdrom/optcd.cmemcpy_tofs((void *) arg, &entry, sizeof entry);
entry1224drivers/cdrom/sonycd535.cstruct cdrom_tocentry *entry;
entry1233drivers/cdrom/sonycd535.centry = (struct cdrom_tocentry *)arg;
entry1234drivers/cdrom/sonycd535.cerr = verify_area(VERIFY_WRITE /* and read */ , entry, sizeof *entry);
entry1238drivers/cdrom/sonycd535.cmemcpy_fromfs(&loc_entry, entry, sizeof loc_entry);
entry1262drivers/cdrom/sonycd535.cmemcpy_tofs(entry, &loc_entry, sizeof *entry);
entry38drivers/char/ftape/ecc.h#define BAD_CLEAR(entry) ((entry)=0)
entry39drivers/char/ftape/ecc.h#define BAD_SET(entry,sector) ((entry)|=(1<<(sector)))
entry40drivers/char/ftape/ecc.h#define BAD_CHECK(entry,sector) ((entry)&(1<<(sector)))
entry56drivers/char/ftape/ftape-eof.cunsigned long entry;
entry233drivers/char/ftape/ftape-eof.cptr->entry = new.entry;
entry242drivers/char/ftape/ftape-eof.cptr->entry = new.entry;
entry250drivers/char/ftape/ftape-eof.cptr->entry = new.entry;
entry129drivers/char/lp_intern.cint lp_internal_init(struct lp_struct *lp_table, int entry,
entry132drivers/char/lp_intern.cif (max_lp-entry < 1)
entry153drivers/char/lp_intern.clp_table[entry].name = "Builtin LP";
entry154drivers/char/lp_intern.clp_table[entry].lp_out = lp_int_out;
entry155drivers/char/lp_intern.clp_table[entry].lp_is_busy = lp_int_busy;
entry156drivers/char/lp_intern.clp_table[entry].lp_has_pout = lp_int_pout;
entry157drivers/char/lp_intern.clp_table[entry].lp_is_online = lp_int_online;
entry158drivers/char/lp_intern.clp_table[entry].lp_my_interrupt = lp_int_interrupt;
entry159drivers/char/lp_intern.clp_table[entry].flags = LP_EXIST;
entry160drivers/char/lp_intern.clp_table[entry].chars = LP_INIT_CHAR;
entry161drivers/char/lp_intern.clp_table[entry].time = LP_INIT_TIME;
entry162drivers/char/lp_intern.clp_table[entry].wait = LP_INIT_WAIT;
entry163drivers/char/lp_intern.clp_table[entry].lp_wait_q = NULL;
entry165drivers/char/lp_intern.cprintk("lp%d: internal port\n", entry);
entry184drivers/isdn/pcbit/edss1.cstruct isdn_event_desc * entry;
entry186drivers/isdn/pcbit/edss1.cfor (entry = isdn_event_table; entry->ev; entry++)
entry187drivers/isdn/pcbit/edss1.cif (entry->ev == ev)
entry190drivers/isdn/pcbit/edss1.creturn entry->desc;
entry410drivers/net/a2065.cint entry = dirty_tx % TX_RING_SIZE;
entry412drivers/net/a2065.cpriv->tx_ring[entry]->TMD1 & 0xff00;
entry417drivers/net/a2065.cpriv->tx_ring[entry]->TMD1 &= 0x00ff;
entry422drivers/net/a2065.cpriv->tx_ring[entry]->TMD3;
entry496drivers/net/a2065.cint entry;
entry593drivers/net/a2065.centry = priv->cur_tx % TX_RING_SIZE;
entry595drivers/net/a2065.cpriv->tx_ring[entry]->TMD2 = -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
entry596drivers/net/a2065.cpriv->tx_ring[entry]->TMD3 = 0x0000;
entry597drivers/net/a2065.cmemcpy(priv->tx_buff[entry], skb->data, skb->len);
entry610drivers/net/a2065.cprintk("%02x", priv->tx_buff[entry][i+j]);
entry617drivers/net/a2065.cpriv->tx_ring[entry]->TMD1 = (priv->tx_ring[entry]->TMD1 &
entry642drivers/net/a2065.cif ((priv->tx_ring[(entry+1) % TX_RING_SIZE]->TMD1 & 0xff00) == 0)
entry655drivers/net/a2065.cint entry = priv->cur_rx % RX_RING_SIZE;
entry659drivers/net/a2065.cwhile (!(priv->rx_ring[entry]->RMD1 & RF_OWN)) {
entry660drivers/net/a2065.cint status = priv->rx_ring[entry]->RMD1 & 0xff00;
entry678drivers/net/a2065.cpriv->rx_ring[entry]->RMD1 &= 0x00ff|RF_STP|RF_ENP;
entry681drivers/net/a2065.cshort pkt_len = priv->rx_ring[entry]->RMD3;
entry695drivers/net/a2065.cif (priv->rx_ring[(entry+i) % RX_RING_SIZE]->RMD1 & RF_OWN)
entry700drivers/net/a2065.cpriv->rx_ring[entry]->RMD1 |= RF_OWN;
entry709drivers/net/a2065.cpriv->rx_buff[entry],
entry736drivers/net/a2065.cpriv->rx_ring[entry]->RMD1 |= RF_OWN;
entry737drivers/net/a2065.centry = (++priv->cur_rx) % RX_RING_SIZE;
entry457drivers/net/ariadne.cint entry = dirty_tx % TX_RING_SIZE;
entry458drivers/net/ariadne.cint status = lowb(priv->tx_ring[entry]->TMD1);
entry463drivers/net/ariadne.cpriv->tx_ring[entry]->TMD1 &= 0xff00;
entry467drivers/net/ariadne.cint err_status = priv->tx_ring[entry]->TMD3;
entry543drivers/net/ariadne.cint entry;
entry632drivers/net/ariadne.centry = priv->cur_tx % TX_RING_SIZE;
entry637drivers/net/ariadne.cpriv->tx_ring[entry]->TMD2 = swapw((u_short)-skb->len);
entry638drivers/net/ariadne.cpriv->tx_ring[entry]->TMD3 = 0x0000;
entry639drivers/net/ariadne.cmemcpyw(priv->tx_buff[entry], (u_short *)skb->data, skb->len);
entry653drivers/net/ariadne.cprintk("%04x", priv->tx_buff[entry][i+j]);
entry660drivers/net/ariadne.cpriv->tx_ring[entry]->TMD1 = (priv->tx_ring[entry]->TMD1&0xff00)|TF_OWN|TF_STP|TF_ENP;
entry684drivers/net/ariadne.cif (lowb(priv->tx_ring[(entry+1) % TX_RING_SIZE]->TMD1) == 0)
entry697drivers/net/ariadne.cint entry = priv->cur_rx % RX_RING_SIZE;
entry701drivers/net/ariadne.cwhile (!(lowb(priv->rx_ring[entry]->RMD1) & RF_OWN)) {
entry702drivers/net/ariadne.cint status = lowb(priv->rx_ring[entry]->RMD1);
entry720drivers/net/ariadne.cpriv->rx_ring[entry]->RMD1 &= 0xff00|RF_STP|RF_ENP;
entry723drivers/net/ariadne.cshort pkt_len = swapw(priv->rx_ring[entry]->RMD3);
entry730drivers/net/ariadne.cif (lowb(priv->rx_ring[(entry+i) % RX_RING_SIZE]->RMD1) & RF_OWN)
entry735drivers/net/ariadne.cpriv->rx_ring[entry]->RMD1 |= RF_OWN;
entry745drivers/net/ariadne.ceth_copy_and_sum(skb, (char *)priv->rx_buff[entry], pkt_len,0);
entry769drivers/net/ariadne.cpriv->rx_ring[entry]->RMD1 |= RF_OWN;
entry770drivers/net/ariadne.centry = (++priv->cur_rx) % RX_RING_SIZE;
entry717drivers/net/atarilance.cint entry, len;
entry808drivers/net/atarilance.centry = lp->cur_tx & TX_RING_MOD_MASK;
entry809drivers/net/atarilance.chead  = &(MEM->tx_head[entry]);
entry837drivers/net/atarilance.cif ((MEM->tx_head[(entry+1) & TX_RING_MOD_MASK].flag & TMD1_OWN) ==
entry884drivers/net/atarilance.cint entry = dirty_tx & TX_RING_MOD_MASK;
entry885drivers/net/atarilance.cint status = MEM->tx_head[entry].flag;
entry890drivers/net/atarilance.cMEM->tx_head[entry].flag = 0;
entry894drivers/net/atarilance.cint err_status = MEM->tx_head[entry].misc;
entry961drivers/net/atarilance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
entry965drivers/net/atarilance.cMEM->rx_head[entry].flag ));
entry968drivers/net/atarilance.cwhile( (MEM->rx_head[entry].flag & RMD1_OWN) == RMD1_OWN_HOST ) {
entry969drivers/net/atarilance.cstruct lance_rx_head *head = &(MEM->rx_head[entry]);
entry999drivers/net/atarilance.cif (MEM->rx_head[(entry+i) & RX_RING_MOD_MASK].flag &
entry1038drivers/net/atarilance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
entry1212drivers/net/de4x5.cint i, entry;
entry1216drivers/net/de4x5.cfor (entry=lp->rx_new; lp->rx_ring[entry].status>=0;entry=lp->rx_new) {
entry1217drivers/net/de4x5.cstatus = lp->rx_ring[entry].status;
entry1220drivers/net/de4x5.clp->rx_old = entry;
entry1237drivers/net/de4x5.cshort pkt_len = (short)(lp->rx_ring[entry].status >> 16) - 4;
entry1239drivers/net/de4x5.cif ((skb = de4x5_alloc_rx_buff(dev, entry, pkt_len)) == NULL) {
entry1278drivers/net/de4x5.cfor (;lp->rx_old!=entry;lp->rx_old=(++lp->rx_old)%lp->rxRingSize) {
entry1282drivers/net/de4x5.clp->rx_ring[entry].status = R_OWN;
entry1303drivers/net/de4x5.cint entry;
entry1306drivers/net/de4x5.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
entry1307drivers/net/de4x5.cstatus = lp->tx_ring[entry].status;
entry1332drivers/net/de4x5.cif (lp->tx_skb[entry] != NULL) {
entry1333drivers/net/de4x5.cdev_kfree_skb(lp->tx_skb[entry], FREE_WRITE);
entry1334drivers/net/de4x5.clp->tx_skb[entry] = NULL;
entry895drivers/net/depca.cint i, entry;
entry898drivers/net/depca.cfor (entry=lp->rx_new; 
entry899drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
entry900drivers/net/depca.centry=lp->rx_new){
entry901drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
entry903drivers/net/depca.clp->rx_old = entry;
entry913drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
entry922drivers/net/depca.cif (entry < lp->rx_old) {         /* Wrapped buffer */
entry972drivers/net/depca.cfor (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
entry976drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
entry995drivers/net/depca.cint entry;
entry999drivers/net/depca.cfor (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
entry1000drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
entry1005drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].misc);
entry1537drivers/net/depca.cint i, entry, end, len, status = 0;
entry1539drivers/net/depca.centry = lp->tx_new;                     /* Ring around buffer number. */
entry1540drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
entry1546drivers/net/depca.cif (end < entry) {                         /* wrapped buffer */
entry1547drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
entry1548drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
entry1551drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
entry1556drivers/net/depca.cfor (i = entry; i != end; i = (++i) & lp->txRingMask) {
entry1569drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
entry1573drivers/net/depca.cfor (i=end; i!=entry; --i) {
entry1578drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
entry758drivers/net/lance.cint entry;
entry828drivers/net/lance.centry = lp->cur_tx & TX_RING_MOD_MASK;
entry835drivers/net/lance.clp->tx_ring[entry].length =
entry838drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
entry840drivers/net/lance.clp->tx_ring[entry].misc = 0x0000;
entry848drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
entry849drivers/net/lance.clp->tx_ring[entry].base =
entry850drivers/net/lance.c((u32)virt_to_bus((lp->tx_bounce_buffs + entry)) & 0xffffff) | 0x83000000;
entry853drivers/net/lance.clp->tx_skbuff[entry] = skb;
entry854drivers/net/lance.clp->tx_ring[entry].base = ((u32)virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
entry867drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
entry916drivers/net/lance.cint entry = dirty_tx & TX_RING_MOD_MASK;
entry917drivers/net/lance.cint status = lp->tx_ring[entry].base;
entry922drivers/net/lance.clp->tx_ring[entry].base = 0;
entry926drivers/net/lance.cint err_status = lp->tx_ring[entry].misc;
entry948drivers/net/lance.cif (lp->tx_skbuff[entry]) {
entry949drivers/net/lance.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
entry950drivers/net/lance.clp->tx_skbuff[entry] = 0;
entry1009drivers/net/lance.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
entry1013drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
entry1014drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
entry1027drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
entry1032drivers/net/lance.cshort pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
entry1047drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
entry1053drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
entry1062drivers/net/lance.c(unsigned char *)bus_to_virt((lp->rx_ring[entry].base & 0x00ffffff)),
entry1071drivers/net/lance.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
entry1072drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
entry1073drivers/net/lance.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
entry448drivers/net/lance32.cint entry;
entry518drivers/net/lance32.centry = lp->cur_tx & TX_RING_MOD_MASK;
entry523drivers/net/lance32.clp->tx_ring[entry].length = -skb->len;
entry525drivers/net/lance32.clp->tx_ring[entry].misc = 0x00000000;
entry527drivers/net/lance32.clp->tx_skbuff[entry] = skb;
entry528drivers/net/lance32.clp->tx_ring[entry].base = (u32)virt_to_bus(skb->data);
entry529drivers/net/lance32.clp->tx_ring[entry].status = 0x8300;
entry542drivers/net/lance32.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
entry591drivers/net/lance32.cint entry = dirty_tx & TX_RING_MOD_MASK;
entry592drivers/net/lance32.cint status = lp->tx_ring[entry].status;
entry597drivers/net/lance32.clp->tx_ring[entry].base = 0;
entry601drivers/net/lance32.cint err_status = lp->tx_ring[entry].misc;
entry622drivers/net/lance32.cif (lp->tx_skbuff[entry]) {
entry623drivers/net/lance32.cdev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
entry624drivers/net/lance32.clp->tx_skbuff[entry] = 0;
entry683drivers/net/lance32.cint entry = lp->cur_rx & RX_RING_MOD_MASK;
entry687drivers/net/lance32.cwhile (lp->rx_ring[entry].status >= 0) {
entry688drivers/net/lance32.cint status = lp->rx_ring[entry].status >> 8;
entry701drivers/net/lance32.clp->rx_ring[entry].status &= 0x03ff;
entry706drivers/net/lance32.cshort pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
entry721drivers/net/lance32.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].status < 0)
entry727drivers/net/lance32.clp->rx_ring[entry].status |= 0x8000;
entry736drivers/net/lance32.c(unsigned char *)bus_to_virt(lp->rx_ring[entry].base),
entry745drivers/net/lance32.clp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
entry746drivers/net/lance32.clp->rx_ring[entry].status |= 0x8000;
entry747drivers/net/lance32.centry = (++lp->cur_rx) & RX_RING_MOD_MASK;
entry649drivers/net/sunlance.cint entry, skblen, len;
entry704drivers/net/sunlance.centry = lp->tx_new & TX_RING_MOD_MASK;
entry705drivers/net/sunlance.cib->btx_ring [entry].length = (-len) | 0xf000;
entry706drivers/net/sunlance.cib->btx_ring [entry].misc = 0;
entry708drivers/net/sunlance.cmemcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
entry712drivers/net/sunlance.cmemset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
entry715drivers/net/sunlance.cib->btx_ring [entry].tmd1_bits = (LE_T1_POK|LE_T1_OWN);
entry775drivers/net/tulip.cint entry;
entry837drivers/net/tulip.centry = tp->cur_tx % TX_RING_SIZE;
entry840drivers/net/tulip.ctp->tx_skbuff[entry] = skb;
entry841drivers/net/tulip.ctp->tx_ring[entry].length = skb->len |
entry842drivers/net/tulip.c(entry == TX_RING_SIZE-1 ? 0xe2000000 : 0xe0000000);
entry843drivers/net/tulip.ctp->tx_ring[entry].buffer1 = virt_to_bus(skb->data);
entry844drivers/net/tulip.ctp->tx_ring[entry].buffer2 = 0;
entry845drivers/net/tulip.ctp->tx_ring[entry].status = TRING_OWN;  /* Pass ownership to the chip. */
entry891drivers/net/tulip.cint entry = dirty_tx % TX_RING_SIZE;
entry892drivers/net/tulip.cint status = lp->tx_ring[entry].status;
entry918drivers/net/tulip.cdev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE);
entry981drivers/net/tulip.cint entry = lp->cur_rx % RX_RING_SIZE;
entry985drivers/net/tulip.cwhile (lp->rx_ring[entry].status >= 0) {
entry986drivers/net/tulip.cint status = lp->rx_ring[entry].status;
entry1000drivers/net/tulip.cshort pkt_len = lp->rx_ring[entry].status >> 16;
entry1010drivers/net/tulip.cif (lp->rx_ring[(entry+i) % RX_RING_SIZE].status < 0)
entry1015drivers/net/tulip.clp->rx_ring[entry].status = TRING_OWN;
entry1023drivers/net/tulip.cbus_to_virt(lp->rx_ring[entry].buffer1), pkt_len);
entry1030drivers/net/tulip.clp->rx_ring[entry].status = TRING_OWN;
entry1031drivers/net/tulip.centry = (++lp->cur_rx) % RX_RING_SIZE;
entry744drivers/sbus/char/suncons.cregister unsigned long entry;
entry747drivers/sbus/char/suncons.c"=r" (entry):
entry749drivers/sbus/char/suncons.creturn entry;
entry42drivers/scsi/scsi_proc.cstruct proc_dir_entry entry;
entry119drivers/scsi/scsi_proc.cscsi_hba_dir->entry.low_ino = PROC_SCSI_FILE + hpnt->host_no;
entry120drivers/scsi/scsi_proc.cscsi_hba_dir->entry.namelen = sprintf(scsi_hba_dir->name,"%d",
entry122drivers/scsi/scsi_proc.cscsi_hba_dir->entry.name = scsi_hba_dir->name;
entry123drivers/scsi/scsi_proc.cscsi_hba_dir->entry.mode = S_IFREG | S_IRUGO | S_IWUSR;
entry124drivers/scsi/scsi_proc.cproc_scsi_register(tpnt->proc_dir, &scsi_hba_dir->entry);
entry340fs/fat/misc.cdone = !strncmp(data[entry].name,name,MSDOS_NAME) && \
entry341fs/fat/misc.c!(data[entry].attr & ATTR_VOLUME);
entry344fs/fat/misc.cdone = !IS_FREE(data[entry].name) && CF_LE_W(data[entry].start) == *number;
entry348fs/fat/misc.cdone = IS_FREE(data[entry].name); \
entry350fs/fat/misc.cinode = iget(sb,sector*MSDOS_DPS+entry); \
entry362fs/fat/misc.cif (!IS_FREE(data[entry].name) && (data[entry].attr & ATTR_DIR)) \
entry373fs/fat/misc.cint entry,start,done;
entry377fs/fat/misc.cfor (entry = 0; entry < MSDOS_DPS; entry++) {
entry382fs/fat/misc.cdone = (data[entry].attr & ATTR_HIDDEN)
entry394fs/fat/misc.cif (ino) *ino = sector*MSDOS_DPS+entry;
entry395fs/fat/misc.cstart = CF_LE_W(data[entry].start);
entry399fs/fat/misc.c*res_de = &data[entry];
entry38fs/ncpfs/dir.cint cache_size, struct ncp_dirent *entry);
entry217fs/ncpfs/dir.cstruct ncp_dirent *entry = NULL;
entry277fs/ncpfs/dir.centry = &c_entry[i];
entry283fs/ncpfs/dir.cif ((entry == NULL) && c_seen_eof)
entry289fs/ncpfs/dir.cif (entry == NULL)
entry323fs/ncpfs/dir.centry = c_entry;
entry334fs/ncpfs/dir.cif (entry == NULL)
entry346fs/ncpfs/dir.cino = (ino_t)(entry->i.DosDirNum);
entry356fs/ncpfs/dir.centry->i.entryName);
entry368fs/ncpfs/dir.cDDPRINTK("ncp_readdir: entry->path= %s\n", entry->i.entryName);
entry369fs/ncpfs/dir.cDDPRINTK("ncp_readdir: entry->f_pos = %ld\n", entry->f_pos);
entry371fs/ncpfs/dir.cif (filldir(dirent, entry->i.entryName, entry->i.nameLen,
entry372fs/ncpfs/dir.centry->f_pos, ino) < 0)
entry379fs/ncpfs/dir.c|| (entry->f_pos != filp->f_pos))
entry387fs/ncpfs/dir.centry += 1;
entry397fs/ncpfs/dir.cstruct ncp_dirent *entry = c_entry;
entry437fs/ncpfs/dir.c&(entry->i)) != 0)
entry444fs/ncpfs/dir.centry->f_pos = total_count;
entry445fs/ncpfs/dir.centry += 1;
entry455fs/ncpfs/dir.cint cache_size, struct ncp_dirent *entry)
entry494fs/ncpfs/dir.c&(entry->i)) != 0)
entry502fs/ncpfs/dir.centry->i.entryName);
entry507fs/ncpfs/dir.centry->i.entryName, fpos, total_count);
entry508fs/ncpfs/dir.centry->s = seq;
entry509fs/ncpfs/dir.centry->f_pos = total_count;
entry510fs/ncpfs/dir.centry += 1;
entry327fs/ncpfs/sock.cstruct select_table_entry entry;
entry403fs/ncpfs/sock.cwait_table.entry = &entry;
entry422fs/ncpfs/sock.cremove_wait_queue(entry.wait_address, &entry.wait);
entry456fs/ncpfs/sock.cremove_wait_queue(entry.wait_address, &entry.wait);
entry118fs/nfs/dir.cstruct nfs_entry *entry;
entry149fs/nfs/dir.centry = NULL;
entry161fs/nfs/dir.centry = c_entry + (index = i + 1);
entry169fs/nfs/dir.cif (!entry) {
entry180fs/nfs/dir.centry = c_entry + (index = 0);
entry185fs/nfs/dir.cif (!entry)
entry188fs/nfs/dir.cint nextpos = entry->cookie;
entry189fs/nfs/dir.cif (filldir(dirent, entry->name, strlen(entry->name), filp->f_pos, entry->fileid) < 0)
entry197fs/nfs/dir.cif (nextpos != entry->cookie)
entry200fs/nfs/dir.centry++;
entry248fs/nfs/dir.cstruct nfs_lookup_cache_entry *entry;
entry252fs/nfs/dir.centry = nfs_lookup_cache + i;
entry253fs/nfs/dir.cif (entry->dev == dir->i_dev
entry254fs/nfs/dir.c&& entry->inode == dir->i_ino
entry255fs/nfs/dir.c&& !strncmp(filename, entry->filename, NFS_MAXNAMLEN))
entry256fs/nfs/dir.creturn entry;
entry267fs/nfs/dir.cstruct nfs_lookup_cache_entry *entry;
entry273fs/nfs/dir.cif ((entry = nfs_lookup_cache_index(dir, filename))) {
entry274fs/nfs/dir.cif (jiffies > entry->expiration_date) {
entry275fs/nfs/dir.centry->dev = 0;
entry278fs/nfs/dir.c*fhandle = entry->fhandle;
entry279fs/nfs/dir.c*fattr = entry->fattr;
entry290fs/nfs/dir.cstruct nfs_lookup_cache_entry *entry;
entry296fs/nfs/dir.cif (!(entry = nfs_lookup_cache_index(dir, filename))) {
entry297fs/nfs/dir.centry = nfs_lookup_cache + nfs_lookup_cache_pos++;
entry301fs/nfs/dir.centry->dev = dir->i_dev;
entry302fs/nfs/dir.centry->inode = dir->i_ino;
entry303fs/nfs/dir.cstrcpy(entry->filename, filename);
entry304fs/nfs/dir.centry->fhandle = *fhandle;
entry305fs/nfs/dir.centry->fattr = *fattr;
entry306fs/nfs/dir.centry->expiration_date = jiffies + (S_ISDIR(fattr->mode)
entry313fs/nfs/dir.cstruct nfs_lookup_cache_entry *entry;
entry322fs/nfs/dir.celse if ((entry = nfs_lookup_cache_index(dir, filename))) {
entry323fs/nfs/dir.cdev = entry->dev;
entry324fs/nfs/dir.cfileid = entry->fattr.fileid;
entry329fs/nfs/dir.centry = nfs_lookup_cache + i;
entry330fs/nfs/dir.cif (entry->dev == dev && entry->fattr.fileid == fileid)
entry331fs/nfs/dir.centry->dev = 0;
entry338fs/nfs/dir.cstruct nfs_lookup_cache_entry *entry;
entry344fs/nfs/dir.centry = nfs_lookup_cache + i;
entry345fs/nfs/dir.cif (entry->dev == dev && entry->fattr.fileid == fileid)
entry346fs/nfs/dir.centry->fattr = *fattr;
entry199fs/nfs/proc.cstatic int *xdr_decode_entry(int *p, struct nfs_entry *entry)
entry201fs/nfs/proc.centry->fileid = ntohl(*p++);
entry202fs/nfs/proc.cif (!(p = xdr_decode_string(p, entry->name, NFS_MAXNAMLEN)))
entry204fs/nfs/proc.centry->cookie = ntohl(*p++);
entry205fs/nfs/proc.centry->eof = 0;
entry803fs/nfs/proc.cint cookie, int count, struct nfs_entry *entry)
entry829fs/nfs/proc.cif (!(p = xdr_decode_entry(p, entry++)))
entry840fs/nfs/proc.centry[-1].eof = 1;
entry163fs/nfs/rpcsock.cstruct select_table_entry entry;
entry169fs/nfs/rpcsock.cwait_table.entry = &entry;
entry174fs/nfs/rpcsock.cremove_wait_queue(entry.wait_address, &entry.wait);
entry181fs/nfs/rpcsock.cremove_wait_queue(entry.wait_address, &entry.wait);
entry50fs/select.cstruct select_table_entry * entry = p->entry + p->nr;
entry54fs/select.centry--;
entry55fs/select.cremove_wait_queue(entry->wait_address,&entry->wait);
entry90fs/select.cstruct select_table_entry *entry;
entry114fs/select.cif(!(entry = (struct select_table_entry*) __get_free_page(GFP_KERNEL)))
entry121fs/select.cwait_table.entry = entry;
entry148fs/select.cfree_page((unsigned long) entry);
entry163fs/smbfs/dir.cstruct smb_dirent *entry = NULL;
entry205fs/smbfs/dir.centry = &c_entry[i];
entry211fs/smbfs/dir.cif ((entry == NULL) && c_seen_eof)
entry215fs/smbfs/dir.cif (entry == NULL) {
entry230fs/smbfs/dir.centry = c_entry;
entry248fs/smbfs/dir.cif (entry == NULL) {
entry265fs/smbfs/dir.clen = strlen(entry->path);
entry266fs/smbfs/dir.cif ((result = get_pname_static(inode, entry->path, len,
entry280fs/smbfs/dir.cDDPRINTK("smb_readdir: entry->path = %s\n", entry->path);
entry281fs/smbfs/dir.cDDPRINTK("smb_readdir: entry->f_pos = %ld\n", entry->f_pos);
entry283fs/smbfs/dir.cif (filldir(dirent, entry->path, len,
entry284fs/smbfs/dir.centry->f_pos, (ino_t)ino_info) < 0) {
entry289fs/smbfs/dir.c|| (entry->f_pos != filp->f_pos)) {
entry296fs/smbfs/dir.centry += 1;
entry767fs/smbfs/dir.cstruct smb_dirent entry;
entry783fs/smbfs/dir.centry.attr  = 0;
entry784fs/smbfs/dir.centry.ctime = CURRENT_TIME;
entry785fs/smbfs/dir.centry.atime = CURRENT_TIME;
entry786fs/smbfs/dir.centry.mtime = CURRENT_TIME;
entry787fs/smbfs/dir.centry.size  = 0;
entry789fs/smbfs/dir.cerror = smb_proc_create(SMB_SERVER(dir), path, len, &entry);
entry798fs/smbfs/dir.cif (!(*result = smb_iget(dir, path, &entry)) < 0) {
entry535fs/smbfs/proc.cstruct smb_dirent *entry)
entry579fs/smbfs/proc.centry->fileid = WVAL(buf, smb_vwv0);
entry580fs/smbfs/proc.centry->attr   = WVAL(buf, smb_vwv1);
entry581fs/smbfs/proc.centry->ctime = entry->atime =
entry582fs/smbfs/proc.centry->mtime = local2utc(DVAL(buf, smb_vwv2));
entry583fs/smbfs/proc.centry->size   = DVAL(buf, smb_vwv4);
entry584fs/smbfs/proc.centry->access = WVAL(buf, smb_vwv6);
entry588fs/smbfs/proc.centry->access &= 3;
entry589fs/smbfs/proc.cDPRINTK("smb_proc_open: entry->access = %d\n", entry->access);
entry761fs/smbfs/proc.cstruct smb_dirent *entry, word command)
entry770fs/smbfs/proc.cWSET(buf, smb_vwv0, entry->attr);
entry771fs/smbfs/proc.cDSET(buf, smb_vwv1, utc2local(entry->ctime));
entry782fs/smbfs/proc.centry->opened = 1;
entry783fs/smbfs/proc.centry->fileid = WVAL(buf, smb_vwv0);
entry786fs/smbfs/proc.csmb_proc_close(server, entry);
entry793fs/smbfs/proc.cstruct smb_dirent *entry)
entry795fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBcreate);
entry800fs/smbfs/proc.cstruct smb_dirent *entry)
entry802fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBmknew);
entry923fs/smbfs/proc.csmb_decode_dirent(char *p, struct smb_dirent *entry)
entry926fs/smbfs/proc.centry->attr = BVAL(p, 0);
entry927fs/smbfs/proc.centry->mtime = entry->atime = entry->ctime =
entry929fs/smbfs/proc.centry->size = DVAL(p, 5);
entry930fs/smbfs/proc.cmemcpy(entry->path, p+9, 13);
entry931fs/smbfs/proc.cDDPRINTK("smb_decode_dirent: path = %s\n", entry->path);
entry941fs/smbfs/proc.cint cache_size, struct smb_dirent *entry)
entry970fs/smbfs/proc.ccurrent_entry = entry;
entry1047fs/smbfs/proc.c"%lu\n", entry->f_pos);  
entry1145fs/smbfs/proc.cint cache_size, struct smb_dirent *entry)
entry1191fs/smbfs/proc.ccurrent_entry = entry;
entry1335fs/smbfs/proc.c"%lu\n", entry->f_pos);  
entry1373fs/smbfs/proc.cint cache_size, struct smb_dirent *entry)
entry1377fs/smbfs/proc.centry);
entry1380fs/smbfs/proc.centry);
entry1385fs/smbfs/proc.cstruct smb_dirent *entry)
entry1407fs/smbfs/proc.centry->attr         = WVAL(buf, smb_vwv0);
entry1408fs/smbfs/proc.centry->ctime = entry->atime = /* The server only tells us 1 time */
entry1409fs/smbfs/proc.centry->mtime = local2utc(DVAL(buf, smb_vwv1));
entry1411fs/smbfs/proc.centry->size         = DVAL(buf, smb_vwv3);
entry1419fs/smbfs/proc.csmb_proc_getattrE(struct smb_server *server, struct smb_dirent *entry)
entry1425fs/smbfs/proc.cWSET(buf, smb_vwv0, entry->fileid);
entry1432fs/smbfs/proc.centry->ctime = date_dos2unix(WVAL(buf, smb_vwv1), WVAL(buf, smb_vwv0));
entry1433fs/smbfs/proc.centry->atime = date_dos2unix(WVAL(buf, smb_vwv3), WVAL(buf, smb_vwv2));
entry1434fs/smbfs/proc.centry->mtime = date_dos2unix(WVAL(buf, smb_vwv5), WVAL(buf, smb_vwv4));
entry1435fs/smbfs/proc.centry->size  = DVAL(buf, smb_vwv6);
entry1436fs/smbfs/proc.centry->attr  = WVAL(buf, smb_vwv10);
entry1444fs/smbfs/proc.cstruct smb_dirent *entry)
entry1455fs/smbfs/proc.creturn smb_proc_getattr_core(server,path,len,entry);
entry1459fs/smbfs/proc.centry->attr  = temp_entry.attr;
entry1460fs/smbfs/proc.centry->atime = temp_entry.atime;
entry1461fs/smbfs/proc.centry->mtime = temp_entry.mtime;
entry1462fs/smbfs/proc.centry->ctime = temp_entry.ctime;
entry1463fs/smbfs/proc.centry->size  = temp_entry.size;
entry1470fs/smbfs/proc.creturn smb_proc_getattr_core(server, path, len, entry);
entry166fs/umsdos/dir.cstruct umsdos_dirent entry;
entry168fs/umsdos/dir.cif (umsdos_emd_dir_readentry (emd_dir,filp,&entry)!=0){
entry171fs/umsdos/dir.c}else if (entry.name_len != 0){
entry193fs/umsdos/dir.cumsdos_parse (entry.name,entry.name_len,&info);
entry199fs/umsdos/dir.c,info.fake.fname,lret,entry.flags));
entry201fs/umsdos/dir.c&& (entry.flags & UMSDOS_HLINK)
entry217fs/umsdos/dir.c|| !(entry.flags & UMSDOS_HIDDEN))){
entry219fs/umsdos/dir.c,entry.name,entry.name_len
entry224fs/umsdos/dir.cif (u_entry != NULL) *u_entry = entry;
entry275fs/umsdos/dir.cstruct umsdos_dirent entry;
entry277fs/umsdos/dir.cret = umsdos_readdir_x (dir,filp,&bufk,0,&entry,1,umsdos_dir_once);
entry291fs/umsdos/dir.cstruct umsdos_dirent *entry,
entry343fs/umsdos/dir.cif (S_ISREG(entry->mode)) entry->mtime = inode->i_mtime;
entry344fs/umsdos/dir.cinode->i_mode  = entry->mode;
entry345fs/umsdos/dir.cinode->i_rdev  = to_kdev_t(entry->rdev);
entry346fs/umsdos/dir.cinode->i_atime = entry->atime;
entry347fs/umsdos/dir.cinode->i_ctime = entry->ctime;
entry348fs/umsdos/dir.cinode->i_mtime = entry->mtime;
entry349fs/umsdos/dir.cinode->i_uid   = entry->uid;
entry350fs/umsdos/dir.cinode->i_gid   = entry->gid;
entry395fs/umsdos/dir.cif (!S_ISDIR(entry->mode)){
entry396fs/umsdos/dir.cif (entry->nlink > 0){
entry397fs/umsdos/dir.cinode->i_nlink = entry->nlink;
entry430fs/umsdos/dir.cstruct umsdos_dirent *entry;
entry446fs/umsdos/dir.cmemcpy (d->entry->name,name,name_len);
entry447fs/umsdos/dir.cd->entry->name[name_len] = '\0';
entry448fs/umsdos/dir.cd->entry->name_len = name_len;
entry465fs/umsdos/dir.cstruct umsdos_dirent *entry)  /* Will hold the entry */
entry473fs/umsdos/dir.cmemcpy (entry->name,UMSDOS_PSDROOT_NAME,UMSDOS_PSDROOT_LEN+1);
entry474fs/umsdos/dir.centry->name_len = UMSDOS_PSDROOT_LEN;
entry485fs/umsdos/dir.cbufk.entry = entry;
entry502fs/umsdos/dir.c,1,entry,0,umsdos_filldir_k) < 0){
entry508fs/umsdos/dir.cumsdos_lookup_patch (dir,inode,entry,bufk.f_pos);
entry523fs/umsdos/dir.cstruct umsdos_dirent *entry)
entry531fs/umsdos/dir.cret = umsdos_inode2entry (adir,dir,entry);
entry552fs/umsdos/dir.cstruct umsdos_dirent entry;
entry560fs/umsdos/dir.cret = umsdos_inode2entry (dir,inode,&entry);
entry562fs/umsdos/dir.cptbpath -= entry.name_len;
entry563fs/umsdos/dir.cmemcpy (ptbpath,entry.name,entry.name_len);
entry573fs/umsdos/dir.cret = umsdos_locate_ancestor (dir,&adir,&entry);
entry579fs/umsdos/dir.cptbpath -= entry.name_len;
entry580fs/umsdos/dir.cmemcpy (ptbpath,entry.name,entry.name_len);
entry660fs/umsdos/dir.cstruct umsdos_dirent entry;
entry661fs/umsdos/dir.cret = umsdos_locate_ancestor (*result,&aadir,&entry);
entry695fs/umsdos/dir.cumsdos_delentry (dir,&info,S_ISDIR(info.entry.mode));
entry697fs/umsdos/dir.cumsdos_lookup_patch (dir,inode,&info.entry,info.f_pos);
entry699fs/umsdos/dir.c,info.entry.flags));
entry700fs/umsdos/dir.cif (info.entry.flags & UMSDOS_HLINK){
entry144fs/umsdos/emd.cstruct umsdos_dirent *entry)
entry146fs/umsdos/emd.cint ret = umsdos_emd_dir_read(emd_dir,filp,(char*)entry,UMSDOS_REC_SIZE);
entry149fs/umsdos/emd.cint recsize = umsdos_evalrecsize (entry->name_len);
entry152fs/umsdos/emd.c,((char*)entry)+UMSDOS_REC_SIZE,recsize - UMSDOS_REC_SIZE);
entry170fs/umsdos/emd.cstruct umsdos_dirent *entry = &info->entry;
entry180fs/umsdos/emd.centry = &entry0;
entry181fs/umsdos/emd.c}else if (entry->name_len > 0){
entry182fs/umsdos/emd.cmemset (entry->name+entry->name_len,'\0'
entry183fs/umsdos/emd.c,sizeof(entry->name)-entry->name_len);
entry190fs/umsdos/emd.cmemset (entry->spare,0,sizeof(entry->spare));
entry194fs/umsdos/emd.cret = umsdos_emd_dir_write(emd_dir,&filp,(char*)entry,info->recsize);
entry280fs/umsdos/emd.cstruct umsdos_dirent *entry = &info->entry;
entry311fs/umsdos/emd.cif (entry->name_len == 0){
entry340fs/umsdos/emd.cif (entry->name_len == rentry->name_len
entry341fs/umsdos/emd.c&& memcmp(entry->name,rentry->name,rentry->name_len)
entry344fs/umsdos/emd.c*entry = *rentry;
entry391fs/umsdos/emd.cinfo->entry.name_len = 0;
entry400fs/umsdos/emd.cinfo->entry.name_len = sprintf (info->entry.name,"..LINK%ld"
entry420fs/umsdos/emd.cif (info->entry.name_len != 0){
entry421fs/umsdos/emd.cif ((isdir != 0) != (S_ISDIR(info->entry.mode) != 0)){
entry422fs/umsdos/emd.cif (S_ISDIR(info->entry.mode)){
entry456fs/umsdos/emd.cstruct umsdos_dirent entry;
entry457fs/umsdos/emd.cif (umsdos_emd_dir_readentry(emd_dir,&filp,&entry)!=0){
entry460fs/umsdos/emd.c}else if (entry.name_len != 0){
entry485fs/umsdos/emd.cif (S_ISDIR(info->entry.mode)){
entry315fs/umsdos/inode.cstruct umsdos_dirent entry;
entry321fs/umsdos/inode.cret = umsdos_emd_dir_read (emd_owner,&filp,(char*)&entry
entry325fs/umsdos/inode.centry.uid = attr->ia_uid;
entry327fs/umsdos/inode.centry.gid = attr->ia_gid;
entry329fs/umsdos/inode.centry.mode = attr->ia_mode;
entry331fs/umsdos/inode.centry.atime = attr->ia_atime;
entry333fs/umsdos/inode.centry.mtime = attr->ia_mtime;
entry335fs/umsdos/inode.centry.ctime = attr->ia_ctime;
entry337fs/umsdos/inode.centry.nlink = inode->i_nlink;
entry339fs/umsdos/inode.cret = umsdos_emd_dir_write (emd_owner,&filp,(char*)&entry
entry344fs/umsdos/inode.c,ret,entry.nlink));
entry144fs/umsdos/ioctl.cstruct umsdos_dirent entry;
entry146fs/umsdos/ioctl.cret = umsdos_emd_dir_readentry (emd_dir,filp,&entry);
entry149fs/umsdos/ioctl.c}else if (entry.name_len > 0){
entry151fs/umsdos/ioctl.cret = entry.name_len;
entry152fs/umsdos/ioctl.cumsdos_parse (entry.name,entry.name_len,&info);
entry155fs/umsdos/ioctl.cmemcpy_tofs(&idata->umsdos_dirent,&entry
entry156fs/umsdos/ioctl.c,sizeof(entry));
entry203fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
entry235fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
entry374fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
entry375fs/umsdos/mangle.cinfo->entry.name_len = len;
entry216fs/umsdos/namei.cinfo.entry.mode = mode;
entry217fs/umsdos/namei.cinfo.entry.rdev = rdev;
entry218fs/umsdos/namei.cinfo.entry.flags = flags;
entry219fs/umsdos/namei.cinfo.entry.uid = current->fsuid;
entry220fs/umsdos/namei.cinfo.entry.gid = (dir->i_mode & S_ISGID)
entry222fs/umsdos/namei.cinfo.entry.ctime = info.entry.atime = info.entry.mtime
entry224fs/umsdos/namei.cinfo.entry.nlink = 1;
entry233fs/umsdos/namei.cumsdos_lookup_patch (dir,inode,&info.entry,info.f_pos);
entry286fs/umsdos/namei.cnew_info->entry.mode = old_info->entry.mode;
entry287fs/umsdos/namei.cnew_info->entry.rdev = old_info->entry.rdev;
entry288fs/umsdos/namei.cnew_info->entry.uid = old_info->entry.uid;
entry289fs/umsdos/namei.cnew_info->entry.gid = old_info->entry.gid;
entry290fs/umsdos/namei.cnew_info->entry.ctime = old_info->entry.ctime;
entry291fs/umsdos/namei.cnew_info->entry.atime = old_info->entry.atime;
entry292fs/umsdos/namei.cnew_info->entry.mtime = old_info->entry.mtime;
entry293fs/umsdos/namei.cnew_info->entry.flags = flags ? flags : old_info->entry.flags;
entry294fs/umsdos/namei.cnew_info->entry.nlink = old_info->entry.nlink;
entry335fs/umsdos/namei.ccurrent->fsuid == old_info.entry.uid ||
entry342fs/umsdos/namei.ccurrent->fsuid == new_info.entry.uid ||
entry361fs/umsdos/namei.c,S_ISDIR(new_info.entry.mode));
entry365fs/umsdos/namei.c,S_ISDIR(old_info.entry.mode));
entry378fs/umsdos/namei.cPRINTK (("rename lookup len %d %d -- ",new_len,new_info.entry.flags));
entry384fs/umsdos/namei.c,new_info.entry.name);
entry573fs/umsdos/namei.cstruct umsdos_dirent entry;
entry575fs/umsdos/namei.cret = umsdos_inode2entry (olddir,oldinode,&entry);
entry578fs/umsdos/namei.c,entry.name
entry579fs/umsdos/namei.c,oldinode->i_ino,entry.flags));
entry580fs/umsdos/namei.cif (!(entry.flags & UMSDOS_HIDDEN)){
entry597fs/umsdos/namei.cret = umsdos_rename_f (olddir,entry.name
entry598fs/umsdos/namei.c,entry.name_len
entry599fs/umsdos/namei.c,olddir,info.entry.name,info.entry.name_len
entry612fs/umsdos/namei.c,entry.name
entry613fs/umsdos/namei.c,entry.name_len,path
entry689fs/umsdos/namei.cinfo.entry.mode = mode | S_IFDIR;
entry690fs/umsdos/namei.cinfo.entry.rdev = 0;
entry691fs/umsdos/namei.cinfo.entry.uid = current->fsuid;
entry692fs/umsdos/namei.cinfo.entry.gid = (dir->i_mode & S_ISGID)
entry694fs/umsdos/namei.cinfo.entry.ctime = info.entry.atime = info.entry.mtime
entry696fs/umsdos/namei.cinfo.entry.flags = 0;
entry698fs/umsdos/namei.cinfo.entry.nlink = 1;
entry943fs/umsdos/namei.ccurrent->fsuid == info.entry.uid ||
entry945fs/umsdos/namei.cif (info.entry.flags & UMSDOS_HLINK){
entry967fs/umsdos/namei.cstruct umsdos_dirent entry;
entry968fs/umsdos/namei.cret = umsdos_inode2entry (hdir,inode,&entry);
entry970fs/umsdos/namei.cret = UMSDOS_unlink (hdir,entry.name
entry971fs/umsdos/namei.c,entry.name_len);
entry991fs/umsdos/namei.c,info.entry.mode,ret));
entry31include/asm-alpha/a.out.h__u64 entry;
entry68include/asm-alpha/a.out.h#define a_entry    ah.entry
entry512include/asm-alpha/pgtable.h#define SWP_TYPE(entry) (((entry) >> 32) & 0xff)
entry513include/asm-alpha/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 40)
entry480include/asm-i386/pgtable.h#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
entry481include/asm-i386/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 8)
entry575include/asm-m68k/pgtable.h#define SWP_TYPE(entry)  (((entry) >> 2) & 0x7f)
entry577include/asm-m68k/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 9)
entry580include/asm-m68k/pgtable.h#define SWP_OFFSET(entry) ((entry) >> PAGE_SHIFT)
entry556include/asm-mips/pgtable.h#define SWP_TYPE(entry) (((entry) >> 32) & 0xff)
entry557include/asm-mips/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 40)
entry562include/asm-mips/pgtable.h#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
entry563include/asm-mips/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 8)
entry501include/asm-ppc/pgtable.h#define SWP_TYPE(entry) (((entry) >> 1) & 0x7f)
entry502include/asm-ppc/pgtable.h#define SWP_OFFSET(entry) ((entry) >> 8)
entry34include/asm-sparc/cache.hextern inline void put_icache_tag(int setnum, int tagnum, unsigned int entry)
entry40include/asm-sparc/cache.h"r" (entry), "r" (vaddr), "i" (ASI_M_TXTC_TAG) :
entry327include/asm-sparc/pgtable.h#define SWP_TYPE(entry) (((entry)>>2) & 0x7f)
entry328include/asm-sparc/pgtable.h#define SWP_OFFSET(entry) (((entry) >> 9) & 0x7ffff)
entry344include/asm-sparc/pgtable.hextern inline void remove_from_ctx_list(struct ctx_list *entry)
entry346include/asm-sparc/pgtable.hentry->next->prev = entry->prev;
entry347include/asm-sparc/pgtable.hentry->prev->next = entry->next;
entry350include/asm-sparc/pgtable.hextern inline void add_to_ctx_list(struct ctx_list *head, struct ctx_list *entry)
entry352include/asm-sparc/pgtable.hentry->next = head;
entry353include/asm-sparc/pgtable.h(entry->prev = head->prev)->next = entry;
entry354include/asm-sparc/pgtable.hhead->prev = entry;
entry356include/asm-sparc/pgtable.h#define add_to_free_ctxlist(entry) add_to_ctx_list(&ctx_free, entry)
entry357include/asm-sparc/pgtable.h#define add_to_used_ctxlist(entry) add_to_ctx_list(&ctx_used, entry)
entry91include/asm-sparc/pgtsun4c.hregister unsigned long entry;
entry94include/asm-sparc/pgtsun4c.h"=r" (entry) :
entry97include/asm-sparc/pgtsun4c.hreturn entry;
entry100include/asm-sparc/pgtsun4c.hextern __inline__ void sun4c_put_segmap(unsigned long addr, unsigned long entry)
entry104include/asm-sparc/pgtsun4c.h"r" (addr), "r" (entry),
entry112include/asm-sparc/pgtsun4c.hregister unsigned long entry;
entry115include/asm-sparc/pgtsun4c.h"=r" (entry) :
entry117include/asm-sparc/pgtsun4c.hreturn entry;
entry120include/asm-sparc/pgtsun4c.hextern __inline__ void sun4c_put_pte(unsigned long addr, unsigned long entry)
entry124include/asm-sparc/pgtsun4c.h"r" (entry), "i" (ASI_PTE));
entry136include/linux/coff.hchar  entry[4];    /* entry pt.         */
entry93include/linux/nfs_fs.hint cookie, int count, struct nfs_entry *entry);
entry474include/linux/sched.hstruct select_table_entry * entry;
entry480include/linux/sched.hentry = p->entry + p->nr;
entry481include/linux/sched.hentry->wait_address = wait_address;
entry482include/linux/sched.hentry->wait.task = current;
entry483include/linux/sched.hentry->wait.next = NULL;
entry484include/linux/sched.hadd_wait_queue(wait_address,&entry->wait);
entry126include/linux/smb_fs.hint len, struct smb_dirent *entry);
entry137include/linux/smb_fs.hint len, struct smb_dirent *entry);
entry139include/linux/smb_fs.hstruct smb_dirent *entry);
entry148include/linux/smb_fs.hstruct smb_dirent *entry);
entry150include/linux/smb_fs.hint len, struct smb_dirent *entry);
entry57include/linux/swap.hextern void swap_after_unlock_page (unsigned long entry);
entry108include/linux/swap.hunsigned long entry;
entry113include/linux/swap.hentry = xchg(swap_cache + index, 0);
entry115include/linux/swap.hif (entry)
entry118include/linux/swap.hreturn entry;
entry123include/linux/swap.hunsigned long entry;
entry128include/linux/swap.hentry = xchg(swap_cache + index, 0);
entry129include/linux/swap.hif (entry)  {
entry133include/linux/swap.hswap_free(entry);
entry65include/linux/umsdos_fs.hstruct umsdos_dirent entry;
entry31include/linux/wait.hstruct select_table_entry * entry;
entry870mm/filemap.cunsigned long entry = SWP_ENTRY(SHM_SWP_TYPE, MAP_NR(page));
entry873mm/filemap.cset_pte(page_table, __pte(entry));
entry876mm/filemap.cif (pte_val(*page_table) == entry)
entry889mm/filemap.cunsigned long entry)
entry891mm/filemap.cunsigned long page = SWP_OFFSET(entry);
entry873mm/memory.cpte_t * page_table, pte_t entry, int write_access)
entry878mm/memory.cswap_in(tsk, vma, page_table, pte_val(entry), write_access);
entry882mm/memory.cpage = vma->vm_ops->swapin(vma, address - vma->vm_start + vma->vm_offset, pte_val(entry));
entry883mm/memory.cif (pte_val(*page_table) != pte_val(entry)) {
entry906mm/memory.cpte_t entry;
entry912mm/memory.centry = *page_table;
entry913mm/memory.cif (pte_present(entry))
entry915mm/memory.cif (!pte_none(entry)) {
entry916mm/memory.cdo_swap_page(tsk, vma, address, page_table, entry, write_access);
entry951mm/memory.centry = mk_pte(page, vma->vm_page_prot);
entry953mm/memory.centry = pte_mkwrite(pte_mkdirty(entry));
entry955mm/memory.centry = pte_wrprotect(entry);
entry957mm/memory.cput_page(page_table, entry);
entry39mm/mprotect.cpte_t entry = *pte;
entry40mm/mprotect.cif (pte_present(entry))
entry41mm/mprotect.cset_pte(pte, pte_modify(entry, newprot));
entry51mm/page_alloc.cstatic inline void add_mem_queue(struct page * head, struct page * entry)
entry55mm/page_alloc.centry->prev = head;
entry56mm/page_alloc.centry->next = next;
entry57mm/page_alloc.cnext->prev = entry;
entry58mm/page_alloc.chead->next = entry;
entry61mm/page_alloc.cstatic inline void remove_mem_queue(struct page * head, struct page * entry)
entry63mm/page_alloc.cstruct page * next = entry->next;
entry64mm/page_alloc.cstruct page * prev = entry->prev;
entry292mm/page_alloc.cpte_t * page_table, unsigned long entry, int write_access)
entry296mm/page_alloc.cif (pte_val(*page_table) != entry) {
entry302mm/page_alloc.cswap_free(entry);
entry306mm/page_alloc.cread_swap_page(entry, (char *) page);
entry307mm/page_alloc.cif (pte_val(*page_table) != entry) {
entry313mm/page_alloc.cif (!write_access && add_to_swap_cache(MAP_NR(page), entry)) {
entry319mm/page_alloc.cswap_free(entry);
entry44mm/page_io.cvoid rw_swap_page(int rw, unsigned long entry, char * buf, int wait)
entry50mm/page_io.ctype = SWP_TYPE(entry);
entry56mm/page_io.coffset = SWP_OFFSET(entry);
entry62mm/page_io.cprintk("Hmm.. Trying to use unallocated swap (%08lx)\n", entry);
entry86mm/page_io.cpage->swap_unlock_entry = entry;
entry139mm/page_io.cvoid swap_after_unlock_page (unsigned long entry)
entry144mm/page_io.ctype = SWP_TYPE(entry);
entry150mm/page_io.coffset = SWP_OFFSET(entry);
entry52mm/swap_state.cint add_to_swap_cache(unsigned long index, unsigned long entry)
entry54mm/swap_state.cstruct swap_info_struct * p = &swap_info[SWP_TYPE(entry)];
entry60mm/swap_state.centry = xchg(swap_cache + index, entry);
entry61mm/swap_state.cif (entry)  {
entry84mm/swap_state.cvoid swap_duplicate(unsigned long entry)
entry89mm/swap_state.cif (!entry)
entry91mm/swap_state.coffset = SWP_OFFSET(entry);
entry92mm/swap_state.ctype = SWP_TYPE(entry);
entry78mm/swapfile.cunsigned long offset, entry;
entry90mm/swapfile.centry = SWP_ENTRY(type,offset);
entry101mm/swapfile.creturn entry;
entry116mm/swapfile.cvoid swap_free(unsigned long entry)
entry121mm/swapfile.cif (!entry)
entry123mm/swapfile.ctype = SWP_TYPE(entry);
entry131mm/swapfile.coffset = SWP_OFFSET(entry);
entry145mm/swapfile.cprintk("swap_free: swap-space map bad (entry %08lx)\n",entry);
entry30mm/vmalloc.cstatic inline void set_pgdir(unsigned long address, pgd_t entry)
entry37mm/vmalloc.c*pgd_offset(p->mm,address) = entry;
entry74mm/vmscan.cunsigned long entry;
entry111mm/vmscan.cif (!(entry = get_swap_page()))
entry115mm/vmscan.cset_pte(page_table, __pte(entry));
entry118mm/vmscan.crw_swap_page(WRITE, entry, (char *) page, wait);
entry123mm/vmscan.cif ((entry = find_in_swap_cache(MAP_NR(page))))  {
entry131mm/vmscan.cset_pte(page_table, __pte(entry));
entry140mm/vmscan.centry = page_unuse(page);
entry142mm/vmscan.creturn entry;
entry126net/802/tr.crif_cache entry;
entry137net/802/tr.cfor(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->daddr[0]),TR_ALEN);entry=entry->next);
entry139net/802/tr.cif(entry) {
entry144net/802/tr.cif((ntohs(entry->rcf) & TR_RCF_LEN_MASK) >> 8) {
entry145net/802/tr.ctrh->rcf=entry->rcf;
entry146net/802/tr.cmemcpy(&trh->rseg[0],&entry->rseg[0],8*sizeof(unsigned short));
entry151net/802/tr.centry->last_used=jiffies;
entry167net/802/tr.crif_cache entry;
entry176net/802/tr.cfor(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);entry=entry->next);
entry178net/802/tr.cif(entry==NULL) {
entry185net/802/tr.centry=kmalloc(sizeof(struct rif_cache_s),GFP_ATOMIC);
entry186net/802/tr.cif(!entry) {
entry190net/802/tr.centry->rcf=trh->rcf;
entry191net/802/tr.cmemcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
entry192net/802/tr.cmemcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
entry193net/802/tr.centry->next=rif_table[hash];
entry194net/802/tr.centry->last_used=jiffies;
entry195net/802/tr.crif_table[hash]=entry;
entry199net/802/tr.cif ( entry->rcf != trh->rcf ) {               
entry207net/802/tr.centry->rcf = trh->rcf;                  
entry208net/802/tr.cmemcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
entry209net/802/tr.centry->last_used=jiffies;               
entry226net/802/tr.crif_cache entry, *pentry=rif_table+i;  
entry228net/802/tr.cwhile((entry=*pentry)) 
entry229net/802/tr.cif((now-entry->last_used) > RIF_TIMEOUT) {
entry230net/802/tr.c*pentry=entry->next;
entry231net/802/tr.ckfree_s(entry,sizeof(struct rif_cache_s));
entry234net/802/tr.cpentry=&entry->next;  
entry251net/802/tr.crif_cache entry;
entry259net/802/tr.cfor(entry=rif_table[i];entry;entry=entry->next) {
entry261net/802/tr.centry->addr[0],entry->addr[1],entry->addr[2],entry->addr[3],entry->addr[4],entry->addr[5],
entry262net/802/tr.centry->rcf,entry->rseg[0],entry->rseg[1],entry->rseg[2],entry->rseg[3],
entry263net/802/tr.centry->rseg[4],entry->rseg[5],entry->rseg[6],entry->rseg[7],jiffies-entry->last_used); 
entry347net/ipv4/arp.cstatic void arp_enqueue(struct arp_table **q, struct arp_table *entry)
entry356net/ipv4/arp.centry->next = entry;
entry359net/ipv4/arp.centry->next = tail->next;
entry360net/ipv4/arp.ctail->next = entry;
entry362net/ipv4/arp.c*q = entry;
entry374net/ipv4/arp.cstruct arp_table * entry;
entry378net/ipv4/arp.centry = (*q)->next;
entry379net/ipv4/arp.c(*q)->next = entry->next;
entry380net/ipv4/arp.cif (entry->next == entry)
entry382net/ipv4/arp.centry->next = NULL;
entry383net/ipv4/arp.creturn entry;
entry392net/ipv4/arp.cstatic void arp_purge_send_q(struct arp_table *entry)
entry400net/ipv4/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
entry417net/ipv4/arp.cstatic void arp_free_entry(struct arp_table *entry)
entry422net/ipv4/arp.cdel_timer(&entry->timer);
entry423net/ipv4/arp.carp_purge_send_q(entry);
entry427net/ipv4/arp.chh = entry->hh;
entry428net/ipv4/arp.centry->hh = NULL;
entry441net/ipv4/arp.ckfree_s(entry, sizeof(struct arp_table));
entry461net/ipv4/arp.cstatic __inline__ int arp_count_hhs(struct arp_table * entry)
entry466net/ipv4/arp.cfor (hh = entry->hh; hh; hh = hh->hh_next)
entry476net/ipv4/arp.cstatic __inline__ void arp_update_hhs(struct arp_table * entry)
entry480net/ipv4/arp.cfor (hh=entry->hh; hh; hh=hh->hh_next)
entry481net/ipv4/arp.centry->dev->header_cache_update(hh, entry->dev, entry->ha);
entry488net/ipv4/arp.cstatic __inline__ void arp_invalidate_hhs(struct arp_table * entry)
entry492net/ipv4/arp.cfor (hh=entry->hh; hh; hh=hh->hh_next)
entry505net/ipv4/arp.cstruct arp_table *entry;
entry518net/ipv4/arp.centry = (struct arp_table*)hh->hh_arp;
entry524net/ipv4/arp.cif (!hh1->hh_arp && entry)
entry527net/ipv4/arp.chh1->hh_next = entry->hh;
entry528net/ipv4/arp.centry->hh = hh1;
entry529net/ipv4/arp.chh1->hh_arp = (void*)entry;
entry532net/ipv4/arp.cif (entry->flags & ATF_COM)
entry533net/ipv4/arp.centry->dev->header_cache_update(hh1, entry->dev, entry->ha);
entry535net/ipv4/arp.cprintk("arp_set_hh: %08x is reattached. Good!\n", entry->ip);
entry539net/ipv4/arp.celse if (entry)
entry540net/ipv4/arp.cprintk("arp_set_hh: %08x rr1 ok!\n", entry->ip);
entry619net/ipv4/arp.cstatic __inline__ void arpd_update(struct arp_table * entry)
entry623net/ipv4/arp.carpd_send(ARPD_UPDATE, entry->ip, entry->dev, entry->ha,
entry624net/ipv4/arp.centry->last_updated);
entry702net/ipv4/arp.cstatic __inline__ void arpd_update(struct arp_table * entry)
entry724net/ipv4/arp.cstruct arp_table *entry, **pentry;
entry745net/ipv4/arp.cwhile ((entry = *pentry) != NULL)
entry747net/ipv4/arp.cif (!(entry->flags & ATF_PERM))
entry751net/ipv4/arp.cusers = arp_count_hhs(entry);
entry753net/ipv4/arp.cif (!users && now - entry->last_used > ARP_TIMEOUT)
entry755net/ipv4/arp.c*pentry = entry->next;
entry758net/ipv4/arp.cprintk("arp_force_expire: %08x expired\n", entry->ip);
entry760net/ipv4/arp.carp_free_entry(entry);
entry767net/ipv4/arp.cif (!users && entry->last_used < oldest_used)
entry770net/ipv4/arp.coldest_used = entry->last_used;
entry773net/ipv4/arp.cpentry = &entry->next;
entry781net/ipv4/arp.centry = *oldest_entry;
entry782net/ipv4/arp.c*oldest_entry = entry->next;
entry784net/ipv4/arp.cprintk("arp_force_expire: expiring %08x\n", entry->ip);
entry786net/ipv4/arp.carp_free_entry(entry);
entry819net/ipv4/arp.cstruct arp_table *entry, **pentry;
entry823net/ipv4/arp.cwhile ((entry = *pentry) != NULL)
entry825net/ipv4/arp.cif (entry->flags & ATF_PERM)
entry827net/ipv4/arp.cpentry = &entry->next;
entry832net/ipv4/arp.cif (now - entry->last_used > ARP_TIMEOUT
entry833net/ipv4/arp.c&& !arp_count_hhs(entry))
entry835net/ipv4/arp.c*pentry = entry->next;
entry838net/ipv4/arp.cprintk("arp_expire: %08x expired\n", entry->ip);
entry840net/ipv4/arp.carp_free_entry(entry);
entry844net/ipv4/arp.cif (entry->last_updated
entry845net/ipv4/arp.c&& now - entry->last_updated > ARP_CONFIRM_INTERVAL
entry846net/ipv4/arp.c&& !(entry->flags & ATF_PERM))
entry848net/ipv4/arp.cstruct device * dev = entry->dev;
entry849net/ipv4/arp.centry->retries = ARP_MAX_TRIES+ARP_MAX_PINGS;
entry850net/ipv4/arp.cdel_timer(&entry->timer);
entry851net/ipv4/arp.centry->timer.expires = jiffies + ARP_CONFIRM_TIMEOUT;
entry852net/ipv4/arp.cadd_timer(&entry->timer);
entry853net/ipv4/arp.carp_send(ARPOP_REQUEST, ETH_P_ARP, entry->ip,
entry854net/ipv4/arp.cdev, dev->pa_addr, entry->ha,
entry857net/ipv4/arp.cprintk("arp_expire: %08x requires confirmation\n", entry->ip);
entry860net/ipv4/arp.cpentry = &entry->next;  /* go to next entry */
entry883net/ipv4/arp.cstruct arp_table *entry = (struct arp_table *) arg;
entry892net/ipv4/arp.cdel_timer(&entry->timer);
entry900net/ipv4/arp.cprintk(KERN_DEBUG "arp_expire_request: %08x deferred\n", entry->ip);
entry902net/ipv4/arp.centry->timer.expires = jiffies + HZ/10;
entry903net/ipv4/arp.cadd_timer(&entry->timer);
entry920net/ipv4/arp.cif ((entry->flags & ATF_COM) && entry->last_updated
entry921net/ipv4/arp.c&& jiffies - entry->last_updated <= ARP_CONFIRM_INTERVAL)
entry930net/ipv4/arp.cif (entry->last_updated && --entry->retries > 0)
entry932net/ipv4/arp.cstruct device *dev = entry->dev;
entry935net/ipv4/arp.cprintk("arp_expire_request: %08x timed out\n", entry->ip);
entry938net/ipv4/arp.centry->timer.expires = jiffies + ARP_RES_TIME;
entry939net/ipv4/arp.cadd_timer(&entry->timer);
entry940net/ipv4/arp.carp_send(ARPOP_REQUEST, ETH_P_ARP, entry->ip, dev, dev->pa_addr,
entry941net/ipv4/arp.centry->retries > ARP_MAX_TRIES ? entry->ha : NULL,
entry951net/ipv4/arp.carp_purge_send_q(entry);
entry954net/ipv4/arp.cif (arp_count_hhs(entry))
entry964net/ipv4/arp.cstruct device *dev = entry->dev;
entry966net/ipv4/arp.cprintk("arp_expire_request: %08x is dead\n", entry->ip);
entry968net/ipv4/arp.centry->retries = ARP_MAX_TRIES;
entry969net/ipv4/arp.centry->flags &= ~ATF_COM;
entry970net/ipv4/arp.carp_invalidate_hhs(entry);
entry976net/ipv4/arp.centry->last_updated = 0;
entry977net/ipv4/arp.carpd_update(entry);
entry979net/ipv4/arp.centry->timer.expires = jiffies + ARP_DEAD_RES_TIME;
entry980net/ipv4/arp.cadd_timer(&entry->timer);
entry981net/ipv4/arp.carp_send(ARPOP_REQUEST, ETH_P_ARP, entry->ip, dev, dev->pa_addr, 
entry988net/ipv4/arp.centry->last_updated = 0;
entry989net/ipv4/arp.carpd_update(entry);
entry991net/ipv4/arp.chash = HASH(entry->ip);
entry997net/ipv4/arp.cif (*pentry != entry)
entry1002net/ipv4/arp.c*pentry = entry->next;
entry1004net/ipv4/arp.cprintk("arp_expire_request: %08x is killed\n", entry->ip);
entry1006net/ipv4/arp.carp_free_entry(entry);
entry1021net/ipv4/arp.cstruct arp_table * entry;
entry1027net/ipv4/arp.centry = (struct arp_table *)
entry1030net/ipv4/arp.cif (entry != NULL)
entry1033net/ipv4/arp.cmemset(entry, 0, sizeof(struct arp_table));
entry1035net/ipv4/arp.centry->mask = DEF_ARP_NETMASK;
entry1036net/ipv4/arp.cinit_timer(&entry->timer);
entry1037net/ipv4/arp.centry->timer.function = arp_expire_request;
entry1038net/ipv4/arp.centry->timer.data = (unsigned long)entry;
entry1039net/ipv4/arp.centry->last_updated = entry->last_used = jiffies;
entry1040net/ipv4/arp.cskb_queue_head_init(&entry->skb);
entry1042net/ipv4/arp.creturn entry;
entry1072net/ipv4/arp.cstruct arp_table *entry;
entry1075net/ipv4/arp.cwhile ((entry = *pentry) != NULL)
entry1077net/ipv4/arp.cif (entry->dev == dev)
entry1079net/ipv4/arp.c*pentry = entry->next;  /* remove from list */
entry1080net/ipv4/arp.carp_free_entry(entry);
entry1083net/ipv4/arp.cpentry = &entry->next;  /* go to next entry */
entry1096net/ipv4/arp.cstatic void arp_send_q(struct arp_table *entry)
entry1106net/ipv4/arp.cif(!(entry->flags&ATF_COM))
entry1109net/ipv4/arp.cin_ntoa(entry->ip));
entry1120net/ipv4/arp.cwhile((skb = skb_dequeue(&entry->skb)) != NULL)
entry1142net/ipv4/arp.cstruct arp_table * entry;
entry1147net/ipv4/arp.cfor (entry=arp_tables[hash]; entry; entry = entry->next)
entry1148net/ipv4/arp.cif (entry->ip == sip && entry->dev == dev)
entry1151net/ipv4/arp.cif (entry)
entry1156net/ipv4/arp.cif (!(entry->flags & ATF_PERM)) 
entry1158net/ipv4/arp.cdel_timer(&entry->timer);
entry1159net/ipv4/arp.centry->last_updated = jiffies;
entry1160net/ipv4/arp.cif (memcmp(entry->ha, sha, dev->addr_len)!=0)
entry1162net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
entry1163net/ipv4/arp.cif (entry->flags & ATF_COM)
entry1164net/ipv4/arp.carp_update_hhs(entry);
entry1166net/ipv4/arp.carpd_update(entry);
entry1169net/ipv4/arp.cif (!(entry->flags & ATF_COM))
entry1175net/ipv4/arp.centry->flags |= ATF_COM;
entry1176net/ipv4/arp.carp_update_hhs(entry);
entry1182net/ipv4/arp.carp_send_q(entry);
entry1190net/ipv4/arp.centry = ientry;
entry1192net/ipv4/arp.cif (grat && !entry)
entry1195net/ipv4/arp.cif (!entry)
entry1197net/ipv4/arp.centry = arp_alloc_entry();
entry1198net/ipv4/arp.cif (!entry)
entry1201net/ipv4/arp.centry->ip = sip;
entry1202net/ipv4/arp.centry->flags = ATF_COM;
entry1203net/ipv4/arp.cmemcpy(entry->ha, sha, dev->addr_len);
entry1204net/ipv4/arp.centry->dev = dev;
entry1207net/ipv4/arp.centry->last_updated = entry->last_used = jiffies;
entry1208net/ipv4/arp.carpd_update(entry);
entry1212net/ipv4/arp.centry->next = arp_tables[hash];
entry1213net/ipv4/arp.carp_tables[hash] = entry;
entry1217net/ipv4/arp.cprintk("arp_update: %08x backlogged\n", entry->ip);
entry1219net/ipv4/arp.carp_enqueue(&arp_backlog, entry);
entry1228net/ipv4/arp.cstruct arp_table *entry;
entry1230net/ipv4/arp.cfor (entry = arp_tables[HASH(paddr)]; entry != NULL; entry = entry->next)
entry1231net/ipv4/arp.cif (entry->ip == paddr && (!dev || entry->dev == dev))
entry1232net/ipv4/arp.creturn entry;
entry1242net/ipv4/arp.cstruct arp_table *entry;
entry1246net/ipv4/arp.centry = arp_lookup(paddr, dev);
entry1248net/ipv4/arp.cif (entry != NULL)
entry1250net/ipv4/arp.centry->last_used = jiffies;
entry1251net/ipv4/arp.cif (entry->flags & ATF_COM)
entry1253net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
entry1305net/ipv4/arp.cstruct arp_table *entry;
entry1307net/ipv4/arp.centry = arp_alloc_entry();
entry1309net/ipv4/arp.cif (entry != NULL)
entry1311net/ipv4/arp.centry->ip = paddr;
entry1312net/ipv4/arp.centry->dev = dev;
entry1315net/ipv4/arp.centry->hh = hh;
entry1317net/ipv4/arp.chh->hh_arp = (void*)entry;
entry1319net/ipv4/arp.centry->timer.expires = jiffies + ARP_RES_TIME;
entry1323net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
entry1330net/ipv4/arp.centry->next = arp_tables[hash];
entry1331net/ipv4/arp.carp_tables[hash] = entry;
entry1332net/ipv4/arp.cadd_timer(&entry->timer);
entry1333net/ipv4/arp.centry->retries = ARP_MAX_TRIES;
entry1345net/ipv4/arp.cprintk("arp_new_entry: %08x backlogged\n", entry->ip);
entry1347net/ipv4/arp.carp_enqueue(&arp_req_backlog, entry);
entry1351net/ipv4/arp.creturn entry;
entry1362net/ipv4/arp.cstruct arp_table *entry;
entry1378net/ipv4/arp.centry = arp_lookup(paddr, dev);
entry1380net/ipv4/arp.cif (entry != NULL)   /* It exists */
entry1382net/ipv4/arp.cif (entry->flags & ATF_COM)
entry1384net/ipv4/arp.centry->last_used = jiffies;
entry1385net/ipv4/arp.cmemcpy(haddr, entry->ha, dev->addr_len);
entry1399net/ipv4/arp.cif (entry->last_updated)
entry1401net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
entry1418net/ipv4/arp.centry = arp_new_entry(paddr, dev, NULL, skb);
entry1420net/ipv4/arp.cif (skb != NULL && !entry)
entry1445net/ipv4/arp.cstruct arp_table *entry;
entry1467net/ipv4/arp.centry = arp_lookup(paddr, dev);
entry1469net/ipv4/arp.cif (entry)
entry1471net/ipv4/arp.cfor (hh = entry->hh; hh; hh=hh->hh_next)
entry1490net/ipv4/arp.cif (entry)
entry1494net/ipv4/arp.chh->hh_arp = (void*)entry;
entry1495net/ipv4/arp.chh->hh_next = entry->hh;
entry1496net/ipv4/arp.centry->hh = hh;
entry1500net/ipv4/arp.cif (entry->flags & ATF_COM)
entry1501net/ipv4/arp.cdev->header_cache_update(hh, dev, entry->ha);
entry1509net/ipv4/arp.centry->last_used = jiffies;
entry1514net/ipv4/arp.centry = arp_new_entry(paddr, dev, hh, NULL);
entry1515net/ipv4/arp.cif (entry == NULL)
entry1534net/ipv4/arp.cstruct arp_table *entry, *entry1;
entry1548net/ipv4/arp.cwhile ((entry = arp_dequeue(&arp_backlog)) != NULL)
entry1551net/ipv4/arp.cif (arp_update(entry->ip, entry->ha, entry->dev, entry, 0))
entry1552net/ipv4/arp.carp_free_entry(entry);
entry1557net/ipv4/arp.cwhile ((entry = arp_dequeue(&arp_req_backlog)) != NULL)
entry1561net/ipv4/arp.cdev = entry->dev;
entry1562net/ipv4/arp.csip = entry->ip;
entry1572net/ipv4/arp.centry->next = arp_tables[hash];
entry1573net/ipv4/arp.carp_tables[hash] = entry;
entry1575net/ipv4/arp.centry->timer.expires = jiffies + ARP_RES_TIME;
entry1576net/ipv4/arp.centry->retries = ARP_MAX_TRIES;
entry1577net/ipv4/arp.centry->last_used = jiffies;
entry1578net/ipv4/arp.cif (!(entry->flags & ATF_COM))
entry1580net/ipv4/arp.cadd_timer(&entry->timer);
entry1601net/ipv4/arp.cfor (hh=entry->hh; hh; hh=next)
entry1608net/ipv4/arp.centry->hh = NULL;
entry1613net/ipv4/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
entry1623net/ipv4/arp.carp_free_entry(entry);
entry1947net/ipv4/arp.cstruct arp_table *entry, **entryp;
entry2010net/ipv4/arp.cwhile ((entry = *entryp) != NULL)
entry2012net/ipv4/arp.cif (entry->ip == ip && entry->mask == mask && entry->dev == dev)
entry2014net/ipv4/arp.cif ((entry->mask & mask) != mask)
entry2016net/ipv4/arp.centry = NULL;
entry2019net/ipv4/arp.centryp = &entry->next;
entry2026net/ipv4/arp.cif (entry == NULL)
entry2028net/ipv4/arp.centry = arp_alloc_entry();
entry2029net/ipv4/arp.cif (entry == NULL)
entry2034net/ipv4/arp.centry->ip = ip;
entry2035net/ipv4/arp.centry->dev = dev;
entry2036net/ipv4/arp.centry->mask = mask;
entry2037net/ipv4/arp.centry->flags = r->arp_flags;
entry2039net/ipv4/arp.centry->next = (*entryp)->next;
entry2040net/ipv4/arp.c*entryp = entry;
entry2049net/ipv4/arp.cmemcpy(entry->ha, ha, dev->addr_len);
entry2050net/ipv4/arp.centry->last_updated = entry->last_used = jiffies;
entry2051net/ipv4/arp.centry->flags |= ATF_COM;
entry2053net/ipv4/arp.carpd_update(entry);
entry2054net/ipv4/arp.carp_update_hhs(entry);
entry2067net/ipv4/arp.cstruct arp_table *entry;
entry2086net/ipv4/arp.centry = arp_tables[HASH(si->sin_addr.s_addr)];
entry2088net/ipv4/arp.centry = arp_proxy_list;
entry2090net/ipv4/arp.cfor ( ; entry ;entry = entry->next)
entry2092net/ipv4/arp.cif (entry->ip == si->sin_addr.s_addr 
entry2093net/ipv4/arp.c&& (!dev || entry->dev == dev)
entry2094net/ipv4/arp.c&& (!(r->arp_flags&ATF_NETMASK) || entry->mask == mask))
entry2096net/ipv4/arp.cmemcpy(r->arp_ha.sa_data, entry->ha, entry->dev->addr_len);
entry2097net/ipv4/arp.cr->arp_ha.sa_family = entry->dev->type;
entry2098net/ipv4/arp.cr->arp_flags = entry->flags;
entry2099net/ipv4/arp.cstrncpy(r->arp_dev, entry->dev->name, sizeof(r->arp_dev));
entry2112net/ipv4/arp.cstruct arp_table  *entry, **entryp;
entry2135net/ipv4/arp.cwhile ((entry = *entryp) != NULL)
entry2137net/ipv4/arp.cif (entry->ip == si->sin_addr.s_addr 
entry2138net/ipv4/arp.c&& (!dev || entry->dev == dev)
entry2139net/ipv4/arp.c&& (!(r->arp_flags&ATF_NETMASK) || entry->mask == mask))
entry2141net/ipv4/arp.c*entryp = entry->next;
entry2142net/ipv4/arp.carp_free_entry(entry);
entry2146net/ipv4/arp.centryp = &entry->next;
entry2279net/ipv4/arp.cstruct arp_table *entry;
entry2293net/ipv4/arp.cfor(entry=arp_tables[i]; entry!=NULL; entry=entry->next)
entry2300net/ipv4/arp.cif (entry->dev->type == ARPHRD_AX25 || entry->dev->type == ARPHRD_NETROM)
entry2301net/ipv4/arp.cstrcpy(hbuffer,ax2asc((ax25_address *)entry->ha));
entry2304net/ipv4/arp.cif(entry->dev->type==ARPHRD_AX25)
entry2305net/ipv4/arp.cstrcpy(hbuffer,ax2asc((ax25_address *)entry->ha));
entry2310net/ipv4/arp.cfor(k=0,j=0;k<HBUFFERLEN-3 && j<entry->dev->addr_len;j++)
entry2312net/ipv4/arp.chbuffer[k++]=hexbuf[ (entry->ha[j]>>4)&15 ];
entry2313net/ipv4/arp.chbuffer[k++]=hexbuf[  entry->ha[j]&15     ];
entry2323net/ipv4/arp.cin_ntoa(entry->ip),
entry2324net/ipv4/arp.c(unsigned int)entry->dev->type,
entry2325net/ipv4/arp.centry->flags,
entry2330net/ipv4/arp.centry->mask==DEF_ARP_NETMASK ?
entry2331net/ipv4/arp.c"*" : in_ntoa(entry->mask), entry->dev->name);
entry2335net/ipv4/arp.centry->mask==DEF_ARP_NETMASK ?
entry2336net/ipv4/arp.c"*" : in_ntoa(entry->mask), entry->dev->name, 
entry2337net/ipv4/arp.centry->hh ? entry->hh->hh_refcnt : -1,
entry2338net/ipv4/arp.centry->hh ? entry->hh->hh_uptodate : 0);
entry353net/ipv4/icmp.cint type, entry;
entry359net/ipv4/icmp.cfor (entry=0; entry<XRLIM_CACHE_SIZE; entry++)
entry360net/ipv4/icmp.cxr->cache[entry].daddr = INADDR_NONE;
entry105net/ipv4/rarp.cstatic inline void rarp_release_entry(struct rarp_table *entry)
entry107net/ipv4/rarp.ckfree_s(entry, sizeof(struct rarp_table));
entry118net/ipv4/rarp.cstruct rarp_table *entry;
entry123net/ipv4/rarp.cwhile ((entry = *pentry) != NULL)
entry125net/ipv4/rarp.cif (entry->ip == ip_addr)
entry127net/ipv4/rarp.c*pentry = entry->next;
entry129net/ipv4/rarp.crarp_release_entry(entry);
entry132net/ipv4/rarp.cpentry = &entry->next;
entry143net/ipv4/rarp.cstruct rarp_table *entry;
entry148net/ipv4/rarp.cwhile ((entry = *pentry) != NULL)
entry150net/ipv4/rarp.cif (entry->dev == dev)
entry152net/ipv4/rarp.c*pentry = entry->next;
entry154net/ipv4/rarp.crarp_release_entry(entry);
entry157net/ipv4/rarp.cpentry = &entry->next;
entry201net/ipv4/rarp.cstruct rarp_table *entry;
entry260net/ipv4/rarp.cfor (entry = rarp_tables; entry != NULL; entry = entry->next)
entry261net/ipv4/rarp.cif (!memcmp(entry->ha, tha, rarp->ar_hln))
entry264net/ipv4/rarp.cif (entry != NULL)
entry266net/ipv4/rarp.csip=entry->ip;
entry287net/ipv4/rarp.cstruct rarp_table *entry;
entry342net/ipv4/rarp.cfor (entry = rarp_tables; entry != NULL; entry = entry->next)
entry343net/ipv4/rarp.cif (entry->ip == ip)
entry350net/ipv4/rarp.cif (entry == NULL)
entry352net/ipv4/rarp.centry = (struct rarp_table *) kmalloc(sizeof(struct rarp_table),
entry354net/ipv4/rarp.cif (entry == NULL)
entry365net/ipv4/rarp.centry->next = rarp_tables;
entry366net/ipv4/rarp.crarp_tables = entry;
entry369net/ipv4/rarp.centry->ip = ip;
entry370net/ipv4/rarp.centry->hlen = hlen;
entry371net/ipv4/rarp.centry->htype = htype;
entry372net/ipv4/rarp.cmemcpy(&entry->ha, &r.arp_ha.sa_data, hlen);
entry373net/ipv4/rarp.centry->dev = dev;
entry391net/ipv4/rarp.cstruct rarp_table *entry;
entry412net/ipv4/rarp.cfor (entry = rarp_tables; entry != NULL; entry = entry->next)
entry413net/ipv4/rarp.cif (entry->ip == ip)
entry416net/ipv4/rarp.cif (entry == NULL)
entry426net/ipv4/rarp.cmemcpy(r.arp_ha.sa_data, &entry->ha, entry->hlen);
entry427net/ipv4/rarp.cr.arp_ha.sa_family = entry->htype;
entry490net/ipv4/rarp.cstruct rarp_table *entry;
entry507net/ipv4/rarp.cfor(entry=rarp_tables; entry!=NULL; entry=entry->next)
entry509net/ipv4/rarp.cnetip=htonl(entry->ip);          /* switch to network order */
entry520net/ipv4/rarp.c(unsigned int)entry->ha[0],
entry521net/ipv4/rarp.c(unsigned int)entry->ha[1],
entry522net/ipv4/rarp.c(unsigned int)entry->ha[2],
entry523net/ipv4/rarp.c(unsigned int)entry->ha[3],
entry524net/ipv4/rarp.c(unsigned int)entry->ha[4],
entry525net/ipv4/rarp.c(unsigned int)entry->ha[5]);