taglinefilesource code
len32drivers/block/ramdisk.cint  len;
len38drivers/block/ramdisk.clen = CURRENT->current_nr_sectors << 9;
len41drivers/block/ramdisk.c(addr+len > rd_start+rd_length)) {
len48drivers/block/ramdisk.clen);
len52drivers/block/ramdisk.clen);
len87drivers/char/mem.cunsigned long addr, size_t len, int prot, unsigned long off)
len91drivers/char/mem.cif (off & 0xfff || off + len < off)
len95drivers/char/mem.cif (remap_page_range(addr, off, len, prot))
len104drivers/char/mem.cmpnt->vm_end = addr + len;
len180drivers/char/mem.cunsigned long addr, size_t len, int prot, unsigned long off)
len186drivers/char/mem.cif (zeromap_page_range(addr, len, prot))
len198drivers/char/mem.cmpnt->vm_end = addr + len;
len260drivers/net/3c501.cif (skb->len <= 0)
len267drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len278drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);
len415drivers/net/3c501.cskb->len = pkt_len;
len471drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len826drivers/net/3c507.cskb->len = pkt_len;
len343drivers/net/3c509.cif (skb->len <= 0)
len348drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
len371drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
len374drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
len542drivers/net/3c509.cskb->len = pkt_len;
len168drivers/net/8390.clength = skb->len;
len169drivers/net/8390.cif (skb->len <= 0)
len450drivers/net/8390.cskb->len = pkt_len;
len384drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len511drivers/net/at1700.cskb->len = pkt_len;
len445drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len638drivers/net/atp.cskb->len = pkt_len;
len382drivers/net/d_link.cint    len;
len414drivers/net/d_link.cPRINTK(("d_link_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
len416drivers/net/d_link.cif ((len = skb->len) < RUNT)
len417drivers/net/d_link.clen = RUNT;
len422drivers/net/d_link.ctx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len;
len426drivers/net/d_link.cfor ( ; len > 0; --len, ++buffer)
len810drivers/net/depca.cif (skb->len <= 0) {
len833drivers/net/depca.cint len;
len834drivers/net/depca.clong skbL = skb->len;
len847drivers/net/depca.clen = ((skbL > PKT_SZ) ? PKT_SZ : skbL); /* skb too long */
len848drivers/net/depca.cif (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
len849drivers/net/depca.cskbL -= len;
len850drivers/net/depca.clp->tx_ring[entry].length = -len;
len856drivers/net/depca.cmemcpy((unsigned char *)(buf), skb->data, len);
len868drivers/net/depca.cfor (p += len; skbL > 0; p += len) {
len883drivers/net/depca.clen = ((skbL > DAT_SZ) ? DAT_SZ : skbL); /* skbL too long */
len884drivers/net/depca.cif (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
len885drivers/net/depca.cskbL -= len;
len886drivers/net/depca.clp->tx_ring[entry].length = -len;
len892drivers/net/depca.cmemcpy((unsigned char *)(buf + PKT_HDR_LEN), (unsigned char *)p, len);
len1038drivers/net/depca.cskb->len = pkt_len;
len486drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len933drivers/net/eexpress.cskb->len = pkt_len;
len506drivers/net/lance.cif (skb->len <= 0)
len532drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len534drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
len540drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
len544drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
len715drivers/net/lance.cskb->len = pkt_len;
len59drivers/net/loopback.cdone = dev_rint(skb->data, skb->len, 0, dev);
len141drivers/net/plip.cvoid *source, unsigned len, struct sk_buff *skb);
len281drivers/net/plip.cret_val = plip_send_packet(dev, skb->data, skb->len);
len292drivers/net/plip.cvoid *saddr, unsigned len, struct sk_buff *skb)
len298drivers/net/plip.creturn eth_header(buff, dev, type, daddr, saddr, len, skb);
len289drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len375drivers/net/skeleton.cskb->len = pkt_len;
len489drivers/net/slhc.cint len, hdrlen;
len602drivers/net/slhc.clen = isize - (cp - icp);
len603drivers/net/slhc.cif (len < 0)
len605drivers/net/slhc.clen += hdrlen;
len606drivers/net/slhc.cip->tot_len = htons(len);
len609drivers/net/slhc.cDPRINT(("uncomp: %d %d %d %d\n", cp - icp, hdrlen, isize, len));
len611drivers/net/slhc.cmemmove(icp + hdrlen, cp, len - hdrlen);
len632drivers/net/slhc.cif (inet_debug == DBG_SLIP) printk("\runcomp: change %x len %d\n", changes, len);
len633drivers/net/slhc.creturn len;
len88drivers/net/slip.cip_dump(unsigned char *ptr, int len)
len105drivers/net/slip.cprintk("%p %d\n", ptr, len);
len127drivers/net/slip.cvoid clh_dump(unsigned char *cp, int len)
len129drivers/net/slip.cif (len > 60)
len130drivers/net/slip.clen = 60;
len131drivers/net/slip.cprintk("%d:", len);
len132drivers/net/slip.cwhile (len > 0) {
len134drivers/net/slip.clen--;
len448drivers/net/slip.csl_encaps(struct slip *sl, unsigned char *icp, int len)
len453drivers/net/slip.cDPRINTF((DBG_SLIP, "SLIP: sl_encaps(0x%X, %d) called\n", icp, len));
len456drivers/net/slip.cip_dump(icp, len);
len461drivers/net/slip.cif(len>sl->mtu)    /* Sigh, shouldn't occur BUT ... */
len463drivers/net/slip.clen=sl->mtu;
len470drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
len473drivers/net/slip.ccount=slip_esc6(p, (unsigned char *)sl->xbuff,len);
len475drivers/net/slip.ccount=slip_esc(p, (unsigned char *)sl->xbuff,len);
len547drivers/net/slip.csize=skb->len;
len586drivers/net/slip.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
len591drivers/net/slip.creturn ax25_encapsulate(buff,dev,type,daddr,saddr,len,skb);
len864drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
len881drivers/net/slip.cwhile(len-- > 0) {
len947drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
len966drivers/net/slip.cfor (i = 0; i < len; ++i) {
len77drivers/net/slip.hextern int  slip_esc(unsigned char *s, unsigned char *d, int len);
len78drivers/net/slip.hextern int  slip_esc6(unsigned char *s, unsigned char *d, int len);
len1085drivers/scsi/NCR5380.cint len;
len1273drivers/scsi/NCR5380.clen = 3;
len1277drivers/scsi/NCR5380.clen = 1;
len1284drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len1741drivers/scsi/NCR5380.cint len, transfersize;
len1805drivers/scsi/NCR5380.clen = transfersize;
len1807drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
len1819drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
len1833drivers/scsi/NCR5380.clen = 1;
len1835drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2014drivers/scsi/NCR5380.clen = 1;
len2017drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2029drivers/scsi/NCR5380.clen = COMMAND_SIZE(cmd->cmnd[0]);
len2036drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, 
len2051drivers/scsi/NCR5380.clen = 1;
len2053drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2098drivers/scsi/NCR5380.cint len;
len2134drivers/scsi/NCR5380.clen = 3;
len2137drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2153drivers/scsi/NCR5380.cif (!len) 
len2206drivers/scsi/NCR5380.clen = 1;
len2210drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2295drivers/scsi/NCR5380.cint len;
len2387drivers/scsi/NCR5380.clen = 1;
len2390drivers/scsi/NCR5380.cNCR5380_transfer_pio (instance, &phase, &len, &msgptr);
len102drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
len104drivers/scsi/aha1542.cif(len == 1) {
len115drivers/scsi/aha1542.cwhile (len--)
len125drivers/scsi/aha1542.cprintk("aha1542_out failed(%d): ", len+1); aha1542_stat();
len131drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
len134drivers/scsi/aha1542.cwhile (len--)
len143drivers/scsi/aha1542.cprintk("aha1542_in failed(%d): ", len+1); aha1542_stat();
len209drivers/scsi/aha1542.cint len;
len239drivers/scsi/aha1542.clen = 4;
len242drivers/scsi/aha1542.cwhile (len--)
len474drivers/scsi/constants.cint len = 0, i;
len476drivers/scsi/constants.clen = 3 + msg[1];
len497drivers/scsi/constants.clen = 1;
len508drivers/scsi/constants.clen = 1;
len521drivers/scsi/constants.clen = 2;
len528drivers/scsi/constants.creturn len;
len418drivers/scsi/pas16.cint len) {
len422drivers/scsi/pas16.cregister i = len;
len452drivers/scsi/pas16.cint len) {
len455drivers/scsi/pas16.cregister i = len;
len1507drivers/scsi/scsi.cvoid *scsi_malloc(unsigned int len)
len1511drivers/scsi/scsi.cif((len & 0x1ff) || len > 8192)
len1515drivers/scsi/scsi.cnbits = len >> 9;
len1525drivers/scsi/scsi.cprintk("SMalloc: %d %x ",len, dma_malloc_buffer + (i << 13) + (j << 9));
len1534drivers/scsi/scsi.cint scsi_free(void *obj, unsigned int len)
len1540drivers/scsi/scsi.cprintk("Sfree %x %d\n",obj, len);
len1551drivers/scsi/scsi.cnbits = len >> 9;
len31drivers/scsi/scsi_ioctl.cunsigned int len,slen;
len35drivers/scsi/scsi_ioctl.clen = get_fs_long ((unsigned long *) buffer);
len38drivers/scsi/scsi_ioctl.cif (len > slen)
len39drivers/scsi/scsi_ioctl.clen = slen + 1;
len40drivers/scsi/scsi_ioctl.cverify_area(VERIFY_WRITE, buffer, len);
len41drivers/scsi/scsi_ioctl.cmemcpy_tofs (buffer, string, len);
len583drivers/scsi/seagate.cint len = 0;
len710drivers/scsi/seagate.clen=current_bufflen;    /* WDE add */
len908drivers/scsi/seagate.clen = buffer->length;
len915drivers/scsi/seagate.clen = SCint->request_bufflen;
len920drivers/scsi/seagate.cprintk("scsi%d : len = %d\n", hostno, len);
len1033drivers/scsi/seagate.cif (!len) {
len1043drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1051drivers/scsi/seagate.cSCint->transfersize, len, data);
len1073drivers/scsi/seagate.clen -= transfersize;
len1078drivers/scsi/seagate.chostno, len, data);
len1134drivers/scsi/seagate.c"=S" (data), "=c" (len) :
len1136drivers/scsi/seagate.c"0" (data), "1" (len) :
len1141drivers/scsi/seagate.cif (!len && nobuffs) {
len1144drivers/scsi/seagate.clen = buffer->length;
len1148drivers/scsi/seagate.chostno, len, data);
len1157drivers/scsi/seagate.ctransfered += len;
len1159drivers/scsi/seagate.cfor (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN |
len1160drivers/scsi/seagate.cSTAT_REQ); --len) {
len1165drivers/scsi/seagate.ctransfered -= len;
len1170drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1178drivers/scsi/seagate.cSCint->transfersize, len, data);
len1200drivers/scsi/seagate.clen -= transfersize;
len1210drivers/scsi/seagate.chostno, len, data);
len1218drivers/scsi/seagate.cprintk("scsi%d: transfered += %d\n", hostno, len);
len1219drivers/scsi/seagate.ctransfered += len;  /* Assume we'll transfer it all, then
len1274drivers/scsi/seagate.c"=D" (data), "=c" (len) :
len1276drivers/scsi/seagate.c"0" (data), "1" (len) :
len1281drivers/scsi/seagate.cprintk("scsi%d: transfered -= %d\n", hostno, len);
len1282drivers/scsi/seagate.ctransfered -= len;    /* Since we assumed all of Len got 
len1287drivers/scsi/seagate.cif (!len && nobuffs) {
len1290drivers/scsi/seagate.clen = buffer->length;
len1294drivers/scsi/seagate.chostno, len, data);
len1361drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1393drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1404drivers/scsi/seagate.clen=current_bufflen;
len317drivers/scsi/t128.cint len) {
len320drivers/scsi/t128.cregister i = len;
len355drivers/scsi/t128.cint len) {
len358drivers/scsi/t128.cregister i = len;
len206drivers/scsi/wd7000.cunsigned len;           /* length of string */
len322drivers/scsi/wd7000.cunchar len[3];
len378drivers/scsi/wd7000.cunchar len[3];                /* command buffer length */
len420drivers/scsi/wd7000.cunchar len[3];                /* buffer length */
len436drivers/scsi/wd7000.cunchar len[3];                /* parms buffer length */
len568drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
len571drivers/scsi/wd7000.cwhile (len--)  {
len581drivers/scsi/wd7000.cprintk("wd7000 command_out: WAIT failed(%d)\n", len+1);
len935drivers/scsi/wd7000.cany2scsi(sgb[i].len, sg[i].length);
len965drivers/scsi/wd7000.cany2scsi(icb.len, sizeof(buf));
len1117drivers/scsi/wd7000.cif (!memcmp(cfg->bios+sig->ofs, sig->sig, sig->len))  {
len176drivers/sound/configure.cint             len;
len178drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len188drivers/sound/configure.cif (len < 2)      /* There is an additional LF at the end */
len191drivers/sound/configure.cansw[len - 1] = 0;
len203drivers/sound/configure.cint             len, num;
len207drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len217drivers/sound/configure.cif (len < 2)      /* There is an additional LF at the end */
len220drivers/sound/configure.cansw[len - 1] = 0;
len77drivers/sound/dev_table.hsnd_rw_buf *userbuf, int useroffs, int len);
len319drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len)
len383drivers/sound/dmabuf.c*len = dev_buffsize[dev] - dev_counts[dev][dev_qhead[dev]];
len835drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len)
len538drivers/sound/gus_wave.cif (position < samples[sample_no].len)
len1521drivers/sound/gus_wave.c((sample_ptrs[sample] + samples[sample].len) >> 18))
len1550drivers/sound/gus_wave.cgus_write_addr (0x0a, sample_ptrs[sample] + samples[sample].len -
len1601drivers/sound/gus_wave.cgus_write_addr (0x04, sample_ptrs[sample] + samples[sample].len - 1, is16bits);  /*
len1775drivers/sound/gus_wave.cif (count < patch.len)
len1778drivers/sound/gus_wave.ccount, (int) patch.len);
len1779drivers/sound/gus_wave.cpatch.len = count;
len1782drivers/sound/gus_wave.cif (patch.len <= 0 || patch.len > gus_mem_size)
len1784drivers/sound/gus_wave.cprintk ("GUS: Invalid sample length %d\n", (int) patch.len);
len1790drivers/sound/gus_wave.cif (patch.loop_start < 0 || patch.loop_start >= patch.len)
len1796drivers/sound/gus_wave.cif (patch.loop_end < patch.loop_start || patch.loop_end > patch.len)
len1814drivers/sound/gus_wave.cif (patch.len >= GUS_BANK_SIZE)
len1816drivers/sound/gus_wave.cprintk ("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
len1821drivers/sound/gus_wave.c((free_mem_ptr + patch.len) / GUS_BANK_SIZE))
len1828drivers/sound/gus_wave.cif ((tmp_mem + patch.len) > gus_mem_size)
len1837drivers/sound/gus_wave.cif ((free_mem_ptr + patch.len) > gus_mem_size)
len1862drivers/sound/gus_wave.cleft = patch.len;
len1998drivers/sound/gus_wave.cfree_mem_ptr += patch.len;
len2710drivers/sound/gus_wave.csnd_rw_buf * userbuf, int useroffs, int len)
len2714drivers/sound/gus_wave.cCOPY_FROM_USER (&localbuf[localoffs], userbuf, useroffs, len);
len2723drivers/sound/gus_wave.clen /= 2;
len2728drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2743drivers/sound/gus_wave.clen /= 4;
len2749drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2884drivers/sound/gus_wave.cif (pat->len > samples[ptr].len)  /*
len2913drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2918drivers/sound/gus_wave.cn = samples[sample].len - offs;  /*
len2958drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2963drivers/sound/gus_wave.cn = samples[sample].len - offs;  /*
len9drivers/sound/sound_calls.hint DMAbuf_getrdbuffer(int dev, char **buf, int *len);
len125fs/binfmt_elf.cunsigned int len;
len195fs/binfmt_elf.clen = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
len198fs/binfmt_elf.cif (last_bss > len)
len199fs/binfmt_elf.cdo_mmap(NULL, len, last_bss-len,
len553fs/binfmt_elf.cunsigned int len;
len560fs/binfmt_elf.clen = 0;
len628fs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len630fs/binfmt_elf.cif (bss > len)
len631fs/binfmt_elf.cdo_mmap(NULL, len, bss-len,
len34fs/devices.cint len;
len36fs/devices.clen = sprintf(page, "Character devices:\n");
len39fs/devices.clen += sprintf(page+len, "%2d %s\n", i, chrdevs[i].name);
len42fs/devices.clen += sprintf(page+len, "\nBlock devices:\n");
len45fs/devices.clen += sprintf(page+len, "%2d %s\n", i, blkdevs[i].name);
len48fs/devices.creturn len;
len349fs/exec.cint len, offset = 0;
len365fs/exec.clen=0;    /* remember zero-padding */
len367fs/exec.clen++;
len369fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
len373fs/exec.cwhile (len) {
len374fs/exec.c--p; --tmp; --len;
len876fs/exec.cunsigned int len;
len915fs/exec.clen = PAGE_ALIGN(ex.a_text + ex.a_data);
len917fs/exec.cif (bss > len)
len918fs/exec.cdo_mmap(NULL, start_addr + len, bss-len,
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))) {
len310fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
len328fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len344fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len352fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len387fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len403fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
len409fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len454fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len531fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
len539fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len584fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
len593fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len627fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
len657fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len666fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len682fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len697fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len704fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len43fs/ext2/balloc.c#define in_range(b, first, len)    ((b) >= (first) && (b) <= (first) + (len) - 1)
len30fs/ext2/dcache.cint len;
len86fs/ext2/dcache.cconst char * name, int len)
len91fs/ext2/dcache.cp->dir != dir || p->len != len ||
len92fs/ext2/dcache.cstrncmp (name, p->name, p->len) != 0);
len204fs/ext2/dcache.cconst char * name, int len)
len212fs/ext2/dcache.cif (len > DCACHE_NAME_LEN)
len214fs/ext2/dcache.cmemcpy (our_name, (char *) name, len);
len215fs/ext2/dcache.cour_name[len] = '\0';
len217fs/ext2/dcache.cprintk ("dcache_lookup (%04x, %lu, %s, %d)\n", dev, dir, our_name, len);
len220fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, our_name, len))) {
len254fs/ext2/dcache.cint len, unsigned long ino)
len263fs/ext2/dcache.cdev, dir, name, len, ino);
len265fs/ext2/dcache.cif (len > DCACHE_NAME_LEN)
len268fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
len297fs/ext2/dcache.cstrncpy (p->name, name, len);
len298fs/ext2/dcache.cp->len = len;
len299fs/ext2/dcache.cp->name[len] = '\0';
len314fs/ext2/dcache.cconst char * name, int len)
len322fs/ext2/dcache.cprintk ("dcache_remove (%04x, %lu, %s, %d)\n", dev, dir, name, len);
len324fs/ext2/dcache.cif (len > DCACHE_NAME_LEN)
len327fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
len43fs/ext2/namei.cstatic int ext2_match (int len, const char * const name,
len48fs/ext2/namei.cif (!de || !de->inode || len > EXT2_NAME_LEN)
len53fs/ext2/namei.cif (!len && de->name_len == 1 && (de->name[0] == '.') &&
len56fs/ext2/namei.cif (len != de->name_len)
len62fs/ext2/namei.c:"S" ((long) name), "D" ((long) de->name), "c" (len)
len170fs/ext2/namei.cint ext2_lookup (struct inode * dir, const char * name, int len,
len185fs/ext2/namei.cif (!(ino = ext2_dcache_lookup (dir->i_dev, dir->i_ino, name, len))) {
len187fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
len365fs/ext2/namei.cint ext2_create (struct inode * dir,const char * name, int len, int mode,
len384fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len408fs/ext2/namei.cint ext2_mknod (struct inode * dir, const char * name, int len, int mode,
len418fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len450fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len474fs/ext2/namei.cint ext2_mkdir (struct inode * dir, const char * name, int len, int mode)
len483fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len526fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len606fs/ext2/namei.cint ext2_rmdir (struct inode * dir, const char * name, int len)
len617fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len691fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
len703fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len752fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
len801fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len810fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len835fs/ext2/namei.cconst char * name, int len)
len851fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len858fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len357fs/hpfs/hpfs.hunsigned char len, name[15];    /* true length, truncated name */
len235fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len);
len243fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len253fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
len255fs/hpfs/hpfs_fs.cunsigned len);
len529fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len)
len532fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
len944fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
len951fs/hpfs/hpfs_fs.cwhile (len--) {
len954fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
len976fs/hpfs/hpfs_fs.cunsigned len)
len980fs/hpfs/hpfs_fs.cwhile (len--) {
len982fs/hpfs/hpfs_fs.cif (c == '\r' && (len == 0 || *in == '\n'));
len1101fs/hpfs/hpfs_fs.cstatic int hpfs_lookup(struct inode *dir, const char *name, int len,
len1122fs/hpfs/hpfs_fs.cif (name[0] == '.' && len == 1)
len1124fs/hpfs/hpfs_fs.celse if (name[0] == '.' && name[1] == '.' && len == 2)
len1129fs/hpfs/hpfs_fs.cde = map_dirent(dir, dir->i_hpfs_dno, name, len, &qbh);
len1228fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len1257fs/hpfs/hpfs_fs.cl = len < de->namelen ? len : de->namelen;
len1264fs/hpfs/hpfs_fs.ct = len - de->namelen;
len1281fs/hpfs/hpfs_fs.cname, len, qbh);
len27fs/isofs/namei.cstatic int isofs_match(int len,const char * name, char * compare, int dlen)
len33fs/isofs/namei.cif (!len && (compare[0]==0) && (dlen==1))
len36fs/isofs/namei.cif (compare[0]==0 && dlen==1 && len == 1)
len38fs/isofs/namei.cif (compare[0]==1 && dlen==1 && len == 2) {
len43fs/isofs/namei.cif (len <= 2) printk("Match: %d %d %s %d %d \n",len,dlen,compare,de->name[0], dlen);
len46fs/isofs/namei.cif (dlen != len)
len52fs/isofs/namei.c:"0" (0),"S" ((long) name),"D" ((long) compare),"c" (len)
len210fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
len217fs/isofs/namei.cprintk("lookup: %x %d\n",dir->i_ino, len);
len231fs/isofs/namei.clen == cache.dlen && 
len232fs/isofs/namei.cisofs_match(len, name, cache.filename, cache.dlen))
len244fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
len79fs/isofs/rock.clen = cont_size; \
len94fs/isofs/rock.cint len;
len109fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len115fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len117fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len119fs/isofs/rock.cchr += rr->len; 
len120fs/isofs/rock.clen -= rr->len;
len167fs/isofs/rock.cint len;
len175fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len181fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len183fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len185fs/isofs/rock.cchr += rr->len; 
len186fs/isofs/rock.clen -= rr->len;
len215fs/isofs/rock.cif((strlen(retname) + rr->len - 5) >= 254) {
len219fs/isofs/rock.cstrncat(retname, rr->u.NM.name, rr->len - 5);
len220fs/isofs/rock.cretnamlen += rr->len - 5;
len249fs/isofs/rock.cint len;
len255fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len263fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len265fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len267fs/isofs/rock.cchr += rr->len; 
len268fs/isofs/rock.clen -= rr->len;
len317fs/isofs/rock.cslen = rr->len - 5;
len324fs/isofs/rock.cinode->i_size += slp->len;
len339fs/isofs/rock.cslen -= slp->len + 2;
len340fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len397fs/isofs/rock.cint len;
len433fs/isofs/rock.cSETUP_ROCK_RIDGE(raw_inode, chr, len);
len436fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len439fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len441fs/isofs/rock.cchr += rr->len; 
len442fs/isofs/rock.clen -= rr->len;
len454fs/isofs/rock.cslen = rr->len - 5;
len464fs/isofs/rock.cstrncat(rpnt,slp->text, slp->len);
len479fs/isofs/rock.cslen -= slp->len + 2;
len480fs/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))) {
len213fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
len232fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
len248fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len257fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len289fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len305fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
len318fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len356fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len431fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
len439fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len486fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
len496fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len539fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
len569fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len578fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
len594fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len610fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len617fs/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) {
len196fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
len205fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len244fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
len252fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len294fs/msdos/namei.cif (msdos_rmdir(dir,name,len) < 0)
len326fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
len336fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len338fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
len363fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
len372fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
len94fs/namei.cint lookup(struct inode * dir,const char * name, int len,
len105fs/namei.cif (len==2 && name[0] == '.' && name[1] == '.') {
len126fs/namei.cif (!len) {
len130fs/namei.creturn dir->i_op->lookup(dir,name,len,result);
len161fs/namei.cint len,error;
len177fs/namei.cfor(len=0;(c = *(pathname++))&&(c != '/');len++)
len182fs/namei.cerror = lookup(base,thisname,len,&inode);
len196fs/namei.c*namelen = len;
len24fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
len26fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len28fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
len29fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
len30fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
len31fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
len34fs/nfs/dir.cconst char *name, int len);
len35fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
len287fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
len292fs/nfs/dir.cchar name[len > NFS_MAXNAMLEN? 1 : len+1];
len301fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len305fs/nfs/dir.cmemcpy(name,__name,len);
len306fs/nfs/dir.cname[len] = '\0';
len307fs/nfs/dir.cif (len == 1 && name[0] == '.') { /* cheat for "." */
len328fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len342fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len363fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
len376fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len395fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
len407fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len422fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
len431fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len442fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
len451fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len462fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
len473fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len491fs/nfs/dir.cconst char *name, int len)
len507fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len25fs/nfs/file.cunsigned long addr, size_t len, int prot, unsigned long off);
len52fs/nfs/mmap.cunsigned long addr, size_t len, int prot, unsigned long off)
len71fs/nfs/mmap.cunmap_page_range(addr, len);
len74fs/nfs/mmap.cmpnt->vm_end = addr + len;
len83fs/nfs/proc.cint len, quadlen;
len85fs/nfs/proc.clen = strlen(string);
len86fs/nfs/proc.cquadlen = (len + 3) >> 2;
len87fs/nfs/proc.c*p++ = htonl(len);
len88fs/nfs/proc.cmemcpy((char *) p, string, len);
len89fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
len96fs/nfs/proc.cunsigned int len;
len98fs/nfs/proc.clen = ntohl(*p++);
len99fs/nfs/proc.cif (len > maxlen)
len101fs/nfs/proc.cmemcpy(string, (char *) p, len);
len102fs/nfs/proc.cstring[len] = '\0';
len103fs/nfs/proc.cp += (len + 3) >> 2;
len107fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
len111fs/nfs/proc.cquadlen = (len + 3) >> 2;
len112fs/nfs/proc.c*p++ = htonl(len);
len113fs/nfs/proc.cmemcpy((char *) p, data, len);
len114fs/nfs/proc.cmemset(((char *) p) + len, '\0', (quadlen << 2) - len);
len121fs/nfs/proc.cunsigned int len;
len123fs/nfs/proc.clen = *lenp = ntohl(*p++);
len124fs/nfs/proc.cif (len > maxlen)
len126fs/nfs/proc.cmemcpy(data, (char *) p, len);
len127fs/nfs/proc.cp += (len + 3) >> 2;
len343fs/nfs/proc.cint len = 0; /* = 0 is for gcc */
len362fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
len367fs/nfs/proc.cPRINTK("NFS reply read %d\n", len);
len377fs/nfs/proc.creturn (status == NFS_OK) ? len : -nfs_stat_to_errno(status);
len42fs/nfs/sock.cint len;
len56fs/nfs/sock.clen = ((char *) end) - ((char *) start);
len84fs/nfs/sock.cresult = sock->ops->send(sock, (void *) start, len, 0, 0);
len99fs/proc/array.cint i, len;
len104fs/proc/array.clen = sprintf(buffer,
len124fs/proc/array.clen += sprintf(buffer + len, " %u", kstat.interrupts[i]);
len125fs/proc/array.clen += sprintf(buffer + len,
len130fs/proc/array.creturn len;
len71fs/proc/base.cint proc_match(int len,const char * name,struct proc_dir_entry * de)
len78fs/proc/base.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len80fs/proc/base.cif (de->namelen != len)
len86fs/proc/base.c:"0" (0),"S" ((long) name),"D" ((long) de->name),"c" (len)
len91fs/proc/base.cstatic int proc_lookupbase(struct inode * dir,const char * name, int len,
len107fs/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) {
len114fs/proc/net.cstatic int proc_lookupnet(struct inode * dir,const char * name, int len,
len128fs/proc/net.cwhile (i-- > 0 && !proc_match(len,name,net_dir+i))
len76fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
len90fs/proc/root.cwhile (i-- > 0 && !proc_match(len,name,root_dir+i))
len102fs/proc/root.cwhile (len-- > 0) {
len100fs/super.cint err, len;
len109fs/super.clen = strlen(tmp->name) + 1;
len110fs/super.cerr = verify_area(VERIFY_WRITE, buf, len);
len113fs/super.cmemcpy_tofs(buf, tmp->name, len);
len158fs/super.cint len = 0;
len162fs/super.cwhile (tmp && len < PAGE_SIZE - 80) {
len163fs/super.clen += sprintf(buf+len, "%s\t%s\n",
len168fs/super.creturn len;
len25fs/sysv/namei.cstatic inline int namecompare(int len, int maxlen,
len28fs/sysv/namei.cif (len >= maxlen || !buffer[len]) {
len32fs/sysv/namei.c:"S" ((long) name),"D" ((long) buffer),"c" (len)
len47fs/sysv/namei.cstatic int sysv_match(int len, const char * name, struct sysv_dir_entry * de)
len49fs/sysv/namei.cif (!de->inode || len > SYSV_NAMELEN)
len52fs/sysv/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len54fs/sysv/namei.creturn namecompare(len,SYSV_NAMELEN,name,de->name);
len109fs/sysv/namei.cint sysv_lookup(struct inode * dir,const char * name, int len,
len123fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
len210fs/sysv/namei.cint sysv_create(struct inode * dir,const char * name, int len, int mode,
len232fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
len248fs/sysv/namei.cint sysv_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len257fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len292fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len308fs/sysv/namei.cint sysv_mkdir(struct inode * dir, const char * name, int len, int mode)
len320fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len358fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len435fs/sysv/namei.cint sysv_rmdir(struct inode * dir, const char * name, int len)
len443fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len490fs/sysv/namei.cint sysv_unlink(struct inode * dir, const char * name, int len)
len500fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len543fs/sysv/namei.cint sysv_symlink(struct inode * dir, const char * name, int len, const char * symname)
len577fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len586fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
len602fs/sysv/namei.cint sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len618fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len625fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
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))) {
len244fs/xiafs/namei.cint xiafs_create(struct inode * dir, const char * name, int len, int mode,
len262fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len278fs/xiafs/namei.cint xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
len286fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len319fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len335fs/xiafs/namei.cint xiafs_mkdir(struct inode * dir, const char * name, int len, int mode)
len341fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len384fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len484fs/xiafs/namei.cint xiafs_rmdir(struct inode * dir, const char * name, int len)
len492fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len535fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
len545fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len583fs/xiafs/namei.cint len, const char * symname)
len591fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
len618fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len635fs/xiafs/namei.cconst char * name, int len)
len650fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
len657fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len33include/linux/etherdevice.hvoid *saddr, unsigned len,
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,
len78include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
len80include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
len82include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
len83include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
len84include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
len85include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
len87include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len88include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len176include/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);
len107include/linux/net.hint  (*listen)  (struct socket *sock, int len);
len108include/linux/net.hint  (*send)    (struct socket *sock, void *buff, int len, int nonblock,
len110include/linux/net.hint  (*recv)    (struct socket *sock, void *buff, int len, int nonblock,
len112include/linux/net.hint  (*sendto)  (struct socket *sock, void *buff, int len, int nonblock,
len114include/linux/net.hint  (*recvfrom)  (struct socket *sock, void *buff, int len, int nonblock,
len122include/linux/netdevice.hunsigned len,
len175include/linux/netdevice.hextern int    dev_rint(unsigned char *buff, long len, int flags,
len122include/linux/nfs_fs.hunsigned long addr, size_t len, int prot, unsigned long off);
len8include/linux/pipe_fs_i.hunsigned int len;
len19include/linux/pipe_fs_i.h#define PIPE_LEN(inode)    ((inode).u.pipe_i.len)
len60include/linux/skbuff.hunsigned long     len;
len135include/linux/soundcard.hlong len;  /* Size of the wave data in bytes */
len641include/linux/soundcard.h#define SEQ_DEFINEBUF(len)    unsigned char _seqbuf[len]; int _seqbuflen = len; int _seqbufptr = 0
len644include/linux/soundcard.h#define _SEQ_NEEDBUF(len)    if ((_seqbufptr+(len)) > _seqbuflen) seqbuf_dump()
len645include/linux/soundcard.h#define _SEQ_ADVBUF(len)    _seqbufptr += len
len757include/linux/soundcard.h#define SEQ_WRPATCH(patchx, len)  {if (_seqbufptr) seqbuf_dump();\
len758include/linux/soundcard.hif (write(seqfd, (char*)(patchx), len)==-1) \
len391include/linux/sysv_fs.hextern int sysv_lookup(struct inode * dir,const char * name, int len,
len393include/linux/sysv_fs.hextern int sysv_create(struct inode * dir,const char * name, int len, int mode,
len395include/linux/sysv_fs.hextern int sysv_mkdir(struct inode * dir, const char * name, int len, int mode);
len396include/linux/sysv_fs.hextern int sysv_rmdir(struct inode * dir, const char * name, int len);
len397include/linux/sysv_fs.hextern int sysv_unlink(struct inode * dir, const char * name, int len);
len398include/linux/sysv_fs.hextern int sysv_symlink(struct inode * inode, const char * name, int len,
len400include/linux/sysv_fs.hextern int sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len401include/linux/sysv_fs.hextern int sysv_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
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, 
len296init/main.cint len = strlen(devnames[n]);
len297init/main.cif (!strncmp(line,devnames[n],len)) {
len298init/main.cROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,16);
len336init/main.cint len = 0;
len344init/main.cif (COMMAND_LINE_SIZE <= ++len)
len25kernel/module.cint len;
len40kernel/module.clen = strlen(name) + 1;
len41kernel/module.cif ((savename = (char*) kmalloc(len, GFP_KERNEL)) == NULL)
len43kernel/module.cmemcpy(savename, name, len);
len55kernel/printk.casmlinkage int sys_syslog(int type, char * buf, int len)
len70kernel/printk.cif (!buf || len < 0)
len72kernel/printk.cif (!len)
len74kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len86kernel/printk.cwhile (log_size && i < len) {
len103kernel/printk.cif (!buf || len < 0)
len105kernel/printk.cif (!len)
len107kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len110kernel/printk.ccount = len;
len133kernel/printk.cif (len < 0 || len > 8)
len135kernel/printk.cconsole_loglevel = len;
len609kernel/sys.casmlinkage int sys_sethostname(char *name, int len)
len615kernel/sys.cif (len > __NEW_UTS_LEN)
len617kernel/sys.cfor (i=0; i < len; i++) {
len629kernel/sys.casmlinkage int sys_setdomainname(char *name, int len)
len635kernel/sys.cif (len > __NEW_UTS_LEN)
len637kernel/sys.cfor (i=0; i < len; i++) {
len121kernel/vsprintf.cint len;
len200kernel/vsprintf.clen = strlen(s);
len202kernel/vsprintf.cprecision = len;
len203kernel/vsprintf.celse if (len > precision)
len204kernel/vsprintf.clen = precision;
len207kernel/vsprintf.cwhile (len < field_width--)
len209kernel/vsprintf.cfor (i = 0; i < len; ++i)
len211kernel/vsprintf.cwhile (len < field_width--)
len42mm/mmap.cint do_mmap(struct file * file, unsigned long addr, unsigned long len,
len47mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len50mm/mmap.cif (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
len81mm/mmap.cif (len > TASK_SIZE || addr > TASK_SIZE - len)
len88mm/mmap.cwhile (addr+len < SHM_RANGE_END) {
len92mm/mmap.cif (addr + len <= vmm->vm_start)
len100mm/mmap.cif (addr+len >= SHM_RANGE_END)
len122mm/mmap.cdo_munmap(addr, len);  /* Clear old maps */
len125mm/mmap.cerror = file->f_op->mmap(file->f_inode, file, addr, len, mask, off);
len127mm/mmap.cerror = anon_map(NULL, NULL, addr, len, mask, off);
len179mm/mmap.cunsigned long addr, size_t len)
len182mm/mmap.cunsigned long end = addr + len;
len230mm/mmap.casmlinkage int sys_mprotect(unsigned long addr, size_t len, unsigned long prot)
len235mm/mmap.casmlinkage int sys_munmap(unsigned long addr, size_t len)
len237mm/mmap.creturn do_munmap(addr, len);
len246mm/mmap.cint do_munmap(unsigned long addr, size_t len)
len250mm/mmap.cif ((addr & ~PAGE_MASK) || addr > TASK_SIZE || len > TASK_SIZE-addr)
len253mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len265mm/mmap.cunsigned long end = addr+len;
len295mm/mmap.cend = addr+len;
len306mm/mmap.cunmap_page_range(addr, len);
len312mm/mmap.cunsigned long addr, size_t len, int prot, unsigned long off)
len338mm/mmap.cunmap_page_range(addr, len);  
len341mm/mmap.cmpnt->vm_end = addr + len;
len446mm/mmap.cunsigned long addr, size_t len, int mask,
len451mm/mmap.cif (zeromap_page_range(addr, len, mask))
len460mm/mmap.cmpnt->vm_end = addr + len;
len276net/inet/arp.cskb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
len285net/inet/arp.cdev->hard_header(skb->data,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
len829net/inet/arp.cint len=0;
len840net/inet/arp.clen+=size;
len858net/inet/arp.csize = sprintf(buffer+len,
len865net/inet/arp.clen+=size;
len866net/inet/arp.cpos=begin+len;
len870net/inet/arp.clen=0;
len880net/inet/arp.clen-=(offset-begin);    /* Start slop */
len881net/inet/arp.cif(len>length)
len882net/inet/arp.clen=length;            /* Ending slop */
len883net/inet/arp.creturn len;
len469net/inet/dev.cint dev_rint(unsigned char *buff, long len, int flags, struct device *dev)
len477net/inet/dev.cif (dev == NULL || buff == NULL || len <= 0) 
len494net/inet/dev.cskb = alloc_skb(len, GFP_ATOMIC);
len509net/inet/dev.cleft = len;
len511net/inet/dev.clen2 = len;
len530net/inet/dev.cskb->len = len;
len643net/inet/dev.cskb->len -= skb->dev->hard_header_len;
len684net/inet/dev.cskb2 = alloc_skb(skb->len, GFP_ATOMIC);
len803net/inet/dev.cint len;
len814net/inet/dev.clen = ifc.ifc_len;
len822net/inet/dev.cerr=verify_area(VERIFY_WRITE,pos,len);
len845net/inet/dev.clen -= sizeof(struct ifreq);
len851net/inet/dev.cif (len < sizeof(struct ifreq)) 
len906net/inet/dev.cint len=0;
len918net/inet/dev.clen+=size;
len923net/inet/dev.csize = sprintf_stats(buffer+len, dev);
len924net/inet/dev.clen+=size;
len925net/inet/dev.cpos=begin+len;
len929net/inet/dev.clen=0;
len937net/inet/dev.clen-=(offset-begin);    /* Start slop */
len938net/inet/dev.cif(len>length)
len939net/inet/dev.clen=length;    /* Ending slop */
len940net/inet/dev.creturn len;
len126net/inet/dev.hunsigned len);
len180net/inet/dev.hextern int    dev_rint(unsigned char *buff, long len, int flags,
len81net/inet/eth.cvoid *daddr, void *saddr, unsigned len,
len94net/inet/eth.ceth->h_proto = htons(len);
len29net/inet/eth.hunsigned long saddr, unsigned len);
len112net/inet/icmp.cint len;
len180net/inet/icmp.clen = dev->hard_header_len + sizeof(struct iphdr) + sizeof(struct icmphdr) +
len183net/inet/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
len196net/inet/icmp.c&ndev, IPPROTO_ICMP, NULL, len, skb_in->ip_hdr->tos,255);
len210net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
len382net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len393net/inet/icmp.csize = dev->hard_header_len + 64 + len;
len406net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len420net/inet/icmp.cskb2->len = offset + len;
len426net/inet/icmp.cmemcpy((char *) icmphr, (char *) icmph, len);
len430net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len449net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len459net/inet/icmp.csize = dev->hard_header_len + 64 + len;
len474net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev, IPPROTO_ICMP, opt, len, 
len488net/inet/icmp.cskb2->len = offset + len;
len495net/inet/icmp.cmemcpy((char *) icmphr, (char *) icmph, len);
len507net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *) icmphr, len);
len526net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len539net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len550net/inet/icmp.csize = dev->hard_header_len + 64 + len;
len565net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len579net/inet/icmp.cskb2->len = offset + len;
len593net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len608net/inet/icmp.cunsigned long daddr, unsigned short len,
len641net/inet/icmp.cif (ip_compute_csum((unsigned char *) icmph, len)) 
len675net/inet/icmp.cicmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
len683net/inet/icmp.cicmp_timestamp(icmph, skb1, dev, saddr, daddr, len, opt);
len691net/inet/icmp.cicmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
len699net/inet/icmp.cicmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
len32net/inet/icmp.hunsigned short len, unsigned long saddr,
len112net/inet/ip.cint len;
len133net/inet/ip.clen = ntohs(ip->tot_len) - (4 * ip->ihl);
len135net/inet/ip.cwhile (len > 0) 
len140net/inet/ip.cif (len > 0) 
len153net/inet/ip.clen--;
len226net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
len238net/inet/ip.cmac = dev->hard_header(skb->data, dev, ETH_P_IP, NULL, NULL, len, skb);
len257net/inet/ip.cstruct device **dev, int type, struct options *opt, int len, int tos, int ttl)
len277net/inet/ip.cskb, saddr, daddr, *dev, type, opt, len));
len338net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
len340net/inet/ip.clen -= tmp;
len388net/inet/ip.cint i, len = sizeof(struct iphdr);
len406net/inet/ip.cwhile (!done && len < iph->ihl*4) switch(*buff) {
len412net/inet/ip.clen++;
len426net/inet/ip.clen += 11;
len431net/inet/ip.clen += *buff;
len448net/inet/ip.clen += *buff;
len465net/inet/ip.clen += *buff;
len480net/inet/ip.clen += 4;
len487net/inet/ip.clen += *buff;
len489net/inet/ip.copt->tstamp.len = *buff / 4 - 1;
len496net/inet/ip.cfor (i = 0; i < opt->tstamp.len; i++) {
len564net/inet/ip.cunsigned short ip_compute_csum(unsigned char * buff, int len)
len569net/inet/ip.cif (len > 3) 
len582net/inet/ip.c: "0" (sum), "c" (len >> 2) ,"1" (buff)
len585net/inet/ip.cif (len & 2) 
len594net/inet/ip.cif (len & 1) 
len656net/inet/ip.cfp->len = end - offset;
len832net/inet/ip.cqp->len = 0;
len866net/inet/ip.cif (qp->len == 0) 
len900net/inet/ip.cint count, len;
len906net/inet/ip.clen = qp->maclen + qp->ihlen + qp->len;
len908net/inet/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL) 
len917net/inet/ip.cskb->len = (len - qp->maclen);
len935net/inet/ip.cif(count+fp->len>skb->len)
len943net/inet/ip.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
len944net/inet/ip.ccount += fp->len;
len1040net/inet/ip.cqp->len = end;
len1081net/inet/ip.cnext->len -= i;        /* so reduce size of  */
len1089net/inet/ip.cif (next->len <= 0) 
len1092net/inet/ip.cnext, next->len));
len1169net/inet/ip.cint left, mtu, hlen, len;
len1247net/inet/ip.clen = left;
len1249net/inet/ip.cif (len > mtu)
len1250net/inet/ip.clen = mtu;
len1253net/inet/ip.cif (len < left)
len1255net/inet/ip.clen/=8;
len1256net/inet/ip.clen*=8;
len1259net/inet/ip.clen, len + hlen));
len1265net/inet/ip.cif ((skb2 = alloc_skb(len + hlen,GFP_ATOMIC)) == NULL) 
len1278net/inet/ip.cskb2->len = len + hlen;
len1298net/inet/ip.cmemcpy(skb2->h.raw + hlen, ptr, len);
len1299net/inet/ip.cleft -= len;
len1314net/inet/ip.cptr += len;
len1315net/inet/ip.coffset += len;
len1465net/inet/ip.cin_ntoa(raddr), dev2->name, skb->len));
len1476net/inet/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len, GFP_ATOMIC);
len1488net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
len1494net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
len1497net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
len1507net/inet/ip.cif(skb2->len > dev2->mtu)
len1568net/inet/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0) 
len1583net/inet/ip.cskb->len=ntohs(iph->tot_len);
len1803net/inet/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
len1811net/inet/ip.cif(skb->len > dev->mtu)
len44net/inet/ip.hint    len;    /* length of this fragment    */
len55net/inet/ip.hint    len;    /* total length of original datagram  */
len76net/inet/ip.hstruct options *opt, int len,
len78net/inet/ip.hextern unsigned short  ip_compute_csum(unsigned char * buff, int len);
len138net/inet/ipx.cint len=0;
len144net/inet/ipx.clen += sprintf (buffer,"Type local_address             rem_address              tx_queue rx_queue st uid\n");
len147net/inet/ipx.clen += sprintf (buffer+len,"%02X   ", s->ipx_type);
len148net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%02X ", htonl(s->ipx_source_addr.net),
len152net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%02X ", htonl(s->ipx_dest_addr.net),
len156net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
len157net/inet/ipx.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
len160net/inet/ipx.cpos=begin+len;
len164net/inet/ipx.clen=0;      /* Keep dumping into the buffer start */
len173net/inet/ipx.clen-=(offset-begin);    /* Remove unwanted header data from lenth */
len174net/inet/ipx.cif(len>length)
len175net/inet/ipx.clen=length;    /* Remove unwanted tail data from length */
len177net/inet/ipx.creturn len;
len313net/inet/ipx.cint len=0;
len317net/inet/ipx.clen += sprintf (buffer,"Net      Router                Flags Dev\n");
len320net/inet/ipx.clen += sprintf (buffer+len,"%08lX %08lX:%02X%02X%02X%02X%02X%02X %02X    %s\n", ntohl(rt->net),
len323net/inet/ipx.cpos=begin+len;
len326net/inet/ipx.clen=0;
len333net/inet/ipx.clen-=(offset-begin);
len334net/inet/ipx.cif(len>length)
len335net/inet/ipx.clen=length;
len336net/inet/ipx.creturn len;
len462net/inet/ipx.cstatic void def_callback2(struct sock *sk, int len)
len658net/inet/ipx.cint len;
len667net/inet/ipx.clen = get_fs_long(uaddr_len);
len669net/inet/ipx.cerr = verify_area(VERIFY_WRITE, uaddr, len);
len673net/inet/ipx.cif(len<sizeof(struct sockaddr_ipx))
len690net/inet/ipx.cput_fs_long(len,uaddr_len);
len764net/inet/ipx.cskb2=alloc_skb(skb->len,GFP_ATOMIC);
len772net/inet/ipx.cskb2->len=skb->len;
len773net/inet/ipx.cmemcpy((char *)(skb2+1),(char *)(skb+1),skb->len);
len788net/inet/ipx.c(rt->flags&IPX_RT_BLUEBOOK)?ntohs(ETH_P_IPX):ntohs(skb2->len),
len791net/inet/ipx.cskb2->len,
len820net/inet/ipx.csock->data_ready(sock,skb->len);
len827net/inet/ipx.cstatic int ipx_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len842net/inet/ipx.cif(len<0)
len844net/inet/ipx.cif(len == 0)
len878net/inet/ipx.cerr=verify_area(VERIFY_READ,ubuf,len);
len882net/inet/ipx.csize=sizeof(ipx_packet)+len;  /* For mac headers */
len915net/inet/ipx.cskb->len=size-sizeof(struct sk_buff);
len925net/inet/ipx.clen+sizeof(ipx_packet),
len933net/inet/ipx.cipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
len943net/inet/ipx.cmemcpy_fromfs((char *)(ipx+1),ubuf,len);
len951net/inet/ipx.creturn len;
len1004net/inet/ipx.ccopied=(size<skb->len)?size:skb->len;
len83net/inet/packet.cskb->len += dev->hard_header_len;
len121net/inet/packet.cstatic int packet_sendto(struct sock *sk, unsigned char *from, int len,
len136net/inet/packet.cif (len < 0) 
len160net/inet/packet.cerr=verify_area(VERIFY_READ,from,len);
len180net/inet/packet.cif(len>dev->mtu)
len187net/inet/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
len206net/inet/packet.cmemcpy_fromfs(skb->data, from, len);
len207net/inet/packet.cskb->len = len;
len218net/inet/packet.creturn(len);
len227net/inet/packet.cint len, int noblock,  unsigned flags)
len229net/inet/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
len285net/inet/packet.cint packet_recvfrom(struct sock *sk, unsigned char *to, int len,
len295net/inet/packet.cif (len == 0) 
len297net/inet/packet.cif (len < 0)
len327net/inet/packet.cerr=verify_area(VERIFY_WRITE,to,len);
len353net/inet/packet.ccopied = min(len, skb->len);
len392net/inet/packet.cint len, int noblock, unsigned flags)
len394net/inet/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len65net/inet/proc.cint len=0;
len71net/inet/proc.clen+=sprintf(buffer, "sl  local_address rem_address   st tx_queue rx_queue tr tm->when uid\n");
len92net/inet/proc.clen+=sprintf(buffer+len, "%2d: %08lX:%04X %08lX:%04X %02X %08lX:%08lX %02X:%08lX %08X %d\n",
len106net/inet/proc.cpos=begin+len;
len109net/inet/proc.clen=0;
len121net/inet/proc.clen-=(offset-begin);
len122net/inet/proc.cif(len>length)
len123net/inet/proc.clen=length;
len124net/inet/proc.creturn len;
len33net/inet/protocol.hunsigned short len, unsigned long saddr,
len37net/inet/protocol.hunsigned short len, unsigned long saddr,
len450net/inet/rarp.cint len=0;
len461net/inet/rarp.clen+=size;
len468net/inet/rarp.clen+=size;
len480net/inet/rarp.csize = sprintf(buffer+len,
len491net/inet/rarp.clen+=size;
len492net/inet/rarp.cpos=begin+len;
len496net/inet/rarp.clen=0;
len506net/inet/rarp.clen-=(offset-begin);    /* Start slop */
len507net/inet/rarp.cif(len>length)
len508net/inet/rarp.clen=length;            /* Ending slop */
len509net/inet/rarp.creturn len;
len97net/inet/raw.cunsigned long daddr, unsigned short len, unsigned long saddr,
len104net/inet/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
len124net/inet/raw.cskb->len = len + skb->ip_hdr->ihl*sizeof(long);
len140net/inet/raw.csk->data_ready(sk,skb->len);
len150net/inet/raw.cint len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)
len159net/inet/raw.c"            usin=%X, addr_len = %d)\n", sk, from, len, noblock,
len168net/inet/raw.cif (len < 0) 
len171net/inet/raw.cerr=verify_area(VERIFY_READ,from,len);
len219net/inet/raw.clen + sk->prot->max_header,
len257net/inet/raw.cmemcpy_fromfs(skb->data + tmp, from, len);
len276net/inet/raw.cskb->len = tmp + len;
len280net/inet/raw.creturn(len);
len284net/inet/raw.cstatic int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len287net/inet/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
len337net/inet/raw.craw_recvfrom(struct sock *sk, unsigned char *to, int len,
len347net/inet/raw.csk, to, len, noblock, flags, sin, addr_len));
len349net/inet/raw.cif (len == 0) return(0);
len350net/inet/raw.cif (len < 0) return(-EINVAL);
len366net/inet/raw.cerr=verify_area(VERIFY_WRITE,to,len);
len374net/inet/raw.ccopied = min(len, skb->len);
len395net/inet/raw.craw_read (struct sock *sk, unsigned char *buff, int len, int noblock,
len398net/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);
len496net/inet/route.cint len=0;
len501net/inet/route.clen += sprintf(buffer,
len503net/inet/route.cpos=len;
len511net/inet/route.csize = sprintf(buffer+len, "%s\t%08lX\t%08lX\t%02X\t%d\t%lu\t%d\t%08lX\n",
len515net/inet/route.clen+=size;
len519net/inet/route.clen=0;
len527net/inet/route.clen-=(offset-begin);
len528net/inet/route.cif(len>length)
len529net/inet/route.clen=length;
len530net/inet/route.creturn len;
len329net/inet/skbuff.cunsigned int len;
len343net/inet/skbuff.clen = orig->truesize;
len346net/inet/skbuff.cnewsk = alloc_skb(len,GFP_KERNEL);  /* May sleep */
len359net/inet/skbuff.cnewsk->mem_len = len;
len366net/inet/skbuff.cmemcpy(newsk,orig,len);
len514net/inet/skbuff.cn->len=skb->len;
len705net/inet/sock.cstatic void def_callback2(struct sock *sk,int len)
len1206net/inet/sock.cint len;
len1214net/inet/sock.clen=get_fs_long(uaddr_len);
len1216net/inet/sock.cerr = verify_area(VERIFY_WRITE, uaddr, len);
len1221net/inet/sock.cif (len < sizeof(sin)) return(-EINVAL);
len1238net/inet/sock.clen = sizeof(sin);
len1242net/inet/sock.cput_fs_long(len, uaddr_len);
len1690net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
len189net/inet/sock.hint len, int nonblock, unsigned flags);
len191net/inet/sock.hint len, int nonblock, unsigned flags);
len193net/inet/sock.hunsigned char *from, int len, int noblock,
len197net/inet/sock.hunsigned char *from, int len, int noblock,
len204net/inet/sock.hstruct options *opt, int len, int tos, int ttl);
len216net/inet/sock.hunsigned short len, unsigned long saddr,
len350net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
len525net/inet/tcp.ctcp_check(struct tcphdr *th, int len,
len536net/inet/tcp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_TCP*256)
len539net/inet/tcp.cif (len > 3) {
len547net/inet/tcp.c: "0"(sum), "c"(len/4) ,"1"(th)
len561net/inet/tcp.cif ((len & 2) != 0) {
len571net/inet/tcp.cif ((len & 1) != 0) {
len587net/inet/tcp.cunsigned long daddr, int len, struct sock *sk)
len590net/inet/tcp.cth->check = tcp_check(th, len, saddr, daddr);
len600net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
len603net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) {
len605net/inet/tcp.cskb, skb->data, th, skb->len);
len726net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len742net/inet/tcp.cbuff->len += tmp;
len815net/inet/tcp.cint len, int nonblock, unsigned flags)
len827net/inet/tcp.csk, from, len, nonblock, flags));
len831net/inet/tcp.cwhile(len > 0) 
len951net/inet/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
len959net/inet/tcp.cmemcpy_fromfs(skb->data + skb->len, from, copy);
len960net/inet/tcp.cskb->len += copy;
len963net/inet/tcp.clen -= copy;
len966net/inet/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
len989net/inet/tcp.cif (copy > len)
len990net/inet/tcp.ccopy = len;
len1065net/inet/tcp.cskb->len = 0;
len1088net/inet/tcp.cskb->len += tmp;
len1092net/inet/tcp.ctmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
len1108net/inet/tcp.cskb->len += tmp;
len1113net/inet/tcp.clen -= copy;
len1114net/inet/tcp.cskb->len += copy;
len1151net/inet/tcp.cint len, int nonblock, unsigned flags,
len1167net/inet/tcp.creturn(tcp_write(sk, from, len, nonblock, flags));
len1202net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len1219net/inet/tcp.cbuff->len += tmp;
len1338net/inet/tcp.cunsigned char *to, int len, unsigned flags)
len1342net/inet/tcp.cwhile (len > 0) {
len1392net/inet/tcp.cint len, int nonblock, unsigned flags)
len1401net/inet/tcp.cif (len == 0)
len1404net/inet/tcp.cif (len < 0)
len1407net/inet/tcp.cerr = verify_area(VERIFY_WRITE, to, len);
len1417net/inet/tcp.creturn tcp_read_urg(sk, nonblock, to, len, flags);
len1426net/inet/tcp.cwhile (len > 0) {
len1447net/inet/tcp.cif (offset < skb->len)
len1495net/inet/tcp.cused = skb->len - offset;
len1496net/inet/tcp.cif (len < used)
len1497net/inet/tcp.cused = len;
len1516net/inet/tcp.clen -= used;
len1521net/inet/tcp.cif (!(flags & MSG_PEEK) && (used + offset >= skb->len))
len1596net/inet/tcp.cbuff->len = sizeof(*t1);
len1635net/inet/tcp.cbuff->len += tmp;
len1687net/inet/tcp.cint len;
len1697net/inet/tcp.clen = get_fs_long(addr_len);
len1698net/inet/tcp.cif(len > sizeof(sin))
len1699net/inet/tcp.clen = sizeof(sin);
len1700net/inet/tcp.cerr=verify_area(VERIFY_WRITE, addr, len);  
len1712net/inet/tcp.cmemcpy_tofs(addr, &sin, len);
len1713net/inet/tcp.cput_fs_long(len, addr_len);
len1740net/inet/tcp.cbuff->len = sizeof(*t1);
len1761net/inet/tcp.cbuff->len += tmp;
len2023net/inet/tcp.cbuff->len = sizeof(struct tcphdr)+4;
len2046net/inet/tcp.cbuff->len += tmp;
len2124net/inet/tcp.cif(skb->len > 0 && after(skb->h.th->seq + skb->len + 1 , sk->copied_seq))
len2207net/inet/tcp.cbuff->len = sizeof(*t1);
len2240net/inet/tcp.cbuff->len += tmp;
len2372net/inet/tcp.ctcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
len2411net/inet/tcp.cif (len != th->doff*4) flag |= 1;
len2778net/inet/tcp.cunsigned long saddr, unsigned short len)
len2786net/inet/tcp.cskb->len = len -(th->doff*4);
len2788net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data len = %d sk = %X:\n", skb->len, sk));
len2790net/inet/tcp.csk->bytes_rcv += skb->len;
len2791net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) {
len2799net/inet/tcp.csk->acked_seq = th->seq + skb->len + th->syn + th->fin;
len2836net/inet/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
len2859net/inet/tcp.cth->ack_seq = th->seq + skb->len;
len3026net/inet/tcp.cunsigned long saddr, unsigned long len)
len3040net/inet/tcp.cif (ptr >= len)
len3071net/inet/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
len3268net/inet/tcp.cbuff->len = 24;
len3292net/inet/tcp.cbuff->len += tmp;
len3362net/inet/tcp.ctcp_sequence(struct sock *sk, struct tcphdr *th, short len,
len3367net/inet/tcp.cnext_seq = len - 4*th->doff;
len3418net/inet/tcp.cunsigned long daddr, unsigned short len,
len3442net/inet/tcp.cDPRINTF((DBG_TCP, "len = %d, redo = %d, skb=%X\n", len, redo, skb));
len3454net/inet/tcp.cif (tcp_check(th, len, saddr, daddr )) {
len3477net/inet/tcp.cskb->len = len;
len3544net/inet/tcp.cif (!tcp_sequence(sk, th, len, opt, saddr,dev)) {
len3595net/inet/tcp.cif (th->ack && !tcp_ack(sk, th, saddr, len)) {
len3601net/inet/tcp.cif (tcp_urg(sk, th, saddr, len)) {
len3607net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
len3680net/inet/tcp.cif (!tcp_sequence(sk, th, len, opt, saddr,dev)) 
len3718net/inet/tcp.cif (!tcp_ack(sk, th, saddr, len)) 
len3746net/inet/tcp.cif (!tcp_ack(sk, th, saddr, len)) 
len3790net/inet/tcp.cif (tcp_urg(sk, th, saddr, len)) { 
len3796net/inet/tcp.cif (tcp_data(skb, sk, saddr, len))
len3805net/inet/tcp.cif (tcp_urg(sk, th, saddr, len)) {
len3812net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
len3862net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len3879net/inet/tcp.cbuff->len += tmp;
len121net/inet/tcp.hunsigned short len, unsigned long saddr, int redo,
len67net/inet/timer.creset_timer (struct sock *t, int timeout, unsigned long len)
len75net/inet/timer.cif ((int) len < 0)  /* prevent close to infinite timers. THEY _DO_ */
len76net/inet/timer.clen = 3;  /* happen (negative values ?) - don't ask me why ! -FB */
len78net/inet/timer.ct->timer.expires = len;
len93net/inet/udp.cprintk("     len = %d, check = %d\n", ntohs(uh->len), ntohs(uh->check));
len153net/inet/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr)
len158net/inet/udp.cuh, len, saddr, daddr));
len166net/inet/udp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_UDP*256)
len169net/inet/udp.cif (len > 3) 
len178net/inet/udp.c: "0"(sum), "c"(len/4) ,"1"(uh)
len198net/inet/udp.cif ((len & 2) != 0) 
len212net/inet/udp.cif ((len & 1) != 0) 
len237net/inet/udp.cunsigned long daddr, int len, struct sock *sk)
len242net/inet/udp.cuh->check = udp_check(uh, len, saddr, daddr);
len255net/inet/udp.cunsigned char *from, int len, int rt)
len267net/inet/udp.cfrom, len));
len269net/inet/udp.cerr=verify_area(VERIFY_READ, from, len);
len277net/inet/udp.csize = sk->prot->max_header + len;
len315net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
len323net/inet/udp.cuh->len = htons(len + sizeof(struct udphdr));
len332net/inet/udp.cmemcpy_fromfs(buff, from, len);
len338net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
len347net/inet/udp.creturn(len);
len351net/inet/udp.cstatic int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
len358net/inet/udp.cDPRINTF((DBG_UDP, "UDP: sendto(len=%d, flags=%X)\n", len, flags));
len365net/inet/udp.cif (len < 0) 
len367net/inet/udp.cif (len == 0) 
len410net/inet/udp.ctmp = udp_send(sk, &sin, from, len, flags);
len421net/inet/udp.cstatic int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len424net/inet/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
len486net/inet/udp.camount = skb->len;
len508net/inet/udp.cint udp_recvfrom(struct sock *sk, unsigned char *to, int len,
len531net/inet/udp.cif (len == 0) 
len533net/inet/udp.cif (len < 0) 
len559net/inet/udp.cer=verify_area(VERIFY_WRITE,to,len);
len572net/inet/udp.ccopied = min(len, skb->len);
len601net/inet/udp.cint udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
len604net/inet/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len652net/inet/udp.cunsigned long daddr, unsigned short len,
len670net/inet/udp.culen = ntohs(uh->len);
len672net/inet/udp.cif (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
len674net/inet/udp.cprintk("UDP: short packet: %d/%d\n", ulen, len);
len675net/inet/udp.cDPRINTF((DBG_UDP, "UDP: short packet %d/%d\n", ulen, len));
len680net/inet/udp.clen=ulen;
len699net/inet/udp.cif (uh->check && udp_check(uh, len, saddr, daddr)) 
len710net/inet/udp.cskb->len = len;
len748net/inet/udp.cskb->len = len - sizeof(*uh);  
len753net/inet/udp.csk->data_ready(sk,skb->len);
len37net/inet/udp.hint len, int noblock, unsigned flags,
len40net/inet/udp.hint len, int noblock, unsigned flags);
len45net/inet/udp.hunsigned short len, unsigned long saddr, int redo,
len710net/socket.csock_send(int fd, void * buff, int len, unsigned flags)
len717net/socket.cfd, buff, len, flags));
len723net/socket.creturn(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
len728net/socket.csock_sendto(int fd, void * buff, int len, unsigned flags,
len736net/socket.c" addr=%X, alen = %d\n", fd, buff, len, flags, addr, addr_len));
len742net/socket.creturn(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
len748net/socket.csock_recv(int fd, void * buff, int len, unsigned flags)
len755net/socket.cfd, buff, len, flags));
len761net/socket.creturn(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
len766net/socket.csock_recvfrom(int fd, void * buff, int len, unsigned flags,
len774net/socket.c" addr=%X, alen=%X\n", fd, buff, len, flags, addr, addr_len));
len780net/socket.creturn(sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
len42net/unix/proc.cint len=0;
len45net/unix/proc.clen += sprintf(buffer, "Num RefCount Protocol Flags    Type St Path\n");
len51net/unix/proc.clen += sprintf(buffer+len, "%2d: %08X %08X %08lX %04X %02X", i,
len62net/unix/proc.clen += sprintf(buffer+len, " %s\n",
len67net/unix/proc.cbuffer[len++]='\n';
len68net/unix/proc.cbuffer[len++]='\0';
len71net/unix/proc.cpos=begin+len;
len74net/unix/proc.clen=0;
len83net/unix/proc.clen-=(offset-begin);
len84net/unix/proc.cif(len>length)
len85net/unix/proc.clen=length;
len86net/unix/proc.creturn len;
len79net/unix/sock.cstatic int unix_proto_send(struct socket *sock, void *buff, int len,
len81net/unix/sock.cstatic int unix_proto_recv(struct socket *sock, void *buff, int len,
len83net/unix/sock.cstatic int unix_proto_sendto(struct socket *sock, void *buff, int len,
len86net/unix/sock.cstatic int unix_proto_recvfrom(struct socket *sock, void *buff, int len,
len193net/unix/sock.cunix_proto_sendto(struct socket *sock, void *buff, int len, int nonblock, 
len200net/unix/sock.cunix_proto_recvfrom(struct socket *sock, void *buff, int len, int nonblock, 
len216net/unix/sock.cunix_proto_send(struct socket *sock, void *buff, int len, int nonblock,
len220net/unix/sock.creturn(unix_proto_write(sock, (char *) buff, len, nonblock));
len226net/unix/sock.cunix_proto_recv(struct socket *sock, void *buff, int len, int nonblock,
len230net/unix/sock.creturn(unix_proto_read(sock, (char *) buff, len, nonblock));
len570net/unix/sock.cint len;
len586net/unix/sock.cif ((len = get_fs_long(usockaddr_len)) <= 0) return(-EINVAL);
len587net/unix/sock.cif (len > upd->sockaddr_len) len = upd->sockaddr_len;
len588net/unix/sock.cif (len) {
len589net/unix/sock.cer=verify_area(VERIFY_WRITE, usockaddr, len);
len592net/unix/sock.cmemcpy_tofs(usockaddr, &upd->sockaddr_un, len);
len594net/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));