taglinefilesource code
end119arch/i386/boot/compressed/misc.cextern int end;
end120arch/i386/boot/compressed/misc.cstatic long free_mem_ptr = (long)&end;
end352arch/i386/boot/compressed/misc.chigh_buffer_start = (uch *)(((ulg)&end) + HEAP_SIZE);
end167arch/sparc/kernel/setup.cextern unsigned long start, end;
end240arch/sparc/kernel/setup.c*memory_start_p = (((unsigned long) &end));
end128arch/sparc/kernel/smp.cvoid smp_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end130arch/sparc/kernel/smp.csmp_invalidate(2, (unsigned long) mm, start, end);
end39arch/sparc/mm/loadmmu.cvoid (*invalidate_range)(struct mm_struct *, unsigned long start, unsigned long end);
end378arch/sparc/mm/srmmu.cstatic void tsunami_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end427arch/sparc/mm/srmmu.cstatic void swift_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end442arch/sparc/mm/srmmu.cwhile(addr < end) {
end514arch/sparc/mm/srmmu.cstatic void viking_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end531arch/sparc/mm/srmmu.cwhile(addr < end) {
end588arch/sparc/mm/srmmu.cstatic void cypress_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end603arch/sparc/mm/srmmu.cwhile(addr < end) {
end648arch/sparc/mm/srmmu.cstatic void hypersparc_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end771arch/sparc/mm/srmmu.cunsigned long end = start + size;
end773arch/sparc/mm/srmmu.cwhile(start < end) {
end807arch/sparc/mm/srmmu.ciommu->end = 0xffffffff;
end810arch/sparc/mm/srmmu.cptsize = iommu->end - iommu->start + 1;
end838arch/sparc/mm/srmmu.cunsigned long start, end, offset;
end847arch/sparc/mm/srmmu.cend = KADB_DEBUGGER_BEGVM; /* Don't step on kadb/prom. */
end849arch/sparc/mm/srmmu.cwhile(start < end) {
end943arch/sparc/mm/srmmu.cstatic inline void srmmu_allocate_ptable_skeleton(unsigned long start, unsigned long end)
end949arch/sparc/mm/srmmu.cwhile(start < end) {
end973arch/sparc/mm/srmmu.cunsigned long start, end;
end977arch/sparc/mm/srmmu.cend = LINUX_OPPROM_ENDVM;
end978arch/sparc/mm/srmmu.cwhile(start < end) {
end1023arch/sparc/mm/srmmu.cstatic void srmmu_map_kernel(unsigned long start, unsigned long end)
end1029arch/sparc/mm/srmmu.cend = (PAGE_ALIGN(end) + PAGE_SIZE);
end1030arch/sparc/mm/srmmu.cwhile(start < end) {
end26arch/sparc/mm/sun4c.cunsigned long begin, end;
end34arch/sparc/mm/sun4c.cend = (AC_CACHETAGS + sun4c_vacinfo.num_bytes);
end35arch/sparc/mm/sun4c.cwhile(begin < end) {
end63arch/sparc/mm/sun4c.cunsigned long end;
end67arch/sparc/mm/sun4c.cend = (addr + sun4c_vacinfo.num_bytes);
end69arch/sparc/mm/sun4c.cfor( ; addr < end; addr += PAGE_SIZE)
end74arch/sparc/mm/sun4c.cfor( ; addr < end; addr += incr)
end90arch/sparc/mm/sun4c.cunsigned long end = addr + PAGE_SIZE;
end93arch/sparc/mm/sun4c.cfor( ; addr < end; addr += incr)
end247arch/sparc/mm/sun4c.cunsigned long start, end;
end249arch/sparc/mm/sun4c.cend = vaddr + SUN4C_REAL_PGDIR_SIZE;
end250arch/sparc/mm/sun4c.cfor(start = vaddr; start < end; start += PAGE_SIZE)
end281arch/sparc/mm/sun4c.cstatic void sun4c_init_lock_area(unsigned long start, unsigned long end)
end285arch/sparc/mm/sun4c.cwhile(start < end) {
end446arch/sparc/mm/sun4c.cunsigned long end = start + SUN4C_REAL_PGDIR_SIZE;
end449arch/sparc/mm/sun4c.cwhile(start < end) {
end579arch/sparc/mm/sun4c.cunsigned long end, flags;
end583arch/sparc/mm/sun4c.cend = address + SUN4C_REAL_PGDIR_SIZE;
end592arch/sparc/mm/sun4c.cwhile(address < end) {
end601arch/sparc/mm/sun4c.cwhile(address < end) {
end677arch/sparc/mm/sun4c.cint start, end;
end682arch/sparc/mm/sun4c.cfor(end = (start + 16); start < end; start++)
end901arch/sparc/mm/sun4c.cstatic void sun4c_invalidate_range(struct mm_struct *mm, unsigned long start, unsigned long end)
end912arch/sparc/mm/sun4c.cwhile(start < end) {
end1312arch/sparc/mm/sun4c.cextern unsigned long end;
end1319arch/sparc/mm/sun4c.ckernel_end = (unsigned long) &end;
end258drivers/block/hd.cunsigned char *p, *end = &s[bytecount &= ~1];  /* bytecount must be even */
end261drivers/block/hd.cfor (p = end ; p != s;) {
end267drivers/block/hd.cwhile (s != end && *s == ' ')
end271drivers/block/hd.cwhile (s != end && *s) {
end272drivers/block/hd.cif (*s++ != ' ' || (s != end && *s && *s != ' '))
end277drivers/block/hd.cwhile (p != end)
end2117drivers/block/ide.cbyte *p = s, *end = &s[bytecount & ~1]; /* bytecount must be even */
end2121drivers/block/ide.cfor (p = end ; p != s;) {
end2128drivers/block/ide.cwhile (s != end && *s == ' ')
end2132drivers/block/ide.cwhile (s != end && *s) {
end2133drivers/block/ide.cif (*s++ != ' ' || (s != end && *s && *s != ' '))
end2138drivers/block/ide.cwhile (p != end)
end451drivers/cdrom/aztcd.cparams->end.min,   params->end.sec,   params->end.frame);
end458drivers/cdrom/aztcd.coutb(params -> end.min,CMD_PORT);
end459drivers/cdrom/aztcd.coutb(params -> end.sec,CMD_PORT);
end460drivers/cdrom/aztcd.coutb(params -> end.frame,CMD_PORT);
end717drivers/cdrom/aztcd.cazt_Play.end = Toc[ti.cdti_trk1 + 1].diskTime;
end721drivers/cdrom/aztcd.cazt_Play.end.min, azt_Play.end.sec, azt_Play.end.frame);
end750drivers/cdrom/aztcd.cazt_Play.end.min = msf.cdmsf_min1;
end751drivers/cdrom/aztcd.cazt_Play.end.sec = msf.cdmsf_sec1;
end752drivers/cdrom/aztcd.cazt_Play.end.frame = msf.cdmsf_frame1;
end756drivers/cdrom/aztcd.cazt_Play.end.min, azt_Play.end.sec, azt_Play.end.frame);
end855drivers/cdrom/aztcd.cazt_Play.end.min =     volctrl.channel1;
end856drivers/cdrom/aztcd.cazt_Play.end.sec =     volctrl.channel2;
end857drivers/cdrom/aztcd.cazt_Play.end.frame =   volctrl.channel3;
end904drivers/cdrom/aztcd.cazt_Play.end.min = msf.cdmsf_min1;
end905drivers/cdrom/aztcd.cazt_Play.end.sec = msf.cdmsf_sec1;
end906drivers/cdrom/aztcd.cazt_Play.end.frame = msf.cdmsf_frame1;
end1204drivers/cdrom/aztcd.cmsf.end.min = 0;
end1205drivers/cdrom/aztcd.cmsf.end.sec = 0;            
end1206drivers/cdrom/aztcd.cmsf.end.frame = azt_read_count ;/*Mitsumi here reads 0xffffff sectors*/
end1208drivers/cdrom/aztcd.cprintk("---reading msf-address %x:%x:%x  %x:%x:%x\n",msf.start.min,msf.start.sec,msf.start.frame,msf.end.min,msf.end.sec,msf.end.frame);
end1819drivers/cdrom/aztcd.cazt_Play.end.min     = 0;
end1820drivers/cdrom/aztcd.cazt_Play.end.sec     = 0;
end1821drivers/cdrom/aztcd.cazt_Play.end.frame   = 1;
end387drivers/cdrom/mcd.cmcd_Play.end = Toc[ti.cdti_trk1 + 1].diskTime;
end392drivers/cdrom/mcd.cmcd_Play.end.min, mcd_Play.end.sec, mcd_Play.end.frame);
end431drivers/cdrom/mcd.cmcd_Play.end.min = msf.cdmsf_min1;
end432drivers/cdrom/mcd.cmcd_Play.end.sec = msf.cdmsf_sec1;
end433drivers/cdrom/mcd.cmcd_Play.end.frame = msf.cdmsf_frame1;
end438drivers/cdrom/mcd.cmcd_Play.end.min, mcd_Play.end.sec, mcd_Play.end.frame);
end865drivers/cdrom/mcd.cmsf.end.min = ~0;
end866drivers/cdrom/mcd.cmsf.end.sec = ~0;
end867drivers/cdrom/mcd.cmsf.end.frame = ~0;
end1334drivers/cdrom/mcd.coutb(params -> end.min, MCDPORT(0));
end1335drivers/cdrom/mcd.coutb(params -> end.sec, MCDPORT(0));
end1336drivers/cdrom/mcd.coutb(params -> end.frame, MCDPORT(0));
end247drivers/cdrom/sjcd.coutb( pms->end.min,     SJCDPORT( 0 ) );
end248drivers/cdrom/sjcd.coutb( pms->end.sec,     SJCDPORT( 0 ) );
end249drivers/cdrom/sjcd.coutb( pms->end.frame,   SJCDPORT( 0 ) );
end604drivers/cdrom/sjcd.cmsf.end.min = msf.end.sec = msf.end.frame = 0x00;
end733drivers/cdrom/sjcd.csjcd_playing.end = ( ti.cdti_trk1 < sjcd_last_track_no ) ?
end762drivers/cdrom/sjcd.csjcd_playing.end.min = bin2bcd( sjcd_msf.cdmsf_min1 );
end763drivers/cdrom/sjcd.csjcd_playing.end.sec = bin2bcd( sjcd_msf.cdmsf_sec1 );
end764drivers/cdrom/sjcd.csjcd_playing.end.frame = bin2bcd( sjcd_msf.cdmsf_frame1 );
end1067drivers/cdrom/sjcd.cmsf.end.min = 0; msf.end.sec = 0;            
end1068drivers/cdrom/sjcd.cmsf.end.frame = sjcd_read_count = SJCD_BUF_SIZ;
end1072drivers/cdrom/sjcd.cmsf.end.min,   msf.end.sec,   msf.end.frame );
end508drivers/char/ftape/ecc.cunsigned long p0, p1, p2, t1, t2, *end;
end510drivers/char/ftape/ecc.cend = data + nblocks * (SECTOR_SIZE / sizeof(long));
end512drivers/char/ftape/ecc.cwhile (data < end) {
end372drivers/char/ftape/ftape-eof.cbyte *end;
end380drivers/char/ftape/ftape-eof.cend = find_end_of_eof_list(start, address + 29 * SECTOR_SIZE);
end381drivers/char/ftape/ftape-eof.cif (end && end - start <= sizeof(eof_map)) {
end382drivers/char/ftape/ftape-eof.cnr_of_eof_marks = (end - start) / sizeof(unsigned long);
end383drivers/char/ftape/ftape-eof.cmemcpy(eof_map, start, end - start);
end515drivers/char/ftape/ftape-eof.cbad_seek = end;
end417drivers/isdn/teles/q931.cbyte           *end;
end421drivers/isdn/teles/q931.cend = p + p[1] + 1;
end450drivers/isdn/teles/q931.cif (p > end)
end1535drivers/net/depca.cint i, entry, end, len, status = 0;
end1538drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
end1539drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
end1544drivers/net/depca.cif (end < entry) {                         /* wrapped buffer */
end1554drivers/net/depca.cfor (i = entry; i != end; i = (++i) & lp->txRingMask) {
end1562drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
end1563drivers/net/depca.cwritew(0x0000, &lp->tx_ring[end].misc);    /* clears other error flags */
end1564drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);    /* packet length in last buff */
end1569drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
end1571drivers/net/depca.cfor (i=end; i!=entry; --i) {
end1578drivers/net/depca.clp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
end996drivers/net/eepro.cunsigned status, tx_available, last, end, boguscount = 10;
end1020drivers/net/eepro.cend = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
end1022drivers/net/eepro.cif (end >= RAM_SIZE) { /* the transmit buffer is wrapped around */
end1027drivers/net/eepro.cend = last + (((length + 3) >> 1) << 1) + XMT_HEADER;
end1029drivers/net/eepro.celse end = RCV_RAM + (end - RAM_SIZE);
end1035drivers/net/eepro.coutw(end, ioaddr + IO_PORT);
end1073drivers/net/eepro.clp->tx_end = end;
end247drivers/net/strip.c__u8 *end = src + length;
end263drivers/net/strip.cwhile (src < end) 
end392drivers/net/strip.cstatic __u8 *UnStuffData(__u8 *src, __u8 *end, __u8 *dst, __u32 dst_length)
end396drivers/net/strip.cif (!src || !end || !dst || !dst_length) 
end398drivers/net/strip.cwhile (src < end && dst < dst_end) 
end404drivers/net/strip.cif (src+1+count >= end) 
end422drivers/net/strip.cif (src+1+count >= end) 
end435drivers/net/strip.cif (src+1 >= end)
end762drivers/net/strip.c__u8 *end = strip_info->sx_buff + strip_info->sx_count;
end765drivers/net/strip.cwhile (ptr<end && p < &pkt_text[MAX_RecvErr-4]) 
end784drivers/net/strip.cif (ptr == end)
end834drivers/net/strip.c__u8 *end = strip_info->sx_buff + strip_info->sx_count;
end861drivers/net/strip.cwhile (ptr < end && *ptr != '*') ptr++;
end864drivers/net/strip.cif (ptr == end) {
end882drivers/net/strip.cptr = UnStuffData(ptr, end, strip_info->rx_buff, 4);
end895drivers/net/strip.cptr = UnStuffData(ptr, end, strip_info->rx_buff+4, packetlen-4);
end925drivers/net/strip.cconst unsigned char *end = cp + count;
end938drivers/net/strip.cwhile (cp < end) {
end467drivers/scsi/aha152x.cScsi_Cmnd *end;
end474drivers/scsi/aha152x.cfor(end=*SC; end->host_scribble; end = (Scsi_Cmnd *) end->host_scribble)
end476drivers/scsi/aha152x.cend->host_scribble = (unsigned char *) new_SC;
end352drivers/scsi/eata.cstatic inline unchar read_pio (ushort iobase, ushort *start, ushort *end) {
end356drivers/scsi/eata.cfor (p = start; p <= end; p++) {
end44fs/binfmt_aout.cstatic void set_brk(unsigned long start, unsigned long end)
end47fs/binfmt_aout.cend = PAGE_ALIGN(end);
end48fs/binfmt_aout.cif (end <= start)
end50fs/binfmt_aout.cdo_mmap(NULL, start, end - start,
end53fs/binfmt_elf.cstatic void set_brk(unsigned long start, unsigned long end)
end56fs/binfmt_elf.cend = PAGE_ALIGN(end);
end57fs/binfmt_elf.cif (end <= start) 
end59fs/binfmt_elf.cdo_mmap(NULL, start, end - start,
end162fs/fat/file.cchar *end   = buf + count;
end214fs/fat/file.c&& buf < end){
end239fs/fat/file.csize = MIN(size,end-buf);
end244fs/fat/file.cfor (; size && buf < end; size--) {
end91fs/file_table.cunsigned long file_table_init(unsigned long start, unsigned long end)
end133fs/inode.cunsigned long inode_init(unsigned long start, unsigned long end)
end807fs/nfs/nfsroot.cu8 *ext, *end, *opt;
end846fs/nfs/nfsroot.cend = (u8 *) recv_bootp + len;
end847fs/nfs/nfsroot.cwhile (ext < end && *ext != 255) {
end853fs/nfs/nfsroot.cif (ext <= end)
end1506fs/nfs/nfsroot.cstatic int *root_nfs_call(int *end)
end1552fs/nfs/nfsroot.cif (nfs_rpc_call(&s, rpc_packet, end, nfs_data.wsize) < 0)
end42fs/nfs/sock.cnfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
end53fs/nfs/sock.creq.rq_svec[0].iov_len = (end - start) << 2;
end54fs/nfs/sock.creq.rq_slen = (end - start) << 2;
end362fs/proc/array.cstatic int get_array(struct task_struct ** p, unsigned long start, unsigned long end, char * buffer)
end368fs/proc/array.cif (start >= end)
end384fs/proc/array.cif (!c && start >= end)
end732fs/proc/array.cunsigned long end;
end743fs/proc/array.cend = address + size;
end744fs/proc/array.cif (end > PMD_SIZE)
end745fs/proc/array.cend = PMD_SIZE;
end763fs/proc/array.c} while (address < end);
end770fs/proc/array.cunsigned long end;
end781fs/proc/array.cend = address + size;
end782fs/proc/array.cif (end > PGDIR_SIZE)
end783fs/proc/array.cend = PGDIR_SIZE;
end785fs/proc/array.cstatm_pte_range(pmd, address, end - address, pages, shared, dirty, total);
end788fs/proc/array.c} while (address < end);
end791fs/proc/array.cstatic void statm_pgd_range(pgd_t * pgd, unsigned long address, unsigned long end,
end794fs/proc/array.cwhile (address < end) {
end795fs/proc/array.cstatm_pmd_range(pgd, address, end - address, pages, shared, dirty, total);
end1068fs/proc/array.cint end;
end1106fs/proc/array.cend = count + file->f_pos;
end1108fs/proc/array.cfile->f_pos = end;
end397fs/vfat/namei.cconst char *ip, *ext_start, *end;
end435fs/vfat/namei.cext_start = end = &name[len];
end438fs/vfat/namei.cif (ext_start == end - 1) {
end490fs/vfat/namei.cfor (p = ext, ip = ext_start; extlen < 3 && ip < end; ip++) {
end674fs/vfat/namei.cint end, j;
end687fs/vfat/namei.cend = 0;
end36fs/xiafs/bitmap.cint end, i, j, tmp;
end40fs/xiafs/bitmap.cend = end_bit >> 5;
end46fs/xiafs/bitmap.cwhile (++i < end)
end17include/asm-alpha/pgtable.h#define flush_cache_range(mm, start, end)  do { } while (0)
end73include/asm-alpha/pgtable.hunsigned long start, unsigned long end)
end25include/asm-i386/pgtable.h#define flush_cache_range(mm, start, end)  do { } while (0)
end71include/asm-i386/pgtable.hunsigned long start, unsigned long end)
end134include/asm-i386/pgtable.hunsigned long start, unsigned long end)
end159include/asm-i386/pgtable.hunsigned long start, unsigned long end)
end101include/asm-mips/asm.h.end  function;    \
end45include/asm-mips/pgtable.h#define invalidate_range(mm_struct,start,end) \
end104include/asm-sparc/iommu.hunsigned long end;   /* Last managed virtual address */
end248include/asm-sparc/pgtable.hextern void (*invalidate_range)(struct mm_struct *, unsigned long start, unsigned long end);
end31include/asm-sparc/smp.hunsigned long end;    /* Used for inv_rnge only. */
end133include/linux/aztcd.hstruct msf  end;
end125include/linux/fs.hextern unsigned long inode_init(unsigned long start, unsigned long end);
end126include/linux/fs.hextern unsigned long file_table_init(unsigned long start, unsigned long end);
end127include/linux/fs.hextern unsigned long name_cache_init(unsigned long start, unsigned long end);
end93include/linux/gscd.hstruct msf  end;
end95include/linux/mcd.hstruct msf  end;
end107include/linux/nfs_fs.hint *end, int size);
end147include/linux/sjcd.hstruct msf  end;
end112include/linux/skbuff.hunsigned char   *end;      /* End pointer          */
end393include/linux/skbuff.hif(skb->tail>skb->end)
end423include/linux/skbuff.hreturn skb->end-skb->tail;
end56include/net/ip.hint    end;    /* last byte of data in datagram  */
end809mm/filemap.cunsigned long end;
end822mm/filemap.cend = address + size;
end823mm/filemap.cif (end > PMD_SIZE)
end824mm/filemap.cend = PMD_SIZE;
end830mm/filemap.c} while (address < end);
end839mm/filemap.cunsigned long offset, end;
end852mm/filemap.cend = address + size;
end853mm/filemap.cif (end > PGDIR_SIZE)
end854mm/filemap.cend = PGDIR_SIZE;
end857mm/filemap.cerror |= filemap_sync_pte_range(pmd, address, end - address, vma, offset, flags);
end860mm/filemap.c} while (address < end);
end868mm/filemap.cunsigned long end = address + size;
end872mm/filemap.cflush_cache_range(vma->vm_mm, end - size, end);
end873mm/filemap.cwhile (address < end) {
end874mm/filemap.cerror |= filemap_sync_pmd_range(dir, address, end - address, vma, flags);
end878mm/filemap.cflush_tlb_range(vma->vm_mm, end - size, end);
end963mm/filemap.cunsigned long start, unsigned long end, int flags)
end969mm/filemap.cerror = vma->vm_ops->sync(vma, start, end-start, flags);
end981mm/filemap.cunsigned long end;
end988mm/filemap.cend = start + len;
end989mm/filemap.cif (end < start)
end993mm/filemap.cif (end == start)
end1011mm/filemap.cif (end <= vma->vm_end) {
end1012mm/filemap.cif (start < end) {
end1013mm/filemap.cerror = msync_interval(vma, start, end, flags);
end214mm/memory.cunsigned long end;
end230mm/memory.cend = address + size;
end231mm/memory.cif (end >= PMD_SIZE)
end232mm/memory.cend = PMD_SIZE;
end239mm/memory.c} while (address < end);
end246mm/memory.cunsigned long end;
end263mm/memory.cend = address + size;
end264mm/memory.cif (end > PGDIR_SIZE)
end265mm/memory.cend = PGDIR_SIZE;
end267mm/memory.cerror = copy_pte_range(dst_pmd++, src_pmd++, address, end - address, cow);
end271mm/memory.c} while (address < end);
end285mm/memory.cunsigned long end = vma->vm_end;
end293mm/memory.cwhile (address < end) {
end294mm/memory.cerror = copy_pmd_range(dst_pgd++, src_pgd++, address, end - address, cow);
end325mm/memory.cunsigned long end;
end336mm/memory.cend = address + size;
end337mm/memory.cif (end >= PMD_SIZE)
end338mm/memory.cend = PMD_SIZE;
end345mm/memory.c} while (address < end);
end351mm/memory.cunsigned long end;
end362mm/memory.cend = address + size;
end363mm/memory.cif (end > PGDIR_SIZE)
end364mm/memory.cend = PGDIR_SIZE;
end366mm/memory.czap_pte_range(pmd, address, end - address);
end369mm/memory.c} while (address < end);
end378mm/memory.cunsigned long end = address + size;
end381mm/memory.cflush_cache_range(mm, end - size, end);
end382mm/memory.cwhile (address < end) {
end383mm/memory.czap_pmd_range(dir, address, end - address);
end387mm/memory.cflush_tlb_range(mm, end - size, end);
end393mm/memory.cunsigned long end;
end396mm/memory.cend = address + size;
end397mm/memory.cif (end > PMD_SIZE)
end398mm/memory.cend = PMD_SIZE;
end405mm/memory.c} while (address < end);
end410mm/memory.cunsigned long end;
end413mm/memory.cend = address + size;
end414mm/memory.cif (end > PGDIR_SIZE)
end415mm/memory.cend = PGDIR_SIZE;
end420mm/memory.czeromap_pte_range(pte, address, end - address, zero_pte);
end423mm/memory.c} while (address < end);
end432mm/memory.cunsigned long end = address + size;
end437mm/memory.cflush_cache_range(current->mm, beg, end);
end438mm/memory.cwhile (address < end) {
end443mm/memory.cerror = zeromap_pmd_range(pmd, address, end - address, zero_pte);
end449mm/memory.cflush_tlb_range(current->mm, beg, end);
end461mm/memory.cunsigned long end;
end464mm/memory.cend = address + size;
end465mm/memory.cif (end > PMD_SIZE)
end466mm/memory.cend = PMD_SIZE;
end476mm/memory.c} while (address < end);
end482mm/memory.cunsigned long end;
end485mm/memory.cend = address + size;
end486mm/memory.cif (end > PGDIR_SIZE)
end487mm/memory.cend = PGDIR_SIZE;
end493mm/memory.cremap_pte_range(pte, address, end - address, address + offset, prot);
end496mm/memory.c} while (address < end);
end505mm/memory.cunsigned long end = from + size;
end510mm/memory.cwhile (from < end) {
end515mm/memory.cerror = remap_pmd_range(pmd, from, end - from, offset + from, prot);
end27mm/mlock.cunsigned long end, int newflags)
end35mm/mlock.cvma->vm_start = end;
end36mm/mlock.cn->vm_end = end;
end69mm/mlock.cunsigned long start, unsigned long end, int newflags)
end85mm/mlock.cvma->vm_end = end;
end86mm/mlock.cright->vm_start = end;
end102mm/mlock.cunsigned long start, unsigned long end, unsigned int newflags)
end110mm/mlock.cif (end == vma->vm_end)
end113mm/mlock.cretval = mlock_fixup_start(vma, end, newflags);
end115mm/mlock.cif (end == vma->vm_end)
end118mm/mlock.cretval = mlock_fixup_middle(vma, start, end, newflags);
end122mm/mlock.cpages = (end - start) >> PAGE_SHIFT;
end128mm/mlock.cwhile (start < end) {
end139mm/mlock.cunsigned long nstart, end, tmp;
end146mm/mlock.cend = start + len;
end147mm/mlock.cif (end < start)
end149mm/mlock.cif (end == start)
end164mm/mlock.cif (vma->vm_end >= end) {
end165mm/mlock.cerror = mlock_fixup(vma, nstart, end, newflags);
end181mm/mlock.cmerge_segments(current, start, end);
end608mm/mmap.cunsigned long end = addr + len;
end611mm/mmap.cend <= area->vm_start || end > area->vm_end ||
end612mm/mmap.cend < addr)
end615mm/mmap.carea->vm_start, area->vm_end, addr, end);
end623mm/mmap.cif (addr == area->vm_start && end == area->vm_end) {
end632mm/mmap.cif (end == area->vm_end)
end636mm/mmap.carea->vm_offset += (end - area->vm_start);
end637mm/mmap.carea->vm_start = end;
end647mm/mmap.cmpnt->vm_offset += (end - area->vm_start);
end648mm/mmap.cmpnt->vm_start = end;
end724mm/mmap.cunsigned long st, end;
end732mm/mmap.cend = addr+len;
end733mm/mmap.cend = end > mpnt->vm_end ? mpnt->vm_end : end;
end736mm/mmap.cmpnt->vm_ops->unmap(mpnt, st, end-st);
end737mm/mmap.czap_page_range(current->mm, st, end-st);
end738mm/mmap.cunmap_fixup(mpnt, st, end-st);
end24mm/mprotect.cunsigned long end;
end35mm/mprotect.cend = address + size;
end36mm/mprotect.cif (end > PMD_SIZE)
end37mm/mprotect.cend = PMD_SIZE;
end44mm/mprotect.c} while (address < end);
end51mm/mprotect.cunsigned long end;
end62mm/mprotect.cend = address + size;
end63mm/mprotect.cif (end > PGDIR_SIZE)
end64mm/mprotect.cend = PGDIR_SIZE;
end66mm/mprotect.cchange_pte_range(pmd, address, end - address, newprot);
end69mm/mprotect.c} while (address < end);
end72mm/mprotect.cstatic void change_protection(unsigned long start, unsigned long end, pgprot_t newprot)
end78mm/mprotect.cflush_cache_range(current->mm, beg, end);
end79mm/mprotect.cwhile (start < end) {
end80mm/mprotect.cchange_pmd_range(dir, start, end - start, newprot);
end84mm/mprotect.cflush_tlb_range(current->mm, beg, end);
end97mm/mprotect.cunsigned long end,
end106mm/mprotect.cvma->vm_start = end;
end107mm/mprotect.cn->vm_end = end;
end143mm/mprotect.cunsigned long start, unsigned long end,
end160mm/mprotect.cvma->vm_end = end;
end161mm/mprotect.cright->vm_start = end;
end178mm/mprotect.cunsigned long start, unsigned long end, unsigned int newflags)
end187mm/mprotect.cif (end == vma->vm_end)
end190mm/mprotect.cerror = mprotect_fixup_start(vma, end, newflags, newprot);
end191mm/mprotect.celse if (end == vma->vm_end)
end194mm/mprotect.cerror = mprotect_fixup_middle(vma, start, end, newflags, newprot);
end199mm/mprotect.cchange_protection(start, end, newprot);
end205mm/mprotect.cunsigned long nstart, end, tmp;
end212mm/mprotect.cend = start + len;
end213mm/mprotect.cif (end < start)
end217mm/mprotect.cif (end == start)
end234mm/mprotect.cif (vma->vm_end >= end) {
end235mm/mprotect.cerror = mprotect_fixup(vma, nstart, end, newflags);
end251mm/mprotect.cmerge_segments(current, start, end);
end30mm/mremap.cgoto end;
end34mm/mremap.cgoto end;
end39mm/mremap.cgoto end;
end43mm/mremap.cgoto end;
end49mm/mremap.cend:
end200mm/swapfile.cunsigned long end;
end212mm/swapfile.cend = address + size;
end213mm/swapfile.cif (end > PMD_SIZE)
end214mm/swapfile.cend = PMD_SIZE;
end220mm/swapfile.c} while (address < end);
end229mm/swapfile.cunsigned long offset, end;
end241mm/swapfile.cend = address + size;
end242mm/swapfile.cif (end > PGDIR_SIZE)
end243mm/swapfile.cend = PGDIR_SIZE;
end245mm/swapfile.cif (unuse_pmd(vma, pmd, address, end - address, offset, type, page))
end249mm/swapfile.c} while (address < end);
end254mm/swapfile.cunsigned long start, unsigned long end,
end257mm/swapfile.cwhile (start < end) {
end258mm/swapfile.cif (unuse_pgd(vma, pgdir, start, end - start, type, page))
end44mm/vmalloc.cunsigned long end;
end55mm/vmalloc.cend = address + size;
end56mm/vmalloc.cif (end > PMD_SIZE)
end57mm/vmalloc.cend = PMD_SIZE;
end58mm/vmalloc.cwhile (address < end) {
end76mm/vmalloc.cunsigned long end;
end87mm/vmalloc.cend = address + size;
end88mm/vmalloc.cif (end > PGDIR_SIZE)
end89mm/vmalloc.cend = PGDIR_SIZE;
end90mm/vmalloc.cwhile (address < end) {
end91mm/vmalloc.cfree_area_pte(pmd, address, end - address);
end100mm/vmalloc.cunsigned long end = address + size;
end104mm/vmalloc.cwhile (address < end) {
end105mm/vmalloc.cfree_area_pmd(dir, address, end - address);
end114mm/vmalloc.cunsigned long end;
end117mm/vmalloc.cend = address + size;
end118mm/vmalloc.cif (end > PMD_SIZE)
end119mm/vmalloc.cend = PMD_SIZE;
end120mm/vmalloc.cwhile (address < end) {
end136mm/vmalloc.cunsigned long end;
end139mm/vmalloc.cend = address + size;
end140mm/vmalloc.cif (end > PGDIR_SIZE)
end141mm/vmalloc.cend = PGDIR_SIZE;
end142mm/vmalloc.cwhile (address < end) {
end146mm/vmalloc.cif (alloc_area_pte(pte, address, end - address))
end157mm/vmalloc.cunsigned long end = address + size;
end161mm/vmalloc.cwhile (address < end) {
end165mm/vmalloc.cif (alloc_area_pmd(pmd, address, end - address))
end178mm/vmalloc.cunsigned long end;
end181mm/vmalloc.cend = address + size;
end182mm/vmalloc.cif (end > PMD_SIZE)
end183mm/vmalloc.cend = PMD_SIZE;
end191mm/vmalloc.c} while (address < end);
end197mm/vmalloc.cunsigned long end;
end200mm/vmalloc.cend = address + size;
end201mm/vmalloc.cif (end > PGDIR_SIZE)
end202mm/vmalloc.cend = PGDIR_SIZE;
end208mm/vmalloc.cremap_area_pte(pte, address, end - address, address + offset);
end211mm/vmalloc.c} while (address < end);
end218mm/vmalloc.cunsigned long end = address + size;
end223mm/vmalloc.cwhile (address < end) {
end227mm/vmalloc.cif (remap_area_pmd(pmd, address, end - address, offset + address))
end160mm/vmscan.cpmd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
end176mm/vmscan.cif (end > pmd_end)
end177mm/vmscan.cend = pmd_end;
end187mm/vmscan.c} while (address < end);
end192mm/vmscan.cpgd_t *dir, unsigned long address, unsigned long end, int dma, int wait)
end208mm/vmscan.cif (end > pgd_end)
end209mm/vmscan.cend = pgd_end;
end212mm/vmscan.cint result = swap_out_pmd(tsk, vma, pmd, address, end, dma, wait);
end217mm/vmscan.c} while (address < end);
end224mm/vmscan.cunsigned long end;
end231mm/vmscan.cend = vma->vm_end;
end232mm/vmscan.cwhile (start < end) {
end233mm/vmscan.cint result = swap_out_pgd(tsk, vma, pgdir, start, end, dma, wait);
end200net/ax25/ax25_out.cunsigned short start, end, next;
end205net/ax25/ax25_out.cend   = (ax25->va + ax25->window) % ax25->modulus;
end208net/ax25/ax25_out.cstart != end                                   &&
end232net/ax25/ax25_out.clast = (next == end) || skb_peek(&ax25->write_queue) == NULL;
end234net/ax25/ax25_out.clast = (next == end);
end162net/core/skbuff.cif(skb->tail>skb->end)
end166net/core/skbuff.cskb,skb->tail,skb->end);
end180net/core/skbuff.cskb,skb->data,skb->end,skb->len);
end183net/core/skbuff.cif((unsigned long) skb->end > (unsigned long) skb)
end187net/core/skbuff.cskb,skb->end);
end506net/core/skbuff.cif(skb->tail>skb->end)
end541net/core/skbuff.creturn skb->end-skb->tail;
end549net/core/skbuff.cif(skb->tail>skb->end)
end701net/core/skbuff.cskb->end=bptr+len;
end797net/core/skbuff.cmemcpy(n->head,skb->head,skb->end-skb->head);
end1228net/ipv4/arp.cgoto end;
end1280net/ipv4/arp.cend:
end79net/ipv4/ip_fragment.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
end94net/ipv4/ip_fragment.cfp->end = end;
end95net/ipv4/ip_fragment.cfp->len = end - offset;
end312net/ipv4/ip_fragment.coffset = fp->end;
end405net/ipv4/ip_fragment.cint i, ihl, end;
end475net/ipv4/ip_fragment.cend = offset + ntohs(iph->tot_len) - ihl;
end488net/ipv4/ip_fragment.cqp->len = end;
end509net/ipv4/ip_fragment.cif (prev != NULL && offset < prev->end)
end511net/ipv4/ip_fragment.ci = prev->end - offset;
end524net/ipv4/ip_fragment.cif (tmp->offset >= end)
end527net/ipv4/ip_fragment.ci = end - next->offset;      /* overlap is 'i' bytes */
end557net/ipv4/ip_fragment.ctfp = ip_frag_create(offset, end, skb, ptr);
end508net/ipv4/ip_masq_app.cskb->end = skb->head+n_len;
end145net/netrom/nr_out.cunsigned short start, end, next;
end150net/netrom/nr_out.cend   = (sk->nr->va + sk->window) % NR_MODULUS;
end153net/netrom/nr_out.cstart != end                                  &&
end175net/netrom/nr_out.clast = (next == end);
end123scripts/ksymoops.ccKSym* end = &ksyms_0_[cardinality_ - 1];
end124scripts/ksymoops.ccif (address < start->address_ || address >= end->address_)
end128scripts/ksymoops.ccwhile (start <= end) {
end129scripts/ksymoops.ccmid = &start[(end - start) / 2];
end133scripts/ksymoops.ccend = mid - 1;
end313scripts/ksymoops.ccunsigned char* end = &code[code_size];
end314scripts/ksymoops.ccwhile (cp < end) {