taglinefilesource code
len297fs/binfmt_elf.cunsigned int len;
len303fs/binfmt_elf.clen = 0;
len364fs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len366fs/binfmt_elf.cif (bss > len)
len367fs/binfmt_elf.czeromap_page_range(len, bss-len, PAGE_COPY);
len326fs/exec.cint len, offset = 0;
len342fs/exec.clen=0;    /* remember zero-padding */
len344fs/exec.clen++;
len346fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
len350fs/exec.cwhile (len) {
len351fs/exec.c--p; --tmp; --len;
len815fs/exec.cunsigned int len;
len854fs/exec.clen = (ex.a_text + ex.a_data + 0xfff) & 0xfffff000;
len856fs/exec.cif (bss > len)
len857fs/exec.czeromap_page_range(start_addr + len, bss-len, PAGE_COPY);
len56fs/ext/namei.cstatic int ext_match(int len,const char * name,struct ext_dir_entry * de)
len60fs/ext/namei.cif (!de || !de->inode || len > EXT_NAME_LEN)
len63fs/ext/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len65fs/ext/namei.cif (len < EXT_NAME_LEN && len != de->name_len)
len71fs/ext/namei.c:"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
len157fs/ext/namei.cint ext_lookup(struct inode * dir,const char * name, int len,
len171fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
len306fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
len324fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len340fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len348fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len381fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len397fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
len403fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len446fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len523fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
len531fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len576fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
len585fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len619fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
len649fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len658fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len674fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len689fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len696fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len27fs/ext2/dcache.cint len;
len83fs/ext2/dcache.cconst char * name, int len)
len88fs/ext2/dcache.cp->dir != dir || p->len != len ||
len89fs/ext2/dcache.cstrncmp (name, p->name, p->len) != 0);
len197fs/ext2/dcache.cconst char * name, int len)
len205fs/ext2/dcache.cif (len > EXT2_NAME_LEN)
len206fs/ext2/dcache.clen = EXT2_NAME_LEN;
len207fs/ext2/dcache.cmemcpy (our_name, (char *) name, len);
len208fs/ext2/dcache.cour_name[len] = '\0';
len210fs/ext2/dcache.cprintk ("dcache_lookup (%04x, %d, %s, %d)\n", dev, dir, our_name, len);
len213fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, our_name, len))) {
len247fs/ext2/dcache.cint len, int ino)
len256fs/ext2/dcache.cdev, dir, name, len, ino);
len258fs/ext2/dcache.cif (len > EXT2_NAME_LEN)
len259fs/ext2/dcache.clen = EXT2_NAME_LEN;
len261fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
len290fs/ext2/dcache.cstrncpy (p->name, name, len);
len291fs/ext2/dcache.cp->len = len;
len292fs/ext2/dcache.cp->name[len] = '\0';
len307fs/ext2/dcache.cconst char * name, int len)
len315fs/ext2/dcache.cprintk ("dcache_remove (%04x, %d, %s, %d)\n", dev, dir, name, len);
len317fs/ext2/dcache.cif (len > EXT2_NAME_LEN)
len318fs/ext2/dcache.clen = EXT2_NAME_LEN;
len320fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
len32fs/ext2/namei.cstatic int ext2_match (int len, const char * const name,
len37fs/ext2/namei.cif (!de || !de->inode || len > EXT2_NAME_LEN)
len40fs/ext2/namei.cif (!len && de->name_len == 1 && (de->name[0] == '.') &&
len43fs/ext2/namei.cif (len != de->name_len)
len49fs/ext2/namei.c:"S" ((long) name), "D" ((long) de->name), "c" (len)
len115fs/ext2/namei.cint ext2_lookup (struct inode * dir, const char * name, int len,
len130fs/ext2/namei.cif (!(ino = ext2_dcache_lookup (dir->i_dev, dir->i_ino, name, len))) {
len132fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
len304fs/ext2/namei.cint ext2_create (struct inode * dir,const char * name, int len, int mode,
len323fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len343fs/ext2/namei.cint ext2_mknod (struct inode * dir, const char * name, int len, int mode,
len353fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len386fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len406fs/ext2/namei.cint ext2_mkdir (struct inode * dir, const char * name, int len, int mode)
len415fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len459fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len534fs/ext2/namei.cint ext2_rmdir (struct inode * dir, const char * name, int len)
len545fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len606fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
len618fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len662fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
len711fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len720fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len741fs/ext2/namei.cconst char * name, int len)
len757fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len764fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len26fs/isofs/namei.cstatic int isofs_match(int len,const char * name, char * compare, int dlen)
len32fs/isofs/namei.cif (!len && (compare[0]==0) && (dlen==1))
len35fs/isofs/namei.cif (compare[0]==0 && dlen==1 && len == 1)
len37fs/isofs/namei.cif (compare[0]==1 && dlen==1 && len == 2) {
len42fs/isofs/namei.cif (len <= 2) printk("Match: %d %d %s %d %d \n",len,dlen,compare,de->name[0], dlen);
len45fs/isofs/namei.cif (dlen != len)
len51fs/isofs/namei.c:"0" (0),"S" ((long) name),"D" ((long) compare),"c" (len)
len197fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
len204fs/isofs/namei.cprintk("lookup: %x %d\n",dir->i_ino, len);
len220fs/isofs/namei.clen == cache.dlen && 
len221fs/isofs/namei.cisofs_match(len, name, cache.filename, cache.dlen))
len234fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
len70fs/isofs/rock.clen = cont_size; \
len85fs/isofs/rock.cint len;
len100fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len106fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len108fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len110fs/isofs/rock.cchr += rr->len; 
len111fs/isofs/rock.clen -= rr->len;
len158fs/isofs/rock.cint len;
len166fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len172fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len174fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len176fs/isofs/rock.cchr += rr->len; 
len177fs/isofs/rock.clen -= rr->len;
len206fs/isofs/rock.cif((strlen(retname) + rr->len - 5) >= 254) {
len210fs/isofs/rock.cstrncat(retname, rr->u.NM.name, rr->len - 5);
len211fs/isofs/rock.cretnamlen += rr->len - 5;
len240fs/isofs/rock.cint len;
len246fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len253fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len255fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len257fs/isofs/rock.cchr += rr->len; 
len258fs/isofs/rock.clen -= rr->len;
len300fs/isofs/rock.cslen = rr->len - 5;
len305fs/isofs/rock.cinode->i_size += slp->len;
len319fs/isofs/rock.cslen -= slp->len + 2;
len320fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len374fs/isofs/rock.cint len;
len405fs/isofs/rock.cSETUP_ROCK_RIDGE(raw_inode, chr, len);
len408fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len411fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len413fs/isofs/rock.cchr += rr->len; 
len414fs/isofs/rock.clen -= rr->len;
len426fs/isofs/rock.cslen = rr->len - 5;
len435fs/isofs/rock.cstrncat(rpnt,slp->text, slp->len);
len449fs/isofs/rock.cslen -= slp->len + 2;
len450fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len44fs/isofs/rock.hunsigned char len;
len87fs/isofs/rock.hunsigned char len;
len23fs/minix/namei.cstatic inline int namecompare(int len, int maxlen,
len26fs/minix/namei.cif (len >= maxlen || !buffer[len]) {
len30fs/minix/namei.c:"S" ((long) name),"D" ((long) buffer),"c" (len)
len44fs/minix/namei.cstatic int minix_match(int len, const char * name,
len52fs/minix/namei.cif (!de->inode || len > info->s_namelen)
len55fs/minix/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len57fs/minix/namei.creturn namecompare(len,info->s_namelen,name,de->name);
len111fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
len125fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
len214fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
len233fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
len249fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len258fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len291fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len307fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
len320fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len359fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len434fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
len442fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len485fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
len495fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len534fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
len564fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len573fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
len589fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len605fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len612fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len33fs/msdos/namei.cstatic int msdos_format_name(char conv,const char *name,int len,char *res,
len41fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len44fs/msdos/namei.cwhile (len--) *res++ = '.';
len49fs/msdos/namei.cfor (walk = res; len && walk-res < 8; walk++) {
len51fs/msdos/namei.clen--;
len61fs/msdos/namei.cif (conv == 's' && len && c != '.') {
len63fs/msdos/namei.clen--;
len66fs/msdos/namei.cwhile (c != '.' && len--) c = *name++;
len69fs/msdos/namei.cwhile (len > 0 && walk-res < MSDOS_NAME) {
len71fs/msdos/namei.clen--;
len82fs/msdos/namei.cif (conv == 's' && len) return -EINVAL;
len93fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
len99fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len105fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
len119fs/msdos/namei.cif (len == 1 && name[0] == '.') {
len123fs/msdos/namei.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len130fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
len191fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
len200fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len239fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
len247fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len289fs/msdos/namei.cif (msdos_rmdir(dir,name,len) < 0)
len321fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
len331fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len333fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
len358fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
len367fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
len97fs/namei.cint lookup(struct inode * dir,const char * name, int len,
len108fs/namei.cif (len==2 && name[0] == '.' && name[1] == '.') {
len129fs/namei.cif (!len) {
len133fs/namei.creturn dir->i_op->lookup(dir,name,len,result);
len164fs/namei.cint len,error;
len180fs/namei.cfor(len=0;(c = *(pathname++))&&(c != '/');len++)
len185fs/namei.cerror = lookup(base,thisname,len,&inode);
len199fs/namei.c*namelen = len;
len23fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
len25fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len27fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
len28fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
len29fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
len30fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
len33fs/nfs/dir.cconst char *name, int len);
len34fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
len286fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
len291fs/nfs/dir.cchar name[len > NFS_MAXNAMLEN? 1 : len+1];
len300fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len304fs/nfs/dir.cmemcpy(name,__name,len);
len305fs/nfs/dir.cname[len] = '\0';
len306fs/nfs/dir.cif (len == 1 && name[0] == '.') { /* cheat for "." */
len327fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len341fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len362fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
len375fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len394fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
len406fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len421fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
len430fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len441fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
len450fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len461fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
len472fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len490fs/nfs/dir.cconst char *name, int len)
len506fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len23fs/nfs/file.cunsigned long addr, size_t len, int prot, unsigned long off);
len49fs/nfs/mmap.cunsigned long addr, size_t len, int prot, unsigned long off)
len68fs/nfs/mmap.cunmap_page_range(addr, len);
len71fs/nfs/mmap.cmpnt->vm_end = addr + len;
len66fs/nfs/proc.cint len, quadlen;
len68fs/nfs/proc.clen = strlen(string);
len69fs/nfs/proc.cquadlen = (len + 3) >> 2;
len70fs/nfs/proc.c*p++ = htonl(len);
len71fs/nfs/proc.cmemcpy((char *) p, string, len);
len72fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
len79fs/nfs/proc.cunsigned int len;
len81fs/nfs/proc.clen = ntohl(*p++);
len82fs/nfs/proc.cif (len > maxlen)
len84fs/nfs/proc.cmemcpy(string, (char *) p, len);
len85fs/nfs/proc.cstring[len] = '\0';
len86fs/nfs/proc.cp += (len + 3) >> 2;
len90fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
len94fs/nfs/proc.cquadlen = (len + 3) >> 2;
len95fs/nfs/proc.c*p++ = htonl(len);
len96fs/nfs/proc.cmemcpy((char *) p, data, len);
len97fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
len104fs/nfs/proc.cunsigned int len;
len106fs/nfs/proc.clen = *lenp = ntohl(*p++);
len107fs/nfs/proc.cif (len > maxlen)
len109fs/nfs/proc.cmemcpy(data, (char *) p, len);
len110fs/nfs/proc.cp += (len + 3) >> 2;
len285fs/nfs/proc.cint len = 0; /* = 0 is for gcc */
len301fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
len306fs/nfs/proc.cPRINTK("NFS reply read %d\n", len);
len311fs/nfs/proc.creturn (status == NFS_OK) ? len : -nfs_stat_to_errno(status);
len40fs/nfs/sock.cint len;
len53fs/nfs/sock.clen = ((char *) end) - ((char *) start);
len70fs/nfs/sock.cresult = sock->ops->send(sock, (void *) start, len, 0, 0);
len70fs/proc/base.cint proc_match(int len,const char * name,struct proc_dir_entry * de)
len77fs/proc/base.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len79fs/proc/base.cif (de->namelen != len)
len85fs/proc/base.c:"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
len90fs/proc/base.cstatic int proc_lookupbase(struct inode * dir,const char * name, int len,
len106fs/proc/base.cwhile (i-- > 0 && !proc_match(len,name,base_dir+i))
len53fs/proc/fd.cstatic int proc_lookupfd(struct inode * dir,const char * name, int len,
len73fs/proc/fd.cif (!len || (name[0] == '.' && (len == 1 ||
len74fs/proc/fd.c(name[1] == '.' && len == 2)))) {
len75fs/proc/fd.cif (len < 2) {
len88fs/proc/fd.cwhile (len-- > 0) {
len101fs/proc/net.cstatic int proc_lookupnet(struct inode * dir,const char * name, int len,
len115fs/proc/net.cwhile (i-- > 0 && !proc_match(len,name,net_dir+i))
len71fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
len85fs/proc/root.cwhile (i-- > 0 && !proc_match(len,name,root_dir+i))
len97fs/proc/root.cwhile (len-- > 0) {
len31fs/xiafs/namei.cstatic int xiafs_match(int len, const char * name, struct xiafs_direct * dep)
len35fs/xiafs/namei.cif (!dep || !dep->d_ino || len > _XIAFS_NAME_LEN)
len38fs/xiafs/namei.cif (!len && (dep->d_name[0]=='.') && (dep->d_name[1]=='\0'))
len40fs/xiafs/namei.cif (len != dep->d_name_len)
len42fs/xiafs/namei.cfor (i=0; i < len; i++)
len115fs/xiafs/namei.cint xiafs_lookup(struct inode * dir, const char * name, int len,
len129fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
len240fs/xiafs/namei.cint xiafs_create(struct inode * dir, const char * name, int len, int mode,
len258fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len274fs/xiafs/namei.cint xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
len282fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len315fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len331fs/xiafs/namei.cint xiafs_mkdir(struct inode * dir, const char * name, int len, int mode)
len337fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len380fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len480fs/xiafs/namei.cint xiafs_rmdir(struct inode * dir, const char * name, int len)
len488fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len531fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
len541fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len579fs/xiafs/namei.cint len, const char * symname)
len587fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
len614fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len631fs/xiafs/namei.cconst char * name, int len)
len646fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
len653fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len64include/linux/ext_fs.hextern int ext_lookup(struct inode * dir,const char * name, int len,
len66include/linux/ext_fs.hextern int ext_create(struct inode * dir,const char * name, int len, int mode,
len68include/linux/ext_fs.hextern int ext_mkdir(struct inode * dir, const char * name, int len, int mode);
len69include/linux/ext_fs.hextern int ext_rmdir(struct inode * dir, const char * name, int len);
len70include/linux/ext_fs.hextern int ext_unlink(struct inode * dir, const char * name, int len);
len71include/linux/ext_fs.hextern int ext_symlink(struct inode * inode, const char * name, int len,
len73include/linux/ext_fs.hextern int ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len74include/linux/ext_fs.hextern int ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len32include/linux/ip.hunsigned char  len;
len131include/linux/iso_fs.hextern int get_rock_ridge_filename(struct iso_directory_record *, char ** name, int * len, struct inode *);
len169include/linux/iso_fs.hextern int isofs_lookup(struct inode * dir,const char * name, int len,
len75include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
len77include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
len79include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
len80include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
len81include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
len82include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
len84include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len85include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len123include/linux/mm.hextern int do_mmap(struct file * file, unsigned long addr, unsigned long len,
len157include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
len159include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
len161include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
len162include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
len163include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
len110include/linux/net.hint  (*listen)  (struct socket *sock, int len);
len111include/linux/net.hint  (*send)    (struct socket *sock, void *buff, int len, int nonblock,
len113include/linux/net.hint  (*recv)    (struct socket *sock, void *buff, int len, int nonblock,
len115include/linux/net.hint  (*sendto)  (struct socket *sock, void *buff, int len, int nonblock,
len117include/linux/net.hint  (*recvfrom)  (struct socket *sock, void *buff, int len, int nonblock,
len122include/linux/nfs_fs.hunsigned long addr, size_t len, int prot, unsigned long off);
len24include/linux/udp.hunsigned short  len;
len65include/linux/xia_fs.hextern int xiafs_lookup(struct inode * dir,const char * name, int len, 
len67include/linux/xia_fs.hextern int xiafs_create(struct inode * dir,const char * name, int len, int mode,
len69include/linux/xia_fs.hextern int xiafs_mkdir(struct inode * dir, const char * name, int len, int mode);
len70include/linux/xia_fs.hextern int xiafs_rmdir(struct inode * dir, const char * name, int len);
len71include/linux/xia_fs.hextern int xiafs_unlink(struct inode * dir, const char * name, int len);
len72include/linux/xia_fs.hextern int xiafs_symlink(struct inode * inode, const char * name, int len,
len75include/linux/xia_fs.hconst char * name, int len);
len76include/linux/xia_fs.hextern int xiafs_mknod(struct inode * dir, const char * name, int len, 
len289init/main.cint len = strlen(devnames[n]);
len290init/main.cif (!strncmp(line,devnames[n],len)) {
len291init/main.cROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,16);
len34kernel/blk_drv/ramdisk.cint  len;
len40kernel/blk_drv/ramdisk.clen = CURRENT->current_nr_sectors << 9;
len43kernel/blk_drv/ramdisk.c(addr+len > rd_start+rd_length)) {
len50kernel/blk_drv/ramdisk.clen);
len54kernel/blk_drv/ramdisk.clen);
len93kernel/blk_drv/scsi/aha1542.cstatic int aha1542_out(unchar *cmdp, int len)
len95kernel/blk_drv/scsi/aha1542.cwhile (len--)
len102kernel/blk_drv/scsi/aha1542.cprintk("aha1542_out failed(%d): ", len+1); aha1542_stat();
len106kernel/blk_drv/scsi/aha1542.cstatic int aha1542_in(unchar *cmdp, int len)
len108kernel/blk_drv/scsi/aha1542.cwhile (len--)
len115kernel/blk_drv/scsi/aha1542.cprintk("aha1542_in failed(%d): ", len+1); aha1542_stat();
len1398kernel/blk_drv/scsi/scsi.cvoid *scsi_malloc(unsigned int len)
len1402kernel/blk_drv/scsi/scsi.cif((len & 0x1ff) || len > 4096)
len1406kernel/blk_drv/scsi/scsi.cnbits = len >> 9;
len1416kernel/blk_drv/scsi/scsi.cprintk("SMalloc: %d %x ",len, dma_malloc_buffer + (i << 13) + (j << 9));
len1425kernel/blk_drv/scsi/scsi.cint scsi_free(void *obj, unsigned int len)
len1431kernel/blk_drv/scsi/scsi.cprintk("Sfree %x %d\n",obj, len);
len1442kernel/blk_drv/scsi/scsi.cnbits = len >> 9;
len31kernel/blk_drv/scsi/scsi_ioctl.cunsigned int len,slen;
len35kernel/blk_drv/scsi/scsi_ioctl.clen = get_fs_long ((unsigned long *) buffer);
len38kernel/blk_drv/scsi/scsi_ioctl.cif (len > slen)
len39kernel/blk_drv/scsi/scsi_ioctl.clen = slen + 1;
len40kernel/blk_drv/scsi/scsi_ioctl.cverify_area(VERIFY_WRITE, buffer, len);
len41kernel/blk_drv/scsi/scsi_ioctl.cmemcpy_tofs (buffer, string, len);
len569kernel/blk_drv/scsi/seagate.cint len;
len696kernel/blk_drv/scsi/seagate.clen=current_bufflen;    /* WDE add */
len894kernel/blk_drv/scsi/seagate.clen = buffer->length;
len901kernel/blk_drv/scsi/seagate.clen = SCint->request_bufflen;
len906kernel/blk_drv/scsi/seagate.cprintk("scsi%d : len = %d\n", hostno, len);
len1019kernel/blk_drv/scsi/seagate.cif (!len) {
len1029kernel/blk_drv/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1037kernel/blk_drv/scsi/seagate.cSCint->transfersize, len, data);
len1059kernel/blk_drv/scsi/seagate.clen -= transfersize;
len1064kernel/blk_drv/scsi/seagate.chostno, len, data);
len1120kernel/blk_drv/scsi/seagate.c"=S" (data), "=c" (len) :
len1122kernel/blk_drv/scsi/seagate.c"0" (data), "1" (len) :
len1127kernel/blk_drv/scsi/seagate.cif (!len && nobuffs) {
len1130kernel/blk_drv/scsi/seagate.clen = buffer->length;
len1134kernel/blk_drv/scsi/seagate.chostno, len, data);
len1143kernel/blk_drv/scsi/seagate.ctransfered += len;
len1145kernel/blk_drv/scsi/seagate.cfor (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN |
len1146kernel/blk_drv/scsi/seagate.cSTAT_REQ); --len) {
len1151kernel/blk_drv/scsi/seagate.ctransfered -= len;
len1156kernel/blk_drv/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1164kernel/blk_drv/scsi/seagate.cSCint->transfersize, len, data);
len1186kernel/blk_drv/scsi/seagate.clen -= transfersize;
len1196kernel/blk_drv/scsi/seagate.chostno, len, data);
len1204kernel/blk_drv/scsi/seagate.cprintk("scsi%d: transfered += %d\n", hostno, len);
len1205kernel/blk_drv/scsi/seagate.ctransfered += len;  /* Assume we'll transfer it all, then
len1260kernel/blk_drv/scsi/seagate.c"=D" (data), "=c" (len) :
len1262kernel/blk_drv/scsi/seagate.c"0" (data), "1" (len) :
len1267kernel/blk_drv/scsi/seagate.cprintk("scsi%d: transfered -= %d\n", hostno, len);
len1268kernel/blk_drv/scsi/seagate.ctransfered -= len;    /* Since we assumed all of Len got 
len1273kernel/blk_drv/scsi/seagate.cif (!len && nobuffs) {
len1276kernel/blk_drv/scsi/seagate.clen = buffer->length;
len1280kernel/blk_drv/scsi/seagate.chostno, len, data);
len1347kernel/blk_drv/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1379kernel/blk_drv/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1390kernel/blk_drv/scsi/seagate.clen=current_bufflen;
len121kernel/blk_drv/scsi/wd7000.cstatic inline int command_out(unchar *cmdp, int len)
len123kernel/blk_drv/scsi/wd7000.cwhile (len--)  {
len130kernel/blk_drv/scsi/wd7000.cprintk("wd7000_out WAIT failed(%d): ", len+1);
len404kernel/blk_drv/scsi/wd7000.cany2scsi(sgb->len, sg[i].length);
len149kernel/blk_drv/scsi/wd7000.hunchar len[3];
len130kernel/chr_drv/mem.cunsigned long addr, size_t len, int prot, unsigned long off)
len134kernel/chr_drv/mem.cif (off & 0xfff || off + len < off)
len136kernel/chr_drv/mem.cif (remap_page_range(addr, off, len, prot))
len145kernel/chr_drv/mem.cmpnt->vm_end = addr + len;
len207kernel/chr_drv/mem.cunsigned long addr, size_t len, int prot, unsigned long off)
len211kernel/chr_drv/mem.cif (zeromap_page_range(addr, len, prot))
len50kernel/printk.casmlinkage int sys_syslog(int type, char * buf, int len)
len64kernel/printk.cif (!buf || len < 0)
len66kernel/printk.cif (!len)
len68kernel/printk.cverify_area(VERIFY_WRITE,buf,len);
len79kernel/printk.cwhile (log_size && i < len) {
len95kernel/printk.cif (!buf || len < 0)
len97kernel/printk.cif (!len)
len99kernel/printk.cverify_area(VERIFY_WRITE,buf,len);
len100kernel/printk.ccount = len;
len643kernel/sys.casmlinkage int sys_sethostname(char *name, int len)
len649kernel/sys.cif (len > __NEW_UTS_LEN)
len651kernel/sys.cfor (i=0; i < len; i++) {
len663kernel/sys.casmlinkage int sys_setdomainname(char *name, int len)
len669kernel/sys.cif (len > __NEW_UTS_LEN)
len671kernel/sys.cfor (i=0; i < len; i++) {
len121kernel/vsprintf.cint len;
len198kernel/vsprintf.clen = strlen(s);
len200kernel/vsprintf.cprecision = len;
len201kernel/vsprintf.celse if (len > precision)
len202kernel/vsprintf.clen = precision;
len205kernel/vsprintf.cwhile (len < field_width--)
len207kernel/vsprintf.cfor (i = 0; i < len; ++i)
len209kernel/vsprintf.cwhile (len < field_width--)
len167lib/malloc.cunsigned int len, int priority)
len170lib/malloc.ckmalloc(unsigned int len, int priority)
len181lib/malloc.clen += sizeof(struct hdr_start)+sizeof(struct hdr_end);
len190lib/malloc.cfor (bdir = bucket_dir ; bdir->size < len ; bdir++) {
len284lib/malloc.clen -= sizeof(struct hdr_start)+sizeof(struct hdr_end);
len291lib/malloc.cif(len > hd->size || len > bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end)) {
len293lib/malloc.chd->size,bdir->size,len,hd->file,hd->line,deb_file,deb_line);
len313lib/malloc.cmemset(retval, 0xf0, len);
len314lib/malloc.che = (struct hdr_end *)(((char *)retval)+len);
len317lib/malloc.chd->size = len;
len326lib/malloc.cprintk("kmalloc called with impossibly large argument (%d)\n", len);
len507lib/malloc.cint len = 0;
len523lib/malloc.cif(len > PAGE_SIZE-80) {
len525lib/malloc.clen += sprintf(buffer+len,"...\n");
len526lib/malloc.creturn len;
len528lib/malloc.clen += sprintf(buffer+len,"%08x:%03x %s:%d %s:%d\n",
len537lib/malloc.creturn len;
len38mm/mmap.cint do_mmap(struct file * file, unsigned long addr, unsigned long len,
len43mm/mmap.cif (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
len74mm/mmap.cif (len > TASK_SIZE || addr > TASK_SIZE - len)
len81mm/mmap.cwhile (addr+len < SHM_RANGE_END) {
len85mm/mmap.cif (addr + len <= vmm->vm_start)
len93mm/mmap.cif (addr+len >= SHM_RANGE_END)
len115mm/mmap.cerror = file->f_op->mmap(file->f_inode, file, addr, len, mask, off);
len136mm/mmap.casmlinkage int sys_munmap(unsigned long addr, size_t len)
len140mm/mmap.cif ((addr & ~PAGE_MASK) || addr > LONG_MAX || addr == 0 || addr + len > TASK_SIZE)
len155mm/mmap.cif (addr+len > mpnt->vm_start && addr + len < mpnt->vm_end)
len157mm/mmap.cif (addr <= mpnt->vm_start && addr + len >= mpnt->vm_end) {
len177mm/mmap.cunmap_page_range(addr, len);
len194mm/mmap.cunsigned long addr, size_t len, int prot, unsigned long off)
len220mm/mmap.cunmap_page_range(addr, len);  
len223mm/mmap.cmpnt->vm_end = addr + len;
len83net/drv/slip/slip.cip_dump(unsigned char *ptr, int len)
len277net/drv/slip/slip.csl_recv(struct slip *sl, int len)
len285net/drv/slip/slip.cPRINTK (("SLIP: sending one dgram to IP (len=%d)\r\n", len));
len288net/drv/slip/slip.cip_dump((unsigned char *) &sl->rcv_queue.buf[sl->rcv_queue.tail], len);
len296net/drv/slip/slip.cdone = dev_rint(p, len, 0, dev);
len300net/drv/slip/slip.ceat_sl_queue(&sl->rcv_queue, len);
len307net/drv/slip/slip.csl_send(struct slip *sl, unsigned char *p, int len)
len316net/drv/slip/slip.cip_dump(p, len);
len334net/drv/slip/slip.cwhile(len--) {
len390net/drv/slip/slip.csl_send(sl, (unsigned char *) (skb + 1), skb->len);
len130net/drv/we8003/handler.clong len;
len135net/drv/we8003/handler.clen = ring->count-4;
len136net/drv/we8003/handler.cif (len < 56)
len139net/drv/we8003/handler.creturn (dev_rint(fptr, len, 0, dev));
len146net/drv/we8003/handler.cint len;
len192net/drv/we8003/handler.cmemcpy ((unsigned char *)dev->mem_start, skb+1, skb->len);
len194net/drv/we8003/handler.clen = skb->len;
len198net/drv/we8003/handler.clen=max(len, ETHER_MIN_LEN); /* actually we should zero out
len210net/drv/we8003/handler.coutb_p(len&0xff,WD_TB0);
len211net/drv/we8003/handler.coutb_p(len>>8,WD_TB1);
len416net/drv/we8003/handler.clen = dev_tint( (unsigned char *)dev->mem_start, dev );
len417net/drv/we8003/handler.cif( len != 0 ){
len418net/drv/we8003/handler.clen=max(len, ETHER_MIN_LEN);
len420net/drv/we8003/handler.coutb_p(len&0xff,WD_TB0);
len421net/drv/we8003/handler.coutb_p(len>>8,WD_TB1);
len332net/inet/3c509.cif (skb->len <= 0)
len337net/inet/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
len353net/inet/3c509.coutw(skb->len, ioaddr + TX_FIFO);
len356net/inet/3c509.cport_write_l(ioaddr + TX_FIFO, (void *)(skb+1), (skb->len + 3) >> 2);
len526net/inet/3c509.cskb->len = pkt_len;
len163net/inet/8390.cif (skb->len <= 0)
len165net/inet/8390.clength = skb->len;
len72net/inet/arp.cchar  *(*print)(unsigned char *ptr, int len);
len96net/inet/arp.cunk_print(unsigned char *ptr, int len)
len102net/inet/arp.cfor (i = 0; i < len; i++)
len110net/inet/arp.ceth_aprint(unsigned char *ptr, int len)
len112net/inet/arp.cif (len != ETH_ALEN) return("");
len121net/inet/arp.cint len, idx;
len133net/inet/arp.clen = htons(arp->ar_op);
len134net/inet/arp.cif (len < ARP_MAX_CMDS) idx = len;
len137net/inet/arp.cprintk(arp_cmds[idx], len);
len140net/inet/arp.clen = htons(arp->ar_hrd);
len141net/inet/arp.cif (len < ARP_MAX_TYPE) idx = len;
len143net/inet/arp.cprintk("   hrd = "); printk(arp_types[idx].name, len);
len280net/inet/arp.cskb->len      = sizeof(struct arphdr) + (2 * arp1->ar_hln) + 
len282net/inet/arp.cskb->mem_len  = sizeof(struct sk_buff) + skb->len;
len284net/inet/arp.cETH_P_ARP, src, dst, skb->len);
len544net/inet/arp.cskb->len = sizeof(struct arphdr) +
len546net/inet/arp.cskb->mem_len = sizeof(struct sk_buff) + skb->len;
len551net/inet/arp.cETH_P_ARP, 0, saddr, skb->len);
len380net/inet/d_link.cint    len;
len426net/inet/d_link.cPRINTK(("d_link_start_xmit:len=%d\n", skb->len));
len442net/inet/d_link.cif ((len = skb->len) < RUNT) /*&& Hmm...? */
len443net/inet/d_link.clen = RUNT;
len446net/inet/d_link.ctransmit_from = MEM_4K - len;
len448net/inet/d_link.ctransmit_from = MEM_2K - len;
len452net/inet/d_link.cfor ( ; len > 0; --len, ++buffer) {
len416net/inet/dev.cdev_rint(unsigned char *buff, long len, int flags, struct device *dev)
len424net/inet/dev.cif (dev == NULL || buff == NULL || len <= 0) return(1);
len435net/inet/dev.cskb = (struct sk_buff *) kmalloc(sizeof(*skb) + len, GFP_ATOMIC);
len443net/inet/dev.cskb->mem_len = sizeof(*skb) + len;
len448net/inet/dev.cleft = len;
len449net/inet/dev.clen2 = len;
len462net/inet/dev.cskb->len = len;
len525net/inet/dev.cskb->len -= skb->dev->hard_header_len;
len658net/inet/dev.cint len;
len663net/inet/dev.clen = ifc.ifc_len;
len676net/inet/dev.clen -= sizeof(struct ifreq);
len677net/inet/dev.cif (len < sizeof(struct ifreq)) break;
len126net/inet/dev.hunsigned len);
len175net/inet/dev.hextern int    dev_rint(unsigned char *buff, long len, int flags,
len91net/inet/eth.cunsigned long daddr, unsigned long saddr, unsigned len)
len29net/inet/eth.hunsigned long saddr, unsigned len);
len81net/inet/icmp.cint len;
len87net/inet/icmp.clen = sizeof(struct sk_buff) + dev->hard_header_len +
len91net/inet/icmp.cskb = (struct sk_buff *) kmalloc(len, GFP_ATOMIC);
len97net/inet/icmp.cskb->mem_len = len;
len98net/inet/icmp.clen -= sizeof(struct sk_buff);
len106net/inet/icmp.c&dev, IPPROTO_ICMP, NULL, len);
len114net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
len232net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len239net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
len253net/inet/icmp.cIPPROTO_ICMP, opt, len);
len263net/inet/icmp.cskb2->len = offset + len;
len267net/inet/icmp.cmemcpy((char *) icmphr, (char *) icmph, len);
len273net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len287net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len299net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len306net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
len320net/inet/icmp.cIPPROTO_ICMP, opt, len);
len330net/inet/icmp.cskb2->len = offset + len;
len342net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len356net/inet/icmp.cunsigned long daddr, unsigned short len,
len376net/inet/icmp.cif (ip_compute_csum((unsigned char *) icmph, len)) {
len397net/inet/icmp.cicmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
len404net/inet/icmp.cicmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
len411net/inet/icmp.cicmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
len30net/inet/icmp.hunsigned short len, unsigned long saddr,
len51net/inet/ip.cint addr, len, i;
len68net/inet/ip.clen = ntohs(ip->tot_len) - (4 * ip->ihl);
len69net/inet/ip.cwhile (len > 0) {
len72net/inet/ip.cif (len > 0) {
len81net/inet/ip.clen--;
len146net/inet/ip.cip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev,
len156net/inet/ip.cmac = dev->hard_header(ptr, dev, ETH_P_IP, daddr, saddr, len);
len175net/inet/ip.cstruct device **dev, int type, struct options *opt, int len)
len188net/inet/ip.cskb, saddr, daddr, *dev, type, opt, len));
len210net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
len212net/inet/ip.clen -= tmp;
len250net/inet/ip.cint i, len = sizeof(struct iphdr);
len268net/inet/ip.cwhile (!done && len < iph->ihl*4) switch(*buff) {
len274net/inet/ip.clen++;
len288net/inet/ip.clen += 11;
len293net/inet/ip.clen += *buff;
len308net/inet/ip.clen += *buff;
len323net/inet/ip.clen += *buff;
len336net/inet/ip.clen += 4;
len343net/inet/ip.clen += *buff;
len345net/inet/ip.copt->tstamp.len = *buff / 4 - 1;
len352net/inet/ip.cfor (i = 0; i < opt->tstamp.len; i++) {
len413net/inet/ip.cip_compute_csum(unsigned char * buff, int len)
len418net/inet/ip.cif (len > 3) {
len430net/inet/ip.c: "0" (sum), "c" (len >> 2) ,"1" (buff)
len433net/inet/ip.cif (len & 2) {
len441net/inet/ip.cif (len & 1) {
len543net/inet/ip.cin_ntoa(raddr), dev2->name, skb->len));
len547net/inet/ip.cdev2->hard_header_len + skb->len, GFP_ATOMIC);
len555net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
len557net/inet/ip.cskb2->mem_len = sizeof(struct sk_buff) + skb2->len;
len563net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
len566net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
len722net/inet/ip.ciph->tot_len = ntohs(skb->len - dev->hard_header_len);
len36net/inet/ip.hstruct options *opt, int len);
len37net/inet/ip.hextern unsigned short  ip_compute_csum(unsigned char * buff, int len);
len422net/inet/lance.cif (skb->len <= 0)
len447net/inet/lance.clp->tx_ring[entry].length = -skb->len;
len451net/inet/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len596net/inet/lance.cskb->len = pkt_len;
len64net/inet/loopback.cdone = dev_rint((unsigned char *)(skb+1), skb->len, 0, dev);
len54net/inet/packet.cskb->len += dev->hard_header_len;
len100net/inet/packet.cpacket_sendto(struct sock *sk, unsigned char *from, int len,
len110net/inet/packet.cif (len < 0) return(-EINVAL);
len120net/inet/packet.cskb = (struct sk_buff *) sk->prot->wmalloc(sk, len+sizeof(*skb), 0, GFP_KERNEL);
len129net/inet/packet.cskb->mem_len = len + sizeof(*skb);
len139net/inet/packet.cmemcpy_fromfs (skb+1, from, len);
len140net/inet/packet.cskb->len = len;
len144net/inet/packet.creturn(len);
len150net/inet/packet.cint len, int noblock,  unsigned flags)
len152net/inet/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
len193net/inet/packet.cpacket_recvfrom(struct sock *sk, unsigned char *to, int len,
len202net/inet/packet.cif (len == 0) return(0);
len203net/inet/packet.cif (len < 0) return(-EINVAL);
len238net/inet/packet.ccopied = min(len, skb->len);
len263net/inet/packet.cint len, int noblock, unsigned flags)
len265net/inet/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len128net/inet/plip.cunsigned long h_source, unsigned len);
len276net/inet/plip.cret_val = plip_send_packet(dev, (unsigned char *)(skb+1), skb->len);
len287net/inet/plip.cunsigned long h_source, unsigned len)
len293net/inet/plip.creturn eth_header(buff, dev, type, h_dest, h_source, len);
len28net/inet/protocol.hunsigned short len, unsigned long saddr,
len86net/inet/raw.cunsigned long daddr, unsigned short len, unsigned long saddr,
len93net/inet/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
len108net/inet/raw.cskb->len = len;
len162net/inet/raw.craw_sendto(struct sock *sk, unsigned char *from, int len,
len172net/inet/raw.c"            usin=%X, addr_len = %d)\n", sk, from, len, noblock,
len177net/inet/raw.cif (len < 0) return(-EINVAL);
len197net/inet/raw.clen+sizeof(*skb) + sk->prot->max_header,
len222net/inet/raw.cskb->mem_len = len + sizeof(*skb) +sk->prot->max_header;
len239net/inet/raw.cmemcpy_fromfs ((unsigned char *)(skb+1)+tmp, from, len);
len254net/inet/raw.cskb->len = tmp + len;
len257net/inet/raw.creturn(len);
len262net/inet/raw.craw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len265net/inet/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
len314net/inet/raw.craw_recvfrom(struct sock *sk, unsigned char *to, int len,
len323net/inet/raw.csk, to, len, noblock, flags, sin, addr_len));
len325net/inet/raw.cif (len == 0) return(0);
len326net/inet/raw.cif (len < 0) return(-EINVAL);
len363net/inet/raw.ccopied = min(len, skb->len);
len386net/inet/raw.craw_read (struct sock *sk, unsigned char *buff, int len, int noblock,
len389net/inet/raw.creturn(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len28net/inet/raw.hunsigned short len, unsigned long saddr,
len31net/inet/raw.hint len, int noblock, unsigned flags,
len34net/inet/raw.hint len, int noblock, unsigned flags);
len45net/inet/skbuff.hunsigned long     len;
len483net/inet/slhc.cint len, hdrlen;
len596net/inet/slhc.clen = isize - (cp - icp) + hdrlen;
len597net/inet/slhc.cip->tot_len = htons(len);
len600net/inet/slhc.cDPRINT(("uncomp: %d %d %d %d\n", cp - icp, hdrlen, isize, len));
len602net/inet/slhc.cmemmove(icp + hdrlen, cp, len - hdrlen);
len621net/inet/slhc.cif (inet_debug == DBG_SLIP) printk("\runcomp: change %x len %d\n", changes, len);
len622net/inet/slhc.creturn len;
len62net/inet/slip.cip_dump(unsigned char *ptr, int len)
len79net/inet/slip.cprintk("%p %d\n", ptr, len);
len101net/inet/slip.cvoid clh_dump(unsigned char *cp, int len)
len103net/inet/slip.cif (len > 60)
len104net/inet/slip.clen = 60;
len105net/inet/slip.cprintk("%d:", len);
len106net/inet/slip.cwhile (len > 0) {
len108net/inet/slip.clen--;
len325net/inet/slip.csl_encaps(struct slip *sl, unsigned char *icp, int len)
len331net/inet/slip.cDPRINTF((DBG_SLIP, "SLIP: sl_encaps(0x%X, %d) called\n", icp, len));
len333net/inet/slip.cip_dump(icp, len);
len337net/inet/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
len353net/inet/slip.cwhile(len-- > 0) {
len413net/inet/slip.csl_encaps(sl, (unsigned char *) (skb + 1), skb->len);
len431net/inet/slip.cunsigned long daddr, unsigned long saddr, unsigned len)
len1117net/inet/sock.cint len;
len1119net/inet/sock.clen = get_fs_long(uaddr_len);
len1122net/inet/sock.cif (len < sizeof(sin)) return(-EINVAL);
len1139net/inet/sock.clen = sizeof(sin);
len1140net/inet/sock.cverify_area(VERIFY_WRITE, uaddr, len);
len1142net/inet/sock.cverify_area(VERIFY_WRITE, uaddr_len, sizeof(len));
len1143net/inet/sock.cput_fs_long(len, uaddr_len);
len1602net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
len123net/inet/sock.hint len, int nonblock, unsigned flags);
len125net/inet/sock.hint len, int nonblock, unsigned flags);
len127net/inet/sock.hunsigned char *from, int len, int noblock,
len131net/inet/sock.hunsigned char *from, int len, int noblock,
len138net/inet/sock.hstruct options *opt, int len);
len150net/inet/sock.hunsigned short len, unsigned long saddr,
len216net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);
len375net/inet/tcp.ctcp_check(struct tcphdr *th, int len,
len386net/inet/tcp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_TCP*256)
len389net/inet/tcp.cif (len > 3) {
len397net/inet/tcp.c: "0"(sum), "c"(len/4) ,"1"(th)
len411net/inet/tcp.cif ((len & 2) != 0) {
len421net/inet/tcp.cif ((len & 1) != 0) {
len438net/inet/tcp.cunsigned long daddr, int len, struct sock *sk)
len442net/inet/tcp.cth->check = tcp_check(th, len, saddr, daddr);
len458net/inet/tcp.cskb->len-(unsigned long)skb->h.th +
len512net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len524net/inet/tcp.cbuff->len += tmp;
len590net/inet/tcp.cint len, int nonblock, unsigned flags)
len601net/inet/tcp.csk, from, len, nonblock, flags));
len604net/inet/tcp.cwhile(len > 0) {
len685net/inet/tcp.ccopy = min(sk->mss - skb->len + 128 +
len686net/inet/tcp.cprot->max_header, len);
len694net/inet/tcp.cmemcpy_fromfs((unsigned char *)(skb+1) + skb->len, from, copy);
len695net/inet/tcp.cskb->len += copy;
len698net/inet/tcp.clen -= copy;
len702net/inet/tcp.cif (skb->len -(unsigned long)skb->h.th +
len717net/inet/tcp.ccopy = min(copy, len);
len773net/inet/tcp.cskb->len = 0;
len793net/inet/tcp.cskb->len += tmp;
len797net/inet/tcp.ctmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
len810net/inet/tcp.cskb->len += tmp;
len815net/inet/tcp.clen -= copy;
len816net/inet/tcp.cskb->len += copy;
len853net/inet/tcp.cint len, int nonblock, unsigned flags,
len863net/inet/tcp.creturn(tcp_write(sk, from, len, nonblock, flags));
len898net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len909net/inet/tcp.cbuff->len += tmp;
len1004net/inet/tcp.cunsigned char *to, int len, unsigned flags)
len1010net/inet/tcp.csk, to, len, flags));
len1012net/inet/tcp.cwhile(len > 0) {
len1069net/inet/tcp.cskb->h.th->urg_ptr = ntohs(skb->len);
len1071net/inet/tcp.camt = min(ntohs(skb->h.th->urg_ptr),len);
len1096net/inet/tcp.cint len, int nonblock, unsigned flags)
len1103net/inet/tcp.cif (len == 0) return(0);
len1104net/inet/tcp.cif (len < 0) {
len1112net/inet/tcp.cif ((flags & MSG_OOB)) return(tcp_read_urg(sk, nonblock, to, len, flags));
len1120net/inet/tcp.csk, to, len, nonblock, flags));
len1122net/inet/tcp.cwhile(len > 0) {
len1224net/inet/tcp.cif (offset < skb->len) {
len1233net/inet/tcp.cif (offset >= skb->len) {
len1245net/inet/tcp.cused = min(skb->len - offset, len);
len1250net/inet/tcp.clen -= used;
len1261net/inet/tcp.c(used + offset >= skb->len)) skb->used = 1;
len1323net/inet/tcp.cbuff->len = sizeof(*t1);
len1338net/inet/tcp.cbuff ->len += tmp;
len1378net/inet/tcp.cint len;
len1382net/inet/tcp.clen = get_fs_long(addr_len);
len1383net/inet/tcp.cif (len > sizeof(sin)) len = sizeof(sin);
len1387net/inet/tcp.cverify_area(VERIFY_WRITE, addr, len);
len1388net/inet/tcp.cmemcpy_tofs(addr, &sin, len);
len1389net/inet/tcp.cverify_area(VERIFY_WRITE, addr_len, sizeof(len));
len1390net/inet/tcp.cput_fs_long(len, addr_len);
len1415net/inet/tcp.cbuff->len = sizeof(*t1);
len1429net/inet/tcp.cbuff->len += tmp;
len1590net/inet/tcp.cbuff->len = sizeof(struct tcphdr)+4;
len1610net/inet/tcp.cbuff->len += tmp;
len1693net/inet/tcp.cif (skb->len > 0 &&
len1694net/inet/tcp.cafter(skb->h.th->seq + skb->len + 1, sk->copied_seq))
len1747net/inet/tcp.cbuff->len = sizeof(*t1);
len1762net/inet/tcp.cbuff ->len += tmp;
len1877net/inet/tcp.ctcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
len1898net/inet/tcp.cif (len != th->doff*4) flag |= 1;
len2156net/inet/tcp.cunsigned long saddr, unsigned short len)
len2163net/inet/tcp.cskb->len = len -(th->doff*4);
len2165net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data len = %d sk = %X:\n", skb->len, sk));
len2167net/inet/tcp.csk->bytes_rcv += skb->len;
len2168net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) {
len2176net/inet/tcp.csk->acked_seq = th->seq + skb->len + th->syn + th->fin;
len2231net/inet/tcp.cth->ack_seq = th->seq + skb->len;
len2519net/inet/tcp.cbuff->len = 24;
len2532net/inet/tcp.cbuff->len += tmp;
len2574net/inet/tcp.ctcp_sequence(struct sock *sk, struct tcphdr *th, short len,
len2584net/inet/tcp.csk, th, len, opt, saddr));
len2587net/inet/tcp.cbetween(th->seq + len-(th->doff*4), sk->acked_seq + 1,
len2590net/inet/tcp.cafter(th->seq + len -(th->doff*4), sk->acked_seq + sk->window))) {
len2605net/inet/tcp.cif (th->ack && len == (th->doff * 4) &&
len2634net/inet/tcp.cunsigned long daddr, unsigned short len,
len2663net/inet/tcp.cDPRINTF((DBG_TCP, "len = %d, redo = %d, skb=%X\n", len, redo, skb));
len2670net/inet/tcp.cif (th->check && tcp_check(th, len, saddr, daddr )) {
len2690net/inet/tcp.cskb->len = len;
len2767net/inet/tcp.cif (!tcp_sequence(sk, th, len, opt, saddr)) {
len2816net/inet/tcp.cif (!tcp_ack(sk, th, saddr, len)) {
len2836net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
len2900net/inet/tcp.cif (!tcp_sequence(sk, th, len, opt, saddr)) {
len2944net/inet/tcp.cif (!tcp_ack(sk, th, saddr, len)) {
len2969net/inet/tcp.cif (!tcp_ack(sk, th, saddr, len)) {
len3001net/inet/tcp.cif (tcp_data(skb, sk, saddr, len))
len3017net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
len3054net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len3068net/inet/tcp.cbuff->len += tmp;
len134net/inet/tcp.hunsigned short len, unsigned long saddr, int redo,
len55net/inet/timer.creset_timer (struct sock *t, int timeout, unsigned long len)
len64net/inet/timer.cif ((int) len < 0)  /* prevent close to infinite timers. THEY _DO_ */
len65net/inet/timer.clen = 3;  /* happen (negative values ?) - don't ask me why ! -FB */
len67net/inet/timer.ct->timer.expires = len;
len54net/inet/udp.cprintk("     len = %d, check = %d\n", ntohs(uh->len), ntohs(uh->check));
len121net/inet/udp.cudp_check(struct udphdr *uh, int len,
len127net/inet/udp.cuh, len, saddr, daddr));
len135net/inet/udp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_UDP*256)
len138net/inet/udp.cif (len > 3) {
len146net/inet/udp.c: "0"(sum), "c"(len/4) ,"1"(uh)
len160net/inet/udp.cif ((len & 2) != 0) {
len170net/inet/udp.cif ((len & 1) != 0) {
len187net/inet/udp.cunsigned long daddr, int len, struct sock *sk)
len191net/inet/udp.cuh->check = udp_check(uh, len, saddr, daddr);
len197net/inet/udp.cunsigned char *from, int len)
len209net/inet/udp.cfrom, len));
len212net/inet/udp.csize = sizeof(struct sk_buff) + sk->prot->max_header + len;
len239net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
len247net/inet/udp.cif (len > dev->mtu) {
len248net/inet/udp.cprintk("UDP: send: length %d > mtu %d (ignored)\n", len, dev->mtu);
len255net/inet/udp.cuh->len = htons(len + sizeof(struct udphdr));
len261net/inet/udp.cerr=verify_area(VERIFY_READ, from, len);
len264net/inet/udp.cmemcpy_fromfs(buff, from, len);
len267net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
len272net/inet/udp.creturn(len);
len277net/inet/udp.cudp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
len284net/inet/udp.cDPRINTF((DBG_UDP, "UDP: sendto(len=%d, flags=%X)\n", len, flags));
len288net/inet/udp.cif (len < 0) return(-EINVAL);
len289net/inet/udp.cif (len == 0) return(0);
len309net/inet/udp.ctmp = udp_send(sk, &sin, from, len);
len318net/inet/udp.cudp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len321net/inet/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
len382net/inet/udp.camount = skb->len;
len404net/inet/udp.cudp_recvfrom(struct sock *sk, unsigned char *to, int len,
len412net/inet/udp.cif (len == 0) return(0);
len413net/inet/udp.cif (len < 0) return(-EINVAL);
len438net/inet/udp.cer=verify_area(VERIFY_WRITE,to,len);
len473net/inet/udp.ccopied = min(len, skb->len);
len502net/inet/udp.cudp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
len505net/inet/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len543net/inet/udp.cunsigned long daddr, unsigned short len,
len566net/inet/udp.cif (uh->check && udp_check(uh, len, saddr, daddr)) {
len575net/inet/udp.cskb->len = len;
len625net/inet/udp.cskb->len = len - sizeof(*uh);
len34net/inet/udp.hint len, int noblock, unsigned flags,
len37net/inet/udp.hint len, int noblock, unsigned flags);
len42net/inet/udp.hunsigned short len, unsigned long saddr, int redo,
len662net/socket.csock_send(int fd, void * buff, int len, unsigned flags)
len669net/socket.cfd, buff, len, flags));
len675net/socket.creturn(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
len680net/socket.csock_sendto(int fd, void * buff, int len, unsigned flags,
len688net/socket.c" addr=%X, alen = %d\n", fd, buff, len, flags, addr, addr_len));
len694net/socket.creturn(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
len700net/socket.csock_recv(int fd, void * buff, int len, unsigned flags)
len707net/socket.cfd, buff, len, flags));
len713net/socket.creturn(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
len718net/socket.csock_recvfrom(int fd, void * buff, int len, unsigned flags,
len726net/socket.c" addr=%X, alen=%X\n", fd, buff, len, flags, addr, addr_len));
len732net/socket.creturn(sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
len63net/unix/sock.cstatic int unix_proto_send(struct socket *sock, void *buff, int len,
len65net/unix/sock.cstatic int unix_proto_recv(struct socket *sock, void *buff, int len,
len67net/unix/sock.cstatic int unix_proto_sendto(struct socket *sock, void *buff, int len,
len70net/unix/sock.cstatic int unix_proto_recvfrom(struct socket *sock, void *buff, int len,
len154net/unix/sock.cunix_proto_sendto(struct socket *sock, void *buff, int len, int nonblock, 
len161net/unix/sock.cunix_proto_recvfrom(struct socket *sock, void *buff, int len, int nonblock, 
len177net/unix/sock.cunix_proto_send(struct socket *sock, void *buff, int len, int nonblock,
len181net/unix/sock.creturn(unix_proto_write(sock, (char *) buff, len, nonblock));
len187net/unix/sock.cunix_proto_recv(struct socket *sock, void *buff, int len, int nonblock,
len191net/unix/sock.creturn(unix_proto_read(sock, (char *) buff, len, nonblock));
len524net/unix/sock.cint len;
len537net/unix/sock.cif ((len = get_fs_long(usockaddr_len)) <= 0) return(-EINVAL);
len538net/unix/sock.cif (len > upd->sockaddr_len) len = upd->sockaddr_len;
len539net/unix/sock.cif (len) {
len540net/unix/sock.cverify_area(VERIFY_WRITE, usockaddr, len);
len541net/unix/sock.cmemcpy_tofs(usockaddr, &upd->sockaddr_un, len);
len543net/unix/sock.cput_fs_long(len, usockaddr_len);
len264zBoot/gzip.hvoid     copy_block OF((char *buf, unsigned len, int header));
len204zBoot/misc.cint len, i;
len209zBoot/misc.clen = INBUFSIZ-insize;
len210zBoot/misc.cif (len > (input_len-input_ptr+1)) len=input_len-input_ptr+1;
len211zBoot/misc.cif (len == 0 || len == EOF) break;
len213zBoot/misc.cfor (i=0;i<len;i++) inbuf[insize+i] = input_data[input_ptr+i];
len214zBoot/misc.cinsize += len;
len215zBoot/misc.cinput_ptr += len;
len395zBoot/misc.cunsigned len = (unsigned)get_byte();
len396zBoot/misc.clen |= ((unsigned)get_byte())<<8;
len397zBoot/misc.cwhile (len--) (void)get_byte();
len18zBoot/piggyback.cint c, n=0, len=0;
len35zBoot/piggyback.clen = 0;
len36zBoot/piggyback.cwhile ((n = read(0, &tmp_buf[len], sizeof(tmp_buf)-len+1)) > 0)
len37zBoot/piggyback.clen += n;
len45zBoot/piggyback.cif (len >= sizeof(tmp_buf))
len51zBoot/piggyback.cfprintf(stderr, "Compressed size %d.\n", len);
len56zBoot/piggyback.cobj.a_data = len + sizeof(long);
len63zBoot/piggyback.cwrite(1, tmp_buf, len);
len64zBoot/piggyback.cwrite(1, (char *)&len, sizeof(len));
len69zBoot/piggyback.cvar_names[1].n_value = len;
len75zBoot/piggyback.clen = sizeof(string_names) + sizeof(len);
len76zBoot/piggyback.cwrite(1, (char *)&len, sizeof(len));