taglinefilesource code
len264arch/i386/boot/compressed/gzip.hvoid     copy_block OF((char *buf, unsigned len, int header));
len219arch/i386/boot/compressed/misc.cint len, i;
len224arch/i386/boot/compressed/misc.clen = INBUFSIZ-insize;
len225arch/i386/boot/compressed/misc.cif (len > (input_len-input_ptr+1)) len=input_len-input_ptr+1;
len226arch/i386/boot/compressed/misc.cif (len == 0 || len == EOF) break;
len228arch/i386/boot/compressed/misc.cfor (i=0;i<len;i++) inbuf[insize+i] = input_data[input_ptr+i];
len229arch/i386/boot/compressed/misc.cinsize += len;
len230arch/i386/boot/compressed/misc.cinput_ptr += len;
len397arch/i386/boot/compressed/misc.cunsigned len = (unsigned)get_byte();
len398arch/i386/boot/compressed/misc.clen |= ((unsigned)get_byte())<<8;
len399arch/i386/boot/compressed/misc.cwhile (len--) (void)get_byte();
len18arch/i386/boot/compressed/piggyback.cint c, n=0, len=0;
len35arch/i386/boot/compressed/piggyback.clen = 0;
len36arch/i386/boot/compressed/piggyback.cwhile ((n = read(0, &tmp_buf[len], sizeof(tmp_buf)-len+1)) > 0)
len37arch/i386/boot/compressed/piggyback.clen += n;
len45arch/i386/boot/compressed/piggyback.cif (len >= sizeof(tmp_buf))
len51arch/i386/boot/compressed/piggyback.cfprintf(stderr, "Compressed size %d.\n", len);
len56arch/i386/boot/compressed/piggyback.cobj.a_data = len + sizeof(long);
len63arch/i386/boot/compressed/piggyback.cwrite(1, tmp_buf, len);
len64arch/i386/boot/compressed/piggyback.cwrite(1, (char *)&len, sizeof(len));
len69arch/i386/boot/compressed/piggyback.cvar_names[1].n_value = len;
len75arch/i386/boot/compressed/piggyback.clen = sizeof(string_names) + sizeof(len);
len76arch/i386/boot/compressed/piggyback.cwrite(1, (char *)&len, sizeof(len));
len133arch/i386/ibcs/binfmt_elf.cunsigned int len;
len203arch/i386/ibcs/binfmt_elf.clen = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
len206arch/i386/ibcs/binfmt_elf.cif (last_bss > len)
len207arch/i386/ibcs/binfmt_elf.cdo_mmap(NULL, len, last_bss-len,
len570arch/i386/ibcs/binfmt_elf.cunsigned int len;
len577arch/i386/ibcs/binfmt_elf.clen = 0;
len645arch/i386/ibcs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len647arch/i386/ibcs/binfmt_elf.cif (bss > len)
len648arch/i386/ibcs/binfmt_elf.cdo_mmap(NULL, len, bss-len,
len121arch/i386/kernel/ioport.c{       int i=0,len=0;
len122arch/i386/kernel/ioport.cwhile(i<IOPORTNAMES_LEN && len<4000)
len124arch/i386/kernel/ioport.clen+=sprintf(buf+len,"%04x-%04x : %s\n",
len130arch/i386/kernel/ioport.cif(len>=4000) 
len131arch/i386/kernel/ioport.clen+=sprintf(buf+len,"4k-Limit reached!\n");
len132arch/i386/kernel/ioport.creturn len;
len163arch/i386/kernel/irq.cint i, len = 0;
len169arch/i386/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len174arch/i386/kernel/irq.creturn len;
len307drivers/block/ide-cd.cint stat_dum, len;
len315drivers/block/ide-cd.clen = IN_BYTE (HD_LCYL, dev->hwif) + 256 * IN_BYTE (HD_HCYL, dev->hwif);
len317drivers/block/ide-cd.cif (len != CD_FRAMESIZE)
len319drivers/block/ide-cd.cprintk ("cdrom_read_intr: funny value for read length %d\n", len);
len320drivers/block/ide-cd.cif (len > CD_FRAMESIZE) len = CD_FRAMESIZE;
len323drivers/block/ide-cd.cIN_WORDS (rq->buffer, len/2);
len416drivers/block/ide-cd.cint ireason, len, stat, thislen;
len425drivers/block/ide-cd.clen = IN_BYTE (HD_LCYL, dev->hwif) + 256 * IN_BYTE (HD_HCYL, dev->hwif);
len447drivers/block/ide-cd.cif (thislen > len) thislen = len;
len466drivers/block/ide-cd.cwhile (len > thislen)
len470drivers/block/ide-cd.clen -= 2;
len495drivers/block/ide-cd.cwhile (len > thislen)
len499drivers/block/ide-cd.clen -= 2;
len536drivers/block/ide-cd.cint len;
len540drivers/block/ide-cd.clen = pc->buflen;
len541drivers/block/ide-cd.cif (len < 0) len = -len;
len545drivers/block/ide-cd.cif (cdrom_start_packet_command (dev, len))
len33drivers/block/ramdisk.cint  len;
len39drivers/block/ramdisk.clen = CURRENT->current_nr_sectors << 9;
len42drivers/block/ramdisk.c(addr+len > rd_start+rd_length)) {
len49drivers/block/ramdisk.clen);
len53drivers/block/ramdisk.clen);
len362drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len382drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
len562drivers/net/3c501.cskb->len = pkt_len;
len544drivers/net/3c505.cint len)
len559drivers/net/3c505.cint sksize = sizeof(struct sk_buff) + len + 4;
len565drivers/net/3c505.cif (len <= 0 || ((len & ~1) != len))
len567drivers/net/3c505.cprintk("*** bad packet len %d at %s(%d)\n",len,filename,__LINE__);
len569drivers/net/3c505.crlen = (len+1) & ~1;
len600drivers/net/3c505.cskb->len = rlen;
len671drivers/net/3c505.cint len;
len784drivers/net/3c505.clen = adapter->irx_pcb.data.rcv_resp.pkt_len;
len790drivers/net/3c505.cprintk("%s: interrupt - packet received of length %i (%i)\n", dev->name, len, dlen);
len970drivers/net/3c505.cstatic int send_packet (elp_device * adapter, unsigned char * ptr, int len)
len978drivers/net/3c505.cunsigned int nlen = (((len < 60) ? 60 : len) + 1) & (~1);
len983drivers/net/3c505.cif (nlen < len)
len984drivers/net/3c505.cprintk("Warning, bad length nlen=%d len=%d %s(%d)\n",nlen,len,filename,__LINE__);
len1063drivers/net/3c505.cif (skb->len <= 0)
len1067drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
len1087drivers/net/3c505.cif (!send_packet(adapter, (unsigned char *)SKB_DATA, skb->len)) {
len1093drivers/net/3c505.cprintk("%s: packet of length %d sent\n", dev->name, (int)skb->len);
len491drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len845drivers/net/3c507.cskb->len = pkt_len;
len402drivers/net/3c509.cif (skb->len <= 0)
len407drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
len431drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
len434drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
len600drivers/net/3c509.cskb->len = pkt_len;
len169drivers/net/8390.clength = skb->len;
len170drivers/net/8390.cif (skb->len <= 0)
len458drivers/net/8390.cskb->len = pkt_len;
len356drivers/net/apricot.cskb->len = pkt_len;
len620drivers/net/apricot.cif (skb->len <= 0) return 0;
len630drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len403drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len533drivers/net/at1700.cskb->len = pkt_len;
len444drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len636drivers/net/atp.cskb->len = pkt_len;
len407drivers/net/de600.cint  len;
len441drivers/net/de600.cPRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
len443drivers/net/de600.cif ((len = skb->len) < RUNT)
len444drivers/net/de600.clen = RUNT;
len448drivers/net/de600.ctx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len;
len464drivers/net/de600.cfor ( ; len > 0; --len, ++buffer)
len481drivers/net/de620.cint len;
len517drivers/net/de620.cif ((len = skb->len) < RUNT)
len518drivers/net/de620.clen = RUNT;
len519drivers/net/de620.cif (len & 1) /* send an even number of bytes */
len520drivers/net/de620.c++len;
len527drivers/net/de620.c(int)skb->len, using_txbuf));
len548drivers/net/de620.cde620_write_block(buffer, len);
len682drivers/net/de620.cskb->len = size; skb->dev = dev; skb->free = 1;
len838drivers/net/depca.cif (skb->len <= 0) {
len861drivers/net/depca.cint len;
len862drivers/net/depca.clong skbL = skb->len;
len876drivers/net/depca.clen = ((skbL > PKT_SZ) ? PKT_SZ : skbL); /* skb too long */
len877drivers/net/depca.cif (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
len878drivers/net/depca.cskbL -= len;
len879drivers/net/depca.clp->tx_ring[entry].length = -len;
len885drivers/net/depca.cmemcpy((unsigned char *)(buf), skb->data, len);
len897drivers/net/depca.cfor (p += len; skbL > 0; p += len) {
len913drivers/net/depca.clen = ((skbL > DAT_SZ) ? DAT_SZ : skbL); /* skbL too long */
len914drivers/net/depca.cif (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
len915drivers/net/depca.cskbL -= len;
len916drivers/net/depca.clp->tx_ring[entry].length = -len;
len922drivers/net/depca.cmemcpy((unsigned char *)(buf + PKT_HDR_LEN), (unsigned char *)p, len);
len1065drivers/net/depca.cskb->len = pkt_len;
len496drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len951drivers/net/eexpress.cskb->len = pkt_len;
len796drivers/net/ewrk3.c} else if (skb->len > 0) {
len849drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
len850drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
len852drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
len858drivers/net/ewrk3.c*buf++ = (char)(skb->len & 0xff);         /* length (16 bit xfer)*/
len860drivers/net/ewrk3.c*buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
len862drivers/net/ewrk3.c*(buf + skb->len) = 0x00;               /* Write the XCT flag */
len865drivers/net/ewrk3.cmemcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
len866drivers/net/ewrk3.c*(buf + skb->len) = 0xff;               /* Write the XCT flag */
len868drivers/net/ewrk3.c*buf++ = (char)((skb->len >> 8) & 0xff);
len870drivers/net/ewrk3.cmemcpy(buf, skb->data, skb->len);       /* Write data bytes */
len1038drivers/net/ewrk3.cskb->len = pkt_len;
len1045drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
len1624drivers/net/ewrk3.cioc->len = ETH_ALEN;
len1625drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1684drivers/net/ewrk3.cioc->len = (HASH_TABLE_LEN >> 3);
len1685drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len); 
len1691drivers/net/ewrk3.cif (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
len1692drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len1694drivers/net/ewrk3.cset_multicast_list(dev, ioc->len, tmp.addr);
len1722drivers/net/ewrk3.cioc->len = EWRK3_PKT_STAT_SZ;
len1760drivers/net/ewrk3.cioc->len = EEPROM_MAX + 1 + ETH_ALEN;
len1761drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len295drivers/net/ewrk3.hunsigned short len;                /* Length of the data buffer */
len677drivers/net/lance.cif (skb->len <= 0)
len712drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len714drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
len720drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
len724drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
len913drivers/net/lance.cskb->len = pkt_len;
len64drivers/net/loopback.cdone = dev_rint(skb->data, skb->len, 0, dev);
len870drivers/net/ni52.cskb->len = totlen;
len1000drivers/net/ni52.cint len;
len1029drivers/net/ni52.cif (skb->len <= 0)
len1036drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
len1037drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
len1041drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1049drivers/net/ni52.cfor(len=0;len<256;len++);
len1054drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1067drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
len500drivers/net/ni65.cint rmdstat,len;
len529drivers/net/ni65.clen = (rmdp->mlen & 0x0fff) - 4; /* -4: ignore FCS */
len534drivers/net/ni65.cmemcpy(skb->data,p->recv_skb[p->rmdnum]->data,len);
len544drivers/net/ni65.cskb1->len = len;
len588drivers/net/ni65.cif (skb->len <= 0)
len603drivers/net/ni65.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len611drivers/net/ni65.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff),(char *)skb->data,skb->len);
len614drivers/net/ni65.ctmdp->blen = -len;
len434drivers/net/plip.cif (skb->len > dev->mtu) {
len435drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
len444drivers/net/plip.csnd->length = skb->len;
len656drivers/net/plip.crcv->skb->len = rcv->length;
len118drivers/net/ppp.cunsigned long saddr, unsigned len);
len1152drivers/net/ppp.cunsigned char *buf, int len)
len1157drivers/net/ppp.ctotlen = len+2;    /* including protocol */
len1170drivers/net/ppp.cwhile (len-- > 0) {
len1218drivers/net/ppp.cint len, i;
len1248drivers/net/ppp.cGETC (c); len = c << 8; GETC (c); len += c;
len1250drivers/net/ppp.cPRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
len1252drivers/net/ppp.cif (len + 2 > nr) {
len1256drivers/net/ppp.cnr, len+2));
len1257drivers/net/ppp.cppp->us_rbuff_head += len;
len1268drivers/net/ppp.ci = len;
len1276drivers/net/ppp.cPRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
len1278drivers/net/ppp.creturn len + 2;
len1683drivers/net/ppp.cint len;
len1695drivers/net/ppp.clen   = skb->len;
len1716drivers/net/ppp.cif (len < sizeof(struct iphdr)) {
len1720drivers/net/ppp.clen = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
len1725drivers/net/ppp.cif (ppp_us_queue (ppp, proto, p, len))
len1743drivers/net/ppp.clen = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 0);
len1763drivers/net/ppp.cdev->name, (int) proto, (int) len, (int) iph->saddr,
len1787drivers/net/ppp.cwhile (len-- > 0)
len1821drivers/net/ppp.cunsigned long daddr, unsigned long saddr, unsigned len)
len1841drivers/net/ppp.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
len1250drivers/net/sk_g16.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 
len1259drivers/net/sk_g16.cskb->len);
len1261drivers/net/sk_g16.ctmdp->blen = -len;            /* set length to transmit */
len1571drivers/net/sk_g16.cint len = (rmdp->mlen & 0x0fff);  /* extract message length from receive buffer */
len1574drivers/net/sk_g16.cskb = alloc_skb(len, GFP_ATOMIC); /* allocate socket buffer */ 
len1594drivers/net/sk_g16.cskb->len = len;
len1605drivers/net/sk_g16.clen);
len340drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len426drivers/net/skeleton.cskb->len = pkt_len;
len499drivers/net/slhc.cint len, hdrlen;
len604drivers/net/slhc.clen = isize - (cp - icp);
len605drivers/net/slhc.cif (len < 0)
len607drivers/net/slhc.clen += hdrlen;
len608drivers/net/slhc.cip->tot_len = htons(len);
len611drivers/net/slhc.cmemmove(icp + hdrlen, cp, len - hdrlen);
len632drivers/net/slhc.creturn len;
len97drivers/net/slip.cstatic int slip_esc(unsigned char *p, unsigned char *d, int len);
len100drivers/net/slip.cstatic int slip_esc6(unsigned char *p, unsigned char *d, int len);
len142drivers/net/slip.cint len;
len145drivers/net/slip.clen = dev->mtu * 2;
len151drivers/net/slip.cif (len < 576 * 2)  {
len152drivers/net/slip.clen = 576 * 2;
len155drivers/net/slip.cxbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len156drivers/net/slip.crbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len158drivers/net/slip.ccbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len194drivers/net/slip.cif (sl->xleft <= len)  {
len204drivers/net/slip.cif (sl->rcount <= len) {
len217drivers/net/slip.csl->buffsize = len;
len301drivers/net/slip.cskb->len = count;
len310drivers/net/slip.csl_encaps(struct slip *sl, unsigned char *icp, int len)
len324drivers/net/slip.cif (len > sl->mtu) {    /* Sigh, shouldn't occur BUT ... */
len325drivers/net/slip.clen = sl->mtu;
len335drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
len340drivers/net/slip.ccount = slip_esc6(p, (unsigned char *) sl->xbuff, len);
len343drivers/net/slip.ccount = slip_esc(p, (unsigned char *) sl->xbuff, len);
len434drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
len459drivers/net/slip.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
len466drivers/net/slip.creturn ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
len497drivers/net/slip.cunsigned long len;
len510drivers/net/slip.clen = dev->mtu * 2;
len516drivers/net/slip.cif (len < 576 * 2)  {
len517drivers/net/slip.clen = 576 * 2;
len519drivers/net/slip.csl->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len523drivers/net/slip.csl->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len528drivers/net/slip.csl->cbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len543drivers/net/slip.csl->buffsize = len;
len788drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
len806drivers/net/slip.cwhile (len-- > 0) {
len869drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
len889drivers/net/slip.cfor (i = 0; i < len; ++i) {
len360drivers/net/znet.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len386drivers/net/znet.cmemcpy(zn.tx_cur, buf, skb->len);
len559drivers/net/znet.cskb->len = pkt_len;
len1982drivers/scsi/53c7,8xx.csize_t len;
len1999drivers/scsi/53c7,8xx.clen = strlen(buf);
len2002drivers/scsi/53c7,8xx.csprintf(buf + len, "%08x\n", * (long *) bp->addr);
len2004drivers/scsi/53c7,8xx.csprintf(buf + len, "\n");
len2006drivers/scsi/53c7,8xx.clen = strlen(buf);
len2007drivers/scsi/53c7,8xx.cdebugger_kernel_write (host, buf, len);
len2019drivers/scsi/53c7,8xx.csize_t len;
len2079drivers/scsi/53c7,8xx.cint i, j, error, len;
len2100drivers/scsi/53c7,8xx.clen = strlen (debugger_tokens[i].name);
len2101drivers/scsi/53c7,8xx.cif (!strncmp(input_buf, debugger_tokens[i].name, len)) 
len2108drivers/scsi/53c7,8xx.cfor (ptr = input_buf + len, j = 0; j < debugger_tokens[i].nargs && *ptr;) {
len3633drivers/scsi/53c7,8xx.csize_t len = strlen(buf);
len3634drivers/scsi/53c7,8xx.cdebugger_kernel_write(host, buf, len);
len3774drivers/scsi/53c7,8xx.cint i, len;
len3785drivers/scsi/53c7,8xx.cptr += len, i -= len) {
len3787drivers/scsi/53c7,8xx.clen = print_msg (ptr);
len1171drivers/scsi/NCR5380.cint len;
len1411drivers/scsi/NCR5380.clen = 3;
len1415drivers/scsi/NCR5380.clen = 1;
len1422drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len1915drivers/scsi/NCR5380.cint len, transfersize;
len1999drivers/scsi/NCR5380.clen = transfersize;
len2001drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
len2015drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
len2023drivers/scsi/NCR5380.clen = 1;
len2025drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2227drivers/scsi/NCR5380.clen = 2;
len2230drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2238drivers/scsi/NCR5380.cif (!len && extended_msg[1] <= 
len2242drivers/scsi/NCR5380.clen = extended_msg[1] - 1;
len2246drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2250drivers/scsi/NCR5380.cinstance->host_no, len);
len2260drivers/scsi/NCR5380.c} else if (len) {
len2294drivers/scsi/NCR5380.clen = 1;
len2297drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2309drivers/scsi/NCR5380.clen = cmd->cmd_len;
len2316drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, 
len2331drivers/scsi/NCR5380.clen = 1;
len2333drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2378drivers/scsi/NCR5380.cint len;
len2422drivers/scsi/NCR5380.clen = 1;
len2425drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2487drivers/scsi/NCR5380.clen = 1;
len2491drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2576drivers/scsi/NCR5380.cint len;
len2707drivers/scsi/NCR5380.clen = 1;
len2710drivers/scsi/NCR5380.cNCR5380_transfer_pio (instance, &phase, &len, &msgptr);
len150drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
len154drivers/scsi/aha1542.cif(len == 1) {
len167drivers/scsi/aha1542.cwhile (len--)
len177drivers/scsi/aha1542.cprintk("aha1542_out failed(%d): ", len+1); aha1542_stat();
len183drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
len189drivers/scsi/aha1542.cwhile (len--)
len198drivers/scsi/aha1542.cprintk("aha1542_in failed(%d): ", len+1); aha1542_stat();
len205drivers/scsi/aha1542.cstatic int aha1542_in1(unsigned int base, unchar *cmdp, int len)
len211drivers/scsi/aha1542.cwhile (len--)
len285drivers/scsi/aha1542.cint len;
len318drivers/scsi/aha1542.clen = 4;
len321drivers/scsi/aha1542.cwhile (len--)
len242drivers/scsi/buslogic.csize_t len)
len246drivers/scsi/buslogic.cif (len == 1) {
len261drivers/scsi/buslogic.cwhile (len--) {
len270drivers/scsi/buslogic.cbuslogic_printk("failed(%u): ", len + 1);
len278drivers/scsi/buslogic.cstatic int buslogic_in(unsigned int base, unsigned char *cmdp, size_t len)
len284drivers/scsi/buslogic.cwhile (len--) {
len293drivers/scsi/buslogic.cbuslogic_printk("failed(%u): ", len + 1);
len478drivers/scsi/constants.cint len = 0, i;
len480drivers/scsi/constants.clen = 3 + msg[1];
len499drivers/scsi/constants.cfor (i = 2; i < len; ++i) 
len503drivers/scsi/constants.cfor (i = 0; i < len; ++i)
len516drivers/scsi/constants.clen = 1;
len527drivers/scsi/constants.clen = 1;
len540drivers/scsi/constants.clen = 2;
len547drivers/scsi/constants.creturn len;
len176drivers/scsi/eata.cushort len;          /* Number of bytes following this field */
len370drivers/scsi/eata.cconfig.len = (ushort) htons((ushort)510);
len477drivers/scsi/pas16.cint len) {
len481drivers/scsi/pas16.cregister i = len;
len510drivers/scsi/pas16.cint len) {
len513drivers/scsi/pas16.cregister i = len;
len1814drivers/scsi/scsi.cvoid *scsi_malloc(unsigned int len)
len1819drivers/scsi/scsi.cif((len & 0x1ff) || len > 8192)
len1824drivers/scsi/scsi.cnbits = len >> 9;
len1834drivers/scsi/scsi.cprintk("SMalloc: %d %x ",len, dma_malloc_buffer + (i << 13) + (j << 9));
len1843drivers/scsi/scsi.cint scsi_free(void *obj, unsigned int len)
len1850drivers/scsi/scsi.cprintk("Sfree %x %d\n",obj, len);
len1861drivers/scsi/scsi.cnbits = len >> 9;
len31drivers/scsi/scsi_ioctl.cunsigned int len,slen;
len35drivers/scsi/scsi_ioctl.clen = get_fs_long ((unsigned long *) buffer);
len42drivers/scsi/scsi_ioctl.cif (len > slen)
len43drivers/scsi/scsi_ioctl.clen = slen + 1;
len44drivers/scsi/scsi_ioctl.cverify_area(VERIFY_WRITE, buffer, len);
len45drivers/scsi/scsi_ioctl.cmemcpy_tofs (buffer, string, len);
len578drivers/scsi/seagate.cint len = 0;
len707drivers/scsi/seagate.clen=current_bufflen;    /* WDE add */
len905drivers/scsi/seagate.clen = buffer->length;
len912drivers/scsi/seagate.clen = SCint->request_bufflen;
len917drivers/scsi/seagate.cprintk("scsi%d : len = %d\n", hostno, len);
len1030drivers/scsi/seagate.cif (!len) {
len1040drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1048drivers/scsi/seagate.cSCint->transfersize, len, data);
len1070drivers/scsi/seagate.clen -= transfersize;
len1075drivers/scsi/seagate.chostno, len, data);
len1131drivers/scsi/seagate.c"=S" (data), "=c" (len) :
len1133drivers/scsi/seagate.c"0" (data), "1" (len) :
len1138drivers/scsi/seagate.cif (!len && nobuffs) {
len1141drivers/scsi/seagate.clen = buffer->length;
len1145drivers/scsi/seagate.chostno, len, data);
len1154drivers/scsi/seagate.ctransfered += len;
len1156drivers/scsi/seagate.cfor (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN |
len1157drivers/scsi/seagate.cSTAT_REQ); --len) {
len1162drivers/scsi/seagate.ctransfered -= len;
len1167drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1175drivers/scsi/seagate.cSCint->transfersize, len, data);
len1197drivers/scsi/seagate.clen -= transfersize;
len1207drivers/scsi/seagate.chostno, len, data);
len1215drivers/scsi/seagate.cprintk("scsi%d: transfered += %d\n", hostno, len);
len1216drivers/scsi/seagate.ctransfered += len;  /* Assume we'll transfer it all, then
len1271drivers/scsi/seagate.c"=D" (data), "=c" (len) :
len1273drivers/scsi/seagate.c"0" (data), "1" (len) :
len1278drivers/scsi/seagate.cprintk("scsi%d: transfered -= %d\n", hostno, len);
len1279drivers/scsi/seagate.ctransfered -= len;    /* Since we assumed all of Len got 
len1284drivers/scsi/seagate.cif (!len && nobuffs) {
len1287drivers/scsi/seagate.clen = buffer->length;
len1291drivers/scsi/seagate.chostno, len, data);
len1358drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1390drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1401drivers/scsi/seagate.clen=current_bufflen;
len315drivers/scsi/t128.cint len) {
len318drivers/scsi/t128.cregister i = len;
len359drivers/scsi/t128.cint len) {
len362drivers/scsi/t128.cregister i = len;
len205drivers/scsi/wd7000.cunsigned len;           /* length of string */
len321drivers/scsi/wd7000.cunchar len[3];
len377drivers/scsi/wd7000.cunchar len[3];                /* command buffer length */
len419drivers/scsi/wd7000.cunchar len[3];                /* buffer length */
len435drivers/scsi/wd7000.cunchar len[3];                /* parms buffer length */
len567drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
len570drivers/scsi/wd7000.cwhile (len--)  {
len580drivers/scsi/wd7000.cprintk("wd7000 command_out: WAIT failed(%d)\n", len+1);
len934drivers/scsi/wd7000.cany2scsi(sgb[i].len, sg[i].length);
len964drivers/scsi/wd7000.cany2scsi(icb.len, sizeof(buf));
len1115drivers/scsi/wd7000.cif (!memcmp(cfg->bios+sig->ofs, sig->sig, sig->len))  {
len197drivers/sound/configure.cint             len;
len199drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len209drivers/sound/configure.cif (len < 2)      /*
len214drivers/sound/configure.cansw[len - 1] = 0;
len226drivers/sound/configure.cint             len, num;
len230drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len240drivers/sound/configure.cif (len < 2)      /*
len245drivers/sound/configure.cansw[len - 1] = 0;
len131drivers/sound/dev_table.hsnd_rw_buf *userbuf, int useroffs, int len);
len298drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len)
len363drivers/sound/dmabuf.c*len = dmap->fragment_size - dmap->counts[dmap->qhead];
len491drivers/sound/dmabuf.cint             len, max, tmp;
len503drivers/sound/dmabuf.clen = dmap->qlen;
len508drivers/sound/dmabuf.cif (tmp & len)
len512drivers/sound/dmabuf.clen += tmp;
len515drivers/sound/dmabuf.cif (len >= max)
len897drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len)
len461drivers/sound/gus_wave.cif (position < samples[sample_no].len)
len1290drivers/sound/gus_wave.c((sample_ptrs[sample] + samples[sample].len) >> 18))
len1317drivers/sound/gus_wave.cgus_write_addr (0x0a, sample_ptrs[sample] + samples[sample].len -
len1350drivers/sound/gus_wave.cgus_write_addr (0x04, sample_ptrs[sample] + samples[sample].len - 1,
len1518drivers/sound/gus_wave.cif (count < patch.len)
len1521drivers/sound/gus_wave.ccount, (int) patch.len);
len1522drivers/sound/gus_wave.cpatch.len = count;
len1525drivers/sound/gus_wave.cif (patch.len <= 0 || patch.len > gus_mem_size)
len1527drivers/sound/gus_wave.cprintk ("GUS: Invalid sample length %d\n", (int) patch.len);
len1533drivers/sound/gus_wave.cif (patch.loop_start < 0 || patch.loop_start >= patch.len)
len1539drivers/sound/gus_wave.cif (patch.loop_end < patch.loop_start || patch.loop_end > patch.len)
len1555drivers/sound/gus_wave.cif (patch.len >= GUS_BANK_SIZE)
len1557drivers/sound/gus_wave.cprintk ("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
len1562drivers/sound/gus_wave.c((free_mem_ptr + patch.len) / GUS_BANK_SIZE))
len1567drivers/sound/gus_wave.cif ((tmp_mem + patch.len) > gus_mem_size)
len1574drivers/sound/gus_wave.cif ((free_mem_ptr + patch.len) > gus_mem_size)
len1599drivers/sound/gus_wave.cleft = patch.len;
len1712drivers/sound/gus_wave.cfree_mem_ptr += patch.len;
len2335drivers/sound/gus_wave.csnd_rw_buf * userbuf, int useroffs, int len)
len2339drivers/sound/gus_wave.cCOPY_FROM_USER (&localbuf[localoffs], userbuf, useroffs, len);
len2348drivers/sound/gus_wave.clen /= 2;
len2353drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2368drivers/sound/gus_wave.clen /= 4;
len2374drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2501drivers/sound/gus_wave.cif (pat->len > samples[ptr].len)  /* Cannot expand sample */
len2524drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2527drivers/sound/gus_wave.cn = samples[sample].len - offs;  /* Num of bytes left */
len2565drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2570drivers/sound/gus_wave.cn = samples[sample].len - offs;  /*
len331drivers/sound/midi_synth.cif (count < sysex.len)
len334drivers/sound/midi_synth.ccount, (int) sysex.len);
len335drivers/sound/midi_synth.csysex.len = count;
len338drivers/sound/midi_synth.cleft = sysex.len;
len45drivers/sound/midibuf.cint             len, head, tail;
len67drivers/sound/midibuf.c#define DATA_AVAIL(q) (q->len)
len68drivers/sound/midibuf.c#define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)
len76drivers/sound/midibuf.cq->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
len86drivers/sound/midibuf.cq->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
len151drivers/sound/midibuf.cmidi_out_buf[dev]->len--;
len212drivers/sound/midibuf.cmidi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;
len225drivers/sound/midibuf.cmidi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
len147drivers/sound/mpu401.cint len; \
len150drivers/sound/mpu401.cseq_input_event(obuf, len); \
len154drivers/sound/mpu401.c#define _SEQ_ADVBUF(x) len=x
len149drivers/sound/sequencer.cseq_copy_to_input (unsigned char *event, int len)
len157drivers/sound/sequencer.cif (len != 4 && len != 8)
len159drivers/sound/sequencer.cif ((seq_mode == SEQ_1) != (len == 4))
len166drivers/sound/sequencer.cmemcpy (&iqueue[iqtail * IEV_SZ], event, len);
len204drivers/sound/sequencer.cseq_input_event (unsigned char *event, int len)
len227drivers/sound/sequencer.cseq_copy_to_input (event, len);
len8drivers/sound/sound_calls.hint DMAbuf_getrdbuffer(int dev, char **buf, int *len);
len48drivers/sound/sound_calls.hvoid seq_input_event(unsigned char *event, int len);
len49drivers/sound/sound_calls.hvoid seq_copy_to_input (unsigned char *event, int len);
len162fs/binfmt_elf.cunsigned int len;
len232fs/binfmt_elf.clen = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
len235fs/binfmt_elf.cif (last_bss > len)
len236fs/binfmt_elf.cdo_mmap(NULL, len, last_bss-len,
len658fs/binfmt_elf.cunsigned int len;
len669fs/binfmt_elf.clen = 0;
len756fs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len758fs/binfmt_elf.cif (bss > len)
len759fs/binfmt_elf.cdo_mmap(NULL, len, bss-len,
len105fs/dcache.cstatic inline unsigned long namehash(const char * name, int len)
len107fs/dcache.creturn len * *(unsigned char *) name;
len133fs/dcache.cstatic struct dir_cache_entry * find_entry(struct inode * dir, const char * name, int len, struct hash_list * hash)
len144fs/dcache.cif (de->name_len != len)
len146fs/dcache.cif (memcmp(de->name, name, len))
len172fs/dcache.cint dcache_lookup(struct inode * dir, const char * name, int len, unsigned long * ino)
len177fs/dcache.cif (len > DCACHE_NAME_LEN)
len179fs/dcache.chash = hash_table + hash_fn(dir->i_dev, dir->i_ino, namehash(name,len));
len180fs/dcache.cde = find_entry(dir, name, len, hash);
len188fs/dcache.cvoid dcache_add(struct inode * dir, const char * name, int len, unsigned long ino)
len193fs/dcache.cif (len > DCACHE_NAME_LEN)
len195fs/dcache.chash = hash_table + hash_fn(dir->i_dev, dir->i_ino, namehash(name,len));
len196fs/dcache.cif ((de = find_entry(dir, name, len, hash)) != NULL) {
len208fs/dcache.cde->name_len = len;
len209fs/dcache.cmemcpy(de->name, name, 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;
len388fs/exec.cint len, offset = 0;
len404fs/exec.clen=0;    /* remember zero-padding */
len406fs/exec.clen++;
len408fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
len412fs/exec.cwhile (len) {
len413fs/exec.c--p; --tmp; --len;
len863fs/exec.cunsigned int len;
len903fs/exec.clen = PAGE_ALIGN(ex.a_text + ex.a_data);
len905fs/exec.cif (bss > len)
len906fs/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)
len58fs/ext/namei.cif (!de || !de->inode || len > EXT_NAME_LEN)
len61fs/ext/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len63fs/ext/namei.cif (len != de->name_len)
len65fs/ext/namei.creturn !memcmp(name, de->name, len);
len149fs/ext/namei.cint ext_lookup(struct inode * dir,const char * name, int len,
len163fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
len302fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
len320fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len336fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len344fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len379fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len395fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
len401fs/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);
len577fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
len586fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len620fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
len650fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len659fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len675fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len690fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len697fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len35fs/ext2/balloc.c#define in_range(b, first, len)    ((b) >= (first) && (b) <= (first) + (len) - 1)
len43fs/ext2/namei.cstatic int ext2_match (int len, const char * const name,
len46fs/ext2/namei.cif (!de || !de->inode || len > EXT2_NAME_LEN)
len51fs/ext2/namei.cif (!len && de->name_len == 1 && (de->name[0] == '.') &&
len54fs/ext2/namei.cif (len != de->name_len)
len56fs/ext2/namei.creturn !memcmp(name, de->name, len);
len162fs/ext2/namei.cint ext2_lookup (struct inode * dir, const char * name, int len,
len176fs/ext2/namei.cif (dcache_lookup(dir, name, len, &ino)) {
len189fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
len191fs/ext2/namei.cdcache_add(dir, name, len, 0);
len196fs/ext2/namei.cdcache_add(dir, name, len, ino);
len364fs/ext2/namei.cint ext2_create (struct inode * dir,const char * name, int len, int mode,
len383fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len405fs/ext2/namei.cint ext2_mknod (struct inode * dir, const char * name, int len, int mode,
len415fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len447fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len469fs/ext2/namei.cint ext2_mkdir (struct inode * dir, const char * name, int len, int mode)
len478fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len521fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len599fs/ext2/namei.cint ext2_rmdir (struct inode * dir, const char * name, int len)
len610fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len680fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
len692fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len741fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
len790fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len799fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len822fs/ext2/namei.cconst char * name, int len)
len843fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len850fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len361fs/hpfs/hpfs.hunsigned char len, name[15];    /* true length, truncated name */
len238fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len);
len246fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len256fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
len258fs/hpfs/hpfs_fs.cunsigned len);
len532fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len)
len535fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
len947fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
len954fs/hpfs/hpfs_fs.cwhile (len--) {
len957fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
len979fs/hpfs/hpfs_fs.cunsigned len)
len983fs/hpfs/hpfs_fs.cwhile (len--) {
len985fs/hpfs/hpfs_fs.cif (c == '\r' && (len == 0 || *in == '\n'));
len1104fs/hpfs/hpfs_fs.cstatic int hpfs_lookup(struct inode *dir, const char *name, int len,
len1125fs/hpfs/hpfs_fs.cif (name[0] == '.' && len == 1)
len1127fs/hpfs/hpfs_fs.celse if (name[0] == '.' && name[1] == '.' && len == 2)
len1132fs/hpfs/hpfs_fs.cde = map_dirent(dir, dir->i_hpfs_dno, name, len, &qbh);
len1231fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len1260fs/hpfs/hpfs_fs.cl = len < de->namelen ? len : de->namelen;
len1267fs/hpfs/hpfs_fs.ct = len - de->namelen;
len1284fs/hpfs/hpfs_fs.cname, len, qbh);
len27fs/isofs/namei.cstatic int isofs_match(int len,const char * name, char * compare, int dlen)
len36fs/isofs/namei.cif (!len)
len45fs/isofs/namei.cif (len <= 2) printk("Match: %d %d %s %d %d \n",len,dlen,compare,de->name[0], dlen);
len48fs/isofs/namei.cif (dlen != len)
len50fs/isofs/namei.creturn !memcmp(name, compare, len);
len219fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
len226fs/isofs/namei.cprintk("lookup: %x %d\n",dir->i_ino, len);
len239fs/isofs/namei.cif (dcache_lookup(dir, name, len, &ino)) ino_back = dir->i_ino;
len242fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
len247fs/isofs/namei.cdcache_add(dir, name, len, ino);
len83fs/isofs/rock.clen = cont_size; \
len99fs/isofs/rock.cint len;
len114fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len120fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len122fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len124fs/isofs/rock.cchr += rr->len; 
len125fs/isofs/rock.clen -= rr->len;
len172fs/isofs/rock.cint len;
len180fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len186fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len188fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len190fs/isofs/rock.cchr += rr->len; 
len191fs/isofs/rock.clen -= rr->len;
len221fs/isofs/rock.cif((strlen(retname) + rr->len - 5) >= 254) {
len225fs/isofs/rock.cstrncat(retname, rr->u.NM.name, rr->len - 5);
len226fs/isofs/rock.cretnamlen += rr->len - 5;
len255fs/isofs/rock.cint len;
len261fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len269fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len271fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len273fs/isofs/rock.cchr += rr->len; 
len274fs/isofs/rock.clen -= rr->len;
len323fs/isofs/rock.cslen = rr->len - 5;
len330fs/isofs/rock.cinode->i_size += slp->len;
len345fs/isofs/rock.cslen -= slp->len + 2;
len346fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len403fs/isofs/rock.cint len;
len445fs/isofs/rock.cSETUP_ROCK_RIDGE(raw_inode, chr, len);
len448fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len451fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len453fs/isofs/rock.cchr += rr->len; 
len454fs/isofs/rock.clen -= rr->len;
len466fs/isofs/rock.cslen = rr->len - 5;
len477fs/isofs/rock.cstrncat(rpnt,slp->text, slp->len);
len492fs/isofs/rock.cslen -= slp->len + 2;
len493fs/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)
len28fs/minix/namei.cif (len < maxlen && buffer[len])
len30fs/minix/namei.creturn !memcmp(name, buffer, len);
len40fs/minix/namei.cstatic int minix_match(int len, const char * name,
len48fs/minix/namei.cif (!de->inode || len > info->s_namelen)
len51fs/minix/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len53fs/minix/namei.creturn namecompare(len,info->s_namelen,name,de->name);
len107fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
len121fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
len210fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
len229fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
len245fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len254fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len286fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len302fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
len315fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len353fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len428fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
len436fs/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);
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);
len37fs/msdos/namei.cstatic int msdos_format_name(char conv,const char *name,int len,char *res,
len45fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len48fs/msdos/namei.cwhile (len--) *res++ = '.';
len53fs/msdos/namei.cfor (walk = res; len && walk-res < 8; walk++) {
len55fs/msdos/namei.clen--;
len65fs/msdos/namei.cif (conv == 's' && len && c != '.') {
len67fs/msdos/namei.clen--;
len70fs/msdos/namei.cwhile (c != '.' && len--) c = *name++;
len73fs/msdos/namei.cwhile (len > 0 && walk-res < MSDOS_NAME) {
len75fs/msdos/namei.clen--;
len86fs/msdos/namei.cif (conv == 's' && len) return -EINVAL;
len97fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
len103fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len109fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
len127fs/msdos/namei.cif (len == 1 && name[0] == '.') {
len131fs/msdos/namei.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len139fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
len213fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
len223fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len262fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
len271fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len313fs/msdos/namei.cif (msdos_rmdir(dir,name,len) < 0)
len346fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
len357fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len359fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
len387fs/msdos/namei.cint len,
len398fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
len421fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
len423fs/msdos/namei.creturn msdos_unlinkx (dir,name,len,1);
len428fs/msdos/namei.cint msdos_unlink_umsdos(struct inode *dir,const char *name,int len)
len430fs/msdos/namei.creturn msdos_unlinkx (dir,name,len,0);
len157fs/namei.cint lookup(struct inode * dir,const char * name, int len,
len168fs/namei.cif (len==2 && name[0] == '.' && name[1] == '.') {
len189fs/namei.cif (!len) {
len193fs/namei.creturn dir->i_op->lookup(dir,name,len,result);
len224fs/namei.cint len,error;
len240fs/namei.cfor(len=0;(c = *(pathname++))&&(c != '/');len++)
len245fs/namei.cerror = lookup(base,thisname,len,&inode);
len259fs/namei.c*namelen = len;
len27fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
len29fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len31fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
len32fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
len33fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
len34fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
len37fs/nfs/dir.cconst char *name, int len);
len38fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
len290fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
len295fs/nfs/dir.cchar name[len > NFS_MAXNAMLEN? 1 : len+1];
len304fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len308fs/nfs/dir.cmemcpy(name,__name,len);
len309fs/nfs/dir.cname[len] = '\0';
len310fs/nfs/dir.cif (len == 1 && name[0] == '.') { /* cheat for "." */
len331fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len345fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len366fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
len379fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len398fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
len410fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len425fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
len434fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len445fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
len454fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len465fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
len476fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len494fs/nfs/dir.cconst char *name, int len)
len510fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len68fs/nfs/file.cint    len;    /* size of data */
len121fs/nfs/file.c&& (cache[i].file_pos + cache[i].len >= pos + count)
len179fs/nfs/file.ccache[tail].len = result;
len97fs/nfs/proc.c#define QUADLEN(len) (((len) + 3) >> 2)
len113fs/nfs/proc.cint len = strlen(string);
len114fs/nfs/proc.cint quadlen = QUADLEN(len);
len117fs/nfs/proc.c*p++ = htonl(len);
len118fs/nfs/proc.cmemcpy(p, string, len);
len124fs/nfs/proc.cunsigned int len = ntohl(*p++);
len125fs/nfs/proc.cif (len > maxlen)
len127fs/nfs/proc.cmemcpy(string, p, len);
len128fs/nfs/proc.cstring[len] = '\0';
len129fs/nfs/proc.creturn p + QUADLEN(len);
len132fs/nfs/proc.cstatic inline int *xdr_decode_string2(int *p, char **string, unsigned int *len,
len135fs/nfs/proc.c*len = ntohl(*p++);
len136fs/nfs/proc.cif (*len > maxlen)
len139fs/nfs/proc.creturn p + QUADLEN(*len);
len143fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
len145fs/nfs/proc.cint quadlen = QUADLEN(len);
len148fs/nfs/proc.c*p++ = htonl(len);
len149fs/nfs/proc.cmemcpy_fromfs(p, data, len);
len156fs/nfs/proc.cunsigned len = *lenp = ntohl(*p++);
len157fs/nfs/proc.cif (len > maxlen)
len160fs/nfs/proc.cmemcpy_tofs(data, p, len);
len162fs/nfs/proc.cmemcpy(data, p, len);
len163fs/nfs/proc.creturn p + QUADLEN(len);
len341fs/nfs/proc.cint **p0, char **string, unsigned int *len, unsigned int maxlen)
len357fs/nfs/proc.cif (!(p = xdr_decode_string2(p, string, len, maxlen))) {
len381fs/nfs/proc.cint len;
len400fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
len405fs/nfs/proc.cstatus = len;
len406fs/nfs/proc.cPRINTK("NFS reply read %d\n", len);
len59fs/nfs/sock.cint len;
len76fs/nfs/sock.clen = ((char *) end) - ((char *) start);
len104fs/nfs/sock.cresult = sock->ops->send(sock, (void *) start, len, 0, 0);
len50fs/nfs/symlink.cunsigned int len;
len73fs/nfs/symlink.c&res, &len, NFS_MAXPATHLEN);
len83fs/nfs/symlink.cmemcpy(res2, res, len);
len84fs/nfs/symlink.cres2[len] = '\0';
len97fs/nfs/symlink.cunsigned int len;
len107fs/nfs/symlink.c&res, &len, buflen);
len110fs/nfs/symlink.cmemcpy_tofs(buffer, res, len);
len111fs/nfs/symlink.cput_fs_byte('\0', buffer + len);
len112fs/nfs/symlink.cerror = len;
len175fs/proc/array.cint i, len;
len180fs/proc/array.clen = sprintf(buffer,
len200fs/proc/array.clen += sprintf(buffer + len, " %u", kstat.interrupts[i]);
len201fs/proc/array.clen += sprintf(buffer + len,
len206fs/proc/array.creturn len;
len70fs/proc/base.cint proc_match(int len,const char * name,struct proc_dir_entry * de)
len75fs/proc/base.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len77fs/proc/base.cif (de->namelen != len)
len79fs/proc/base.creturn !memcmp(name, de->name, len);
len82fs/proc/base.cstatic int proc_lookupbase(struct inode * dir,const char * name, int len,
len98fs/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,
len72fs/proc/fd.cif (!len || (name[0] == '.' && (len == 1 ||
len73fs/proc/fd.c(name[1] == '.' && len == 2)))) {
len74fs/proc/fd.cif (len < 2) {
len87fs/proc/fd.cwhile (len-- > 0) {
len152fs/proc/net.cstatic int proc_lookupnet(struct inode * dir,const char * name, int len,
len165fs/proc/net.cif (!proc_match(len, name, de))
len82fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
len96fs/proc/root.cwhile (i-- > 0 && !proc_match(len,name,root_dir+i))
len108fs/proc/root.cwhile (len-- > 0) {
len99fs/super.cint err, len;
len108fs/super.clen = strlen(tmp->name) + 1;
len109fs/super.cerr = verify_area(VERIFY_WRITE, buf, len);
len112fs/super.cmemcpy_tofs(buf, tmp->name, len);
len157fs/super.cint len = 0;
len161fs/super.cwhile (tmp && len < PAGE_SIZE - 80) {
len162fs/super.clen += sprintf(buf+len, "%s\t%s\n",
len167fs/super.creturn len;
len25fs/sysv/namei.cstatic inline int namecompare(int len, int maxlen,
len28fs/sysv/namei.cif (len > maxlen)
len30fs/sysv/namei.cif (len < maxlen && buffer[len])
len32fs/sysv/namei.creturn !memcmp(name, buffer, len);
len42fs/sysv/namei.cstatic int sysv_match(int len, const char * name, struct sysv_dir_entry * de)
len44fs/sysv/namei.cif (!de->inode || len > SYSV_NAMELEN)
len47fs/sysv/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len49fs/sysv/namei.creturn namecompare(len,SYSV_NAMELEN,name,de->name);
len103fs/sysv/namei.cint sysv_lookup(struct inode * dir,const char * name, int len,
len117fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
len203fs/sysv/namei.cint sysv_create(struct inode * dir,const char * name, int len, int mode,
len222fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
len238fs/sysv/namei.cint sysv_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len247fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len279fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len295fs/sysv/namei.cint sysv_mkdir(struct inode * dir, const char * name, int len, int mode)
len306fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len344fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len420fs/sysv/namei.cint sysv_rmdir(struct inode * dir, const char * name, int len)
len428fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len476fs/sysv/namei.cint sysv_unlink(struct inode * dir, const char * name, int len)
len486fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len529fs/sysv/namei.cint sysv_symlink(struct inode * dir, const char * name, int len, const char * symname)
len564fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len573fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
len589fs/sysv/namei.cint sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len605fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len612fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len158fs/umsdos/dir.c,info.fake.len,&inode);
len484fs/umsdos/dir.cint len)
len494fs/umsdos/dir.c&& len == 3
len504fs/umsdos/dir.cint len,
len511fs/umsdos/dir.cif (len == 1 && name[0] == '.'){
len515fs/umsdos/dir.c}else if (len == 2 && name[0] == '.' && name[1] == '.'){
len547fs/umsdos/dir.c}else if (umsdos_is_pseudodos(dir,name,len)){
len557fs/umsdos/dir.cret = umsdos_parse (name,len,&info);
len560fs/umsdos/dir.c,info.fake.len));
len572fs/umsdos/dir.cret = umsdos_real_lookup (dir,info.fake.fname,info.fake.len,result);
len613fs/umsdos/dir.cint len,
len616fs/umsdos/dir.creturn umsdos_lookup_x(dir,name,len,result,0);
len645fs/umsdos/dir.cint len;
len647fs/umsdos/dir.clen = (int)(pt - start);
len651fs/umsdos/dir.cret = msdos_lookup(dir,start,len,result);
len653fs/umsdos/dir.cret = umsdos_lookup_x(dir,start,len,result,1);
len77fs/umsdos/inode.cint len,
len82fs/umsdos/inode.cret = msdos_lookup (dir,name,len,result);
len113fs/umsdos/ioctl.c,info.fake.fname,info.fake.len+1);
len73fs/umsdos/mangle.cchar *pt = info->fake.fname + info->fake.len;
len98fs/umsdos/mangle.cinfo->fake.len += 4;
len107fs/umsdos/mangle.cint umsdos_evalrecsize (int len)
len110fs/umsdos/mangle.cint nbrec = 1+((len-1+(dirent.name-(char*)&dirent))
len119fs/umsdos/mangle.cint umsdos_evalrecsize_old (int len)
len122fs/umsdos/mangle.cint size = len + (dirent.name-(char*)&dirent);
len135fs/umsdos/mangle.cint len,
len144fs/umsdos/mangle.cif (len > UMSDOS_MAXNAME) len = UMSDOS_MAXNAME;
len152fs/umsdos/mangle.cint msdos_len = len;
len191fs/umsdos/mangle.cif (len<=(8+1+3)){
len193fs/umsdos/mangle.cconst char *endpt = fname + len;
len254fs/umsdos/mangle.c|| (firstpt == NULL && len > 8)
len255fs/umsdos/mangle.c|| (len == UMSDOS_EMD_NAMELEN
len303fs/umsdos/mangle.cbase_len = firstpt != NULL ? (int)(firstpt - fname) : len;
len372fs/umsdos/mangle.cinfo->fake.len = msdos_len;
len374fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
len375fs/umsdos/mangle.cinfo->entry.name_len = len;
len381fs/umsdos/mangle.cinfo->recsize = umsdos_evalrecsize (len);
len161fs/umsdos/namei.cint len,
len165fs/umsdos/namei.cif (umsdos_is_pseudodos(dir,name,len)){
len176fs/umsdos/namei.c&& (len == 1 || (len == 2 && name[1] == '.'))){
len202fs/umsdos/namei.cint len,        /* Length of the name */
len210fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len213fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len229fs/umsdos/namei.cret = msdos_create (dir,info.fake.fname,info.fake.len
len337fs/umsdos/namei.cPRINTK (("ret %d %d ",ret,new_info.fake.len));
len343fs/umsdos/namei.c,old_info.fake.fname,old_info.fake.len
len345fs/umsdos/namei.c,new_info.fake.fname,new_info.fake.len);
len402fs/umsdos/namei.cint len,
len421fs/umsdos/namei.cret = umsdos_create_any (dir,name,len,mode,0,flags,&inode);
len424fs/umsdos/namei.cint len = strlen(symname);
len428fs/umsdos/namei.cret = umsdos_file_write_kmem (inode,&filp,(char*)symname,len);
len431fs/umsdos/namei.cif (ret != len){
len440fs/umsdos/namei.cUMSDOS_unlink (dir,name,len);
len455fs/umsdos/namei.cint len,
len458fs/umsdos/namei.creturn umsdos_symlink_x (dir,name,len,symname,S_IFLNK|0777,0);
len467fs/umsdos/namei.cint len)
len546fs/umsdos/namei.c}else if ((ret = umsdos_nevercreat(dir,name,len,-EPERM))==0){
len596fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len
len613fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len,path
len646fs/umsdos/namei.cint len,        /* Length of the name */
len651fs/umsdos/namei.creturn umsdos_create_any (dir,name,len,mode,0,0,result);
len659fs/umsdos/namei.cint len,
len662fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len665fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len682fs/umsdos/namei.cret = msdos_mkdir (dir,info.fake.fname,info.fake.len,mode);
len698fs/umsdos/namei.c,info.fake.len,&subdir);
len725fs/umsdos/namei.cint len,
len744fs/umsdos/namei.cint ret = umsdos_create_any (dir,name,len,mode,rdev,0,&inode);
len755fs/umsdos/namei.cint len)
len844fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len848fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&sdir);
len870fs/umsdos/namei.cumsdos_parse (name,len,&info);
len875fs/umsdos/namei.c,info.fake.len);
len900fs/umsdos/namei.cint len)
len903fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len905fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len926fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&inode);
len955fs/umsdos/namei.c,info.fake.len);
len35fs/umsdos/rdir.cint len = -1;
len37fs/umsdos/rdir.cif (ret > 0) len = get_fs_word(&dirent->d_reclen);
len38fs/umsdos/rdir.cif (len == 5
len50fs/umsdos/rdir.c&& len == 2
len68fs/umsdos/rdir.cint len,
len73fs/umsdos/rdir.c&& len == 2
len86fs/umsdos/rdir.cret = umsdos_real_lookup (dir,name,len,result);
len111fs/umsdos/rdir.cint len)
len128fs/umsdos/rdir.cif (umsdos_is_pseudodos(dir,name,len)){
len141fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
len145fs/umsdos/rdir.cret = UMSDOS_rlookup (dir,name,len,&sdir);
len164fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
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);
len536fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
len546fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len584fs/xiafs/namei.cint len, const char * symname)
len592fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
len619fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len636fs/xiafs/namei.cconst char * name, int len)
len651fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
len658fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len176include/asm-sparc/openprom.hvoid  (*pv_putstr)(char *str, int len);
len191include/asm-sparc/openprom.hvoid  (*v0_eval)(int len, char *str);
len300include/asm-sparc/openprom.hint  (*no_setprop)(int node, char*  name, char*  val, int len);
len146include/asm-sparc/string.hextern __inline__ char *strncat(char *dest, const char *src, size_t len)
len164include/asm-sparc/string.h"r" (dest), "r" (src), "r" (len), "r" (temp=0));
len33include/linux/etherdevice.hvoid *saddr, unsigned len,
len65include/linux/ext_fs.hextern int ext_lookup(struct inode * dir,const char * name, int len,
len67include/linux/ext_fs.hextern int ext_create(struct inode * dir,const char * name, int len, int mode,
len69include/linux/ext_fs.hextern int ext_mkdir(struct inode * dir, const char * name, int len, int mode);
len70include/linux/ext_fs.hextern int ext_rmdir(struct inode * dir, const char * name, int len);
len71include/linux/ext_fs.hextern int ext_unlink(struct inode * dir, const char * name, int len);
len72include/linux/ext_fs.hextern int ext_symlink(struct inode * inode, const char * name, int len,
len74include/linux/ext_fs.hextern int ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len75include/linux/ext_fs.hextern int ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len34include/linux/ip.h__u8  len;
len159include/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,
len84include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
len86include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
len88include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
len89include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
len90include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
len91include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
len93include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len94include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len202include/linux/mm.hextern int do_mmap(struct file * file, unsigned long addr, unsigned long len,
len146include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
len148include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
len150include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
len151include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
len152include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
len153include/linux/msdos_fs.hextern int msdos_unlink_umsdos(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,
len147include/linux/netdevice.hunsigned len,
len206include/linux/netdevice.hextern int    dev_rint(unsigned char *buff, long len, int flags,
len60include/linux/nfs_fs.hint **p0, char **string, unsigned int *len,
len8include/linux/pipe_fs_i.hunsigned int len;
len19include/linux/pipe_fs_i.h#define PIPE_LEN(inode)    ((inode).u.pipe_i.len)
len61include/linux/skbuff.hunsigned long     len;
len156include/linux/soundcard.hlong len;  /* Size of the wave data in bytes */
len215include/linux/soundcard.hlong len;  /* Size of the sysex data in bytes */
len795include/linux/soundcard.h#define SEQ_DEFINEBUF(len)    unsigned char _seqbuf[len]; int _seqbuflen = len;int _seqbufptr = 0
len799include/linux/soundcard.h#define _SEQ_NEEDBUF(len)    if ((_seqbufptr+(len)) > _seqbuflen) seqbuf_dump()
len800include/linux/soundcard.h#define _SEQ_ADVBUF(len)    _seqbufptr += len
len817include/linux/soundcard.h#define _SEQ_NEEDBUF(len)  /* empty */
len960include/linux/soundcard.h#define SEQ_WRPATCH(patchx, len)    {if (_seqbufptr) seqbuf_dump();\
len961include/linux/soundcard.hif (write(seqfd, (char*)(patchx), len)==-1) \
len963include/linux/soundcard.h#define SEQ_WRPATCH2(patchx, len)  (seqbuf_dump(), write(seqfd, (char*)(patchx), len))
len364include/linux/sysv_fs.hextern int sysv_lookup(struct inode * dir,const char * name, int len,
len366include/linux/sysv_fs.hextern int sysv_create(struct inode * dir,const char * name, int len, int mode,
len368include/linux/sysv_fs.hextern int sysv_mkdir(struct inode * dir, const char * name, int len, int mode);
len369include/linux/sysv_fs.hextern int sysv_rmdir(struct inode * dir, const char * name, int len);
len370include/linux/sysv_fs.hextern int sysv_unlink(struct inode * dir, const char * name, int len);
len371include/linux/sysv_fs.hextern int sysv_symlink(struct inode * inode, const char * name, int len,
len373include/linux/sysv_fs.hextern int sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len374include/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;
len19include/linux/umsdos_fs.hint  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, 
len343init/main.cint len = strlen(devnames[n]);
len344init/main.cif (!strncmp(line,devnames[n],len)) {
len345init/main.cROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,0);
len386init/main.cint len = 0;
len402init/main.cif (COMMAND_LINE_SIZE <= ++len)
len59kernel/dma.cint i, len = 0;
len63kernel/dma.clen += sprintf(buf+len, "%2d: %s\n",
len68kernel/dma.creturn len;
len54kernel/printk.casmlinkage int sys_syslog(int type, char * buf, int len)
len69kernel/printk.cif (!buf || len < 0)
len71kernel/printk.cif (!len)
len73kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len85kernel/printk.cwhile (log_size && i < len) {
len102kernel/printk.cif (!buf || len < 0)
len104kernel/printk.cif (!len)
len106kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len109kernel/printk.ccount = len;
len132kernel/printk.cif (len < 1 || len > 8)
len134kernel/printk.cconsole_loglevel = len;
len639kernel/sys.casmlinkage int sys_sethostname(char *name, int len)
len645kernel/sys.cif (len > __NEW_UTS_LEN)
len647kernel/sys.cfor (i=0; i < len; i++) {
len659kernel/sys.casmlinkage int sys_setdomainname(char *name, int len)
len665kernel/sys.cif (len > __NEW_UTS_LEN)
len667kernel/sys.cfor (i=0; i < len; i++) {
len136kernel/vsprintf.cint len;
len220kernel/vsprintf.clen = strlen(s);
len222kernel/vsprintf.cprecision = len;
len223kernel/vsprintf.celse if (len > precision)
len224kernel/vsprintf.clen = precision;
len227kernel/vsprintf.cwhile (len < field_width--)
len229kernel/vsprintf.cfor (i = 0; i < len; ++i)
len231kernel/vsprintf.cwhile (len < field_width--)
len136mm/filemap.cstatic void file_mmap_unmap(struct vm_area_struct *vma, unsigned long start, size_t len)
len139mm/filemap.cfile_mmap_sync(vma, start, len, MS_ASYNC);
len38mm/mmap.cint do_mmap(struct file * file, unsigned long addr, unsigned long len,
len44mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len47mm/mmap.cif (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
len51mm/mmap.cif (off + len < off)
len87mm/mmap.cif (len > TASK_SIZE || addr > TASK_SIZE - len)
len90mm/mmap.caddr = get_unmapped_area(len);
len118mm/mmap.cvma->vm_end = addr + len;
len138mm/mmap.cdo_munmap(addr, len);  /* Clear old maps */
len159mm/mmap.cunsigned long get_unmapped_area(unsigned long len)
len171mm/mmap.cif ((gap_start <= gap_end) && (gap_end - gap_start >= len))
len221mm/mmap.cunsigned long addr, size_t len)
len224mm/mmap.cunsigned long end = addr + len;
len285mm/mmap.casmlinkage int sys_munmap(unsigned long addr, size_t len)
len287mm/mmap.creturn do_munmap(addr, len);
len296mm/mmap.cint do_munmap(unsigned long addr, size_t len)
len300mm/mmap.cif ((addr & ~PAGE_MASK) || addr > TASK_SIZE || len > TASK_SIZE-addr)
len303mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len315mm/mmap.cunsigned long end = addr+len;
len347mm/mmap.cend = addr+len;
len357mm/mmap.cunmap_page_range(addr, len);
len175mm/mprotect.casmlinkage int sys_mprotect(unsigned long start, size_t len, unsigned long prot)
len183mm/mprotect.clen = (len + ~PAGE_MASK) & PAGE_MASK;
len184mm/mprotect.cend = start + len;
len481net/inet/af_inet.cstatic void def_callback2(struct sock *sk,int len)
len319net/inet/arp.cskb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
len328net/inet/arp.cdev->hard_header(skb->data,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
len930net/inet/arp.cint len=0;
len942net/inet/arp.clen+=size;
len970net/inet/arp.csize = sprintf(buffer+len,
len976net/inet/arp.csize += sprintf(buffer+len+size,
len981net/inet/arp.clen+=size;
len982net/inet/arp.cpos=begin+len;
len986net/inet/arp.clen=0;
len996net/inet/arp.clen-=(offset-begin);    /* Start slop */
len997net/inet/arp.cif(len>length)
len998net/inet/arp.clen=length;            /* Ending slop */
len999net/inet/arp.creturn len;
len490net/inet/dev.cint dev_rint(unsigned char *buff, long len, int flags, struct device *dev)
len498net/inet/dev.cif (dev == NULL || buff == NULL || len <= 0) 
len515net/inet/dev.cskb = alloc_skb(len, GFP_ATOMIC);
len530net/inet/dev.cleft = len;
len532net/inet/dev.clen2 = len;
len551net/inet/dev.cskb->len = len;
len661net/inet/dev.cskb->len -= skb->dev->hard_header_len;
len813net/inet/dev.cint len;
len824net/inet/dev.clen = ifc.ifc_len;
len832net/inet/dev.cerr=verify_area(VERIFY_WRITE,pos,len);
len855net/inet/dev.clen -= sizeof(struct ifreq);
len861net/inet/dev.cif (len < sizeof(struct ifreq)) 
len916net/inet/dev.cint len=0;
len928net/inet/dev.clen+=size;
len933net/inet/dev.csize = sprintf_stats(buffer+len, dev);
len934net/inet/dev.clen+=size;
len935net/inet/dev.cpos=begin+len;
len939net/inet/dev.clen=0;
len947net/inet/dev.clen-=(offset-begin);    /* Start slop */
len948net/inet/dev.cif(len>length)
len949net/inet/dev.clen=length;    /* Ending slop */
len950net/inet/dev.creturn len;
len85net/inet/eth.cvoid *daddr, void *saddr, unsigned len,
len98net/inet/eth.ceth->h_proto = htons(len);
len29net/inet/eth.hunsigned long saddr, unsigned len);
len103net/inet/icmp.cint len;
len192net/inet/icmp.clen = dev->hard_header_len + sizeof(struct iphdr) + sizeof(struct icmphdr) +
len195net/inet/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
len211net/inet/icmp.c&ndev, IPPROTO_ICMP, NULL, len,
len225net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
len384net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len395net/inet/icmp.csize = dev->hard_header_len + 64 + len;
len408net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len422net/inet/icmp.cskb2->len = offset + len;
len428net/inet/icmp.cmemcpy((char *) icmphr, (char *) icmph, len);
len432net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len451net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len460net/inet/icmp.cif (len != 20)
len464net/inet/icmp.clen);
len468net/inet/icmp.cif (len < 12)
len488net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev, IPPROTO_ICMP, opt, len, 
len502net/inet/icmp.cskb2->len = offset + 20;
len540net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len553net/inet/icmp.cunsigned long saddr, unsigned long daddr, int len,
len564net/inet/icmp.csize = dev->hard_header_len + 64 + len;
len579net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len593net/inet/icmp.cskb2->len = offset + len;
len607net/inet/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len622net/inet/icmp.cunsigned long daddr, unsigned short len,
len647net/inet/icmp.cif (ip_compute_csum((unsigned char *) icmph, len)) 
len691net/inet/icmp.cicmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
len699net/inet/icmp.cicmp_timestamp(icmph, skb1, dev, saddr, daddr, len, opt);
len707net/inet/icmp.cicmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
len715net/inet/icmp.cicmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
len32net/inet/icmp.hunsigned short len, unsigned long saddr,
len91net/inet/igmp.cskb->len=tmp+sizeof(*igh);
len193net/inet/igmp.cunsigned long daddr, unsigned short len, unsigned long saddr, int redo,
len194net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
len206net/inet/ip.cmac = dev->hard_header(skb->data, dev, ETH_P_IP, NULL, NULL, len, skb);
len226net/inet/ip.cstruct device **dev, int type, struct options *opt, int len, int tos, int ttl)
len304net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
len306net/inet/ip.clen -= tmp;
len358net/inet/ip.cint i, len = sizeof(struct iphdr);
len376net/inet/ip.cwhile (!done && len < iph->ihl*4) switch(*buff) {
len382net/inet/ip.clen++;
len396net/inet/ip.clen += 11;
len401net/inet/ip.clen += *buff;
len418net/inet/ip.clen += *buff;
len435net/inet/ip.clen += *buff;
len450net/inet/ip.clen += 4;
len457net/inet/ip.clen += *buff;
len459net/inet/ip.copt->tstamp.len = *buff / 4 - 1;
len466net/inet/ip.cfor (i = 0; i < opt->tstamp.len; i++) {
len534net/inet/ip.cunsigned short ip_compute_csum(unsigned char * buff, int len)
len539net/inet/ip.cif (len > 3)
len552net/inet/ip.c: "0" (sum), "c" (len >> 2) ,"1" (buff)
len555net/inet/ip.cif (len & 2)
len564net/inet/ip.cif (len & 1)
len626net/inet/ip.cfp->len = end - offset;
len800net/inet/ip.cqp->len = 0;
len834net/inet/ip.cif (qp->len == 0)
len868net/inet/ip.cint count, len;
len874net/inet/ip.clen = qp->maclen + qp->ihlen + qp->len;
len876net/inet/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL)
len885net/inet/ip.cskb->len = (len - qp->maclen);
len903net/inet/ip.cif(count+fp->len > skb->len)
len911net/inet/ip.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
len912net/inet/ip.ccount += fp->len;
len1008net/inet/ip.cqp->len = end;
len1048net/inet/ip.cnext->len -= i;        /* so reduce size of  */
len1056net/inet/ip.cif (next->len <= 0)
len1132net/inet/ip.cint left, mtu, hlen, len;
len1201net/inet/ip.clen = left;
len1203net/inet/ip.cif (len > mtu)
len1204net/inet/ip.clen = mtu;
len1207net/inet/ip.cif (len < left)
len1209net/inet/ip.clen/=8;
len1210net/inet/ip.clen*=8;
len1216net/inet/ip.cif ((skb2 = alloc_skb(len + hlen,GFP_ATOMIC)) == NULL)
len1231net/inet/ip.cskb2->len = len + hlen;
len1257net/inet/ip.cmemcpy(skb2->h.raw + hlen, ptr, len);
len1258net/inet/ip.cleft -= len;
len1273net/inet/ip.cptr += len;
len1274net/inet/ip.coffset += len;
len1420net/inet/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len, GFP_ATOMIC);
len1432net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
len1438net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
len1441net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
len1451net/inet/ip.cif(skb2->len > dev2->mtu + dev2->hard_header_len)
len1518net/inet/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0)
len1544net/inet/ip.cskb->len=ntohs(iph->tot_len);
len1771net/inet/ip.cint len=skb->len-old_dev->hard_header_len;
len1772net/inet/ip.cstruct sk_buff *newskb=alloc_skb(len+dev->hard_header_len, GFP_ATOMIC);
len1787net/inet/ip.cnewskb->len=len+dev->hard_header_len;
len1790net/inet/ip.cnewskb->ip_hdr=(struct iphdr *)(newskb->data+ip_send(newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr));
len1791net/inet/ip.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
len1844net/inet/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
len1867net/inet/ip.cif(skb->len > dev->mtu + dev->hard_header_len)
len2022net/inet/ip.cint len=0;
len2025net/inet/ip.clen=sprintf(buffer,"Device    : Multicast\n");  
len2033net/inet/ip.clen+=sprintf(buffer+len,"%-10s: %08lX\n", im->interface->name, im->multiaddr);
len2034net/inet/ip.cpos=begin+len;
len2037net/inet/ip.clen=0;
len2046net/inet/ip.clen-=(offset-begin);
len2047net/inet/ip.cif(len>length)
len2048net/inet/ip.clen=length;  
len2049net/inet/ip.creturn len;
len2355net/inet/ip.cint len;
len2380net/inet/ip.clen=strlen(sk->ip_mc_name);
len2381net/inet/ip.cerr=verify_area(VERIFY_WRITE, optval, len);
len2384net/inet/ip.cput_fs_long(len,(unsigned long *) optlen);
len2385net/inet/ip.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
len52net/inet/ip.hint    len;    /* length of this fragment    */
len63net/inet/ip.hint    len;    /* total length of original datagram  */
len84net/inet/ip.hstruct options *opt, int len,
len86net/inet/ip.hextern unsigned short  ip_compute_csum(unsigned char * buff, int len);
len712net/inet/ip_fw.cstruct ip_fw *check_ipfw_struct(struct ip_fw *frwl, int len)
len715net/inet/ip_fw.cif ( len != sizeof(struct ip_fw) )
len767net/inet/ip_fw.cint ip_acct_ctl(int stage, void *m, int len)
len785net/inet/ip_fw.cif (!(frwl=check_ipfw_struct(m,len)))
len812net/inet/ip_fw.cint ip_fw_ctl(int stage, void *m, int len)
len836net/inet/ip_fw.cif ( len < sizeof(struct iphdr) + 2 * sizeof(unsigned short) )
len840net/inet/ip_fw.clen,sizeof(struct ip) + 2 * sizeof(unsigned short));
len875net/inet/ip_fw.cfrwl=check_ipfw_struct(m,len);
len914net/inet/ip_fw.cint len=0;
len917net/inet/ip_fw.clen=sprintf(buffer,"Firewall Rules\n");  
len925net/inet/ip_fw.clen+=sprintf(buffer+len,"%08lX/%08lX->%08lX/%08lX %X ",
len929net/inet/ip_fw.clen+=sprintf(buffer+len,"%u %u %lu %lu ",
len931net/inet/ip_fw.clen+=sprintf(buffer+len,"%u %u %u %u %u %u %u %u %u %u\n",
len935net/inet/ip_fw.cpos=begin+len;
len938net/inet/ip_fw.clen=0;
len947net/inet/ip_fw.clen-=(offset-begin);
len948net/inet/ip_fw.cif(len>length)
len949net/inet/ip_fw.clen=length;  
len950net/inet/ip_fw.creturn len;
len149net/inet/ipx.cint len=0;
len155net/inet/ipx.clen += sprintf (buffer,"Type local_address             rem_address              tx_queue rx_queue st uid\n");
len158net/inet/ipx.clen += sprintf (buffer+len,"%02X   ", s->ipx_type);
len159net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%04X ", htonl(s->ipx_source_addr.net),
len163net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%02X%02X%02X%02X%02X%02X:%04X ", htonl(s->ipx_dest_addr.net),
len167net/inet/ipx.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
len168net/inet/ipx.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
len171net/inet/ipx.cpos=begin+len;
len175net/inet/ipx.clen=0;      /* Keep dumping into the buffer start */
len184net/inet/ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
len185net/inet/ipx.cif(len>length)
len186net/inet/ipx.clen=length;    /* Remove unwanted tail data from length */
len188net/inet/ipx.creturn len;
len439net/inet/ipx.cint len=0;
len443net/inet/ipx.clen += sprintf (buffer,"Net      Router                Flags Dev\n");
len446net/inet/ipx.clen += sprintf (buffer+len,"%08lX %08lX:%02X%02X%02X%02X%02X%02X %02X    %s\n", ntohl(rt->net),
len449net/inet/ipx.cpos=begin+len;
len452net/inet/ipx.clen=0;
len459net/inet/ipx.clen-=(offset-begin);
len460net/inet/ipx.cif(len>length)
len461net/inet/ipx.clen=length;
len462net/inet/ipx.creturn len;
len568net/inet/ipx.cstatic void def_callback2(struct sock *sk, int len)
len889net/inet/ipx.cincoming_size = skb->len - ntohs(ipx->ipx_pktsize);
len904net/inet/ipx.cskb2->len=ntohs(ipx->ipx_pktsize) + outgoing_size;
len962net/inet/ipx.cstatic int ipx_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len1029net/inet/ipx.csize=sizeof(ipx_packet)+len;  /* For mac headers */
len1065net/inet/ipx.cskb->len=size;
len1092net/inet/ipx.cipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
len1103net/inet/ipx.cmemcpy_fromfs((char *)(ipx+1),ubuf,len);
len1122net/inet/ipx.cskb2=alloc_skb(skb->len, GFP_ATOMIC);
len1126net/inet/ipx.cskb2->len=skb->len;
len1130net/inet/ipx.cmemcpy(skb2->data, skb->data, skb->len);
len1135net/inet/ipx.creturn len;
len1240net/inet/ipx.camount=skb->len;
len43net/inet/p8022.cunsigned long  len = skb->len;
len47net/inet/p8022.cdev->hard_header(skb->data, dev, len - hard_len,
len48net/inet/p8022.cdest_node, NULL, len - hard_len, skb);
len12net/inet/p8023.cunsigned long  len = skb->len;
len15net/inet/p8023.cdev->hard_header(skb->data, dev, len - hard_len,
len16net/inet/p8023.cdest_node, NULL, len - hard_len, skb);
len89net/inet/packet.cskb->len += dev->hard_header_len;
len121net/inet/packet.csk->data_ready(sk,skb->len);
len139net/inet/packet.cstatic int packet_sendto(struct sock *sk, unsigned char *from, int len,
len182net/inet/packet.cif(len>dev->mtu+dev->hard_header_len)
len185net/inet/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
len203net/inet/packet.cmemcpy_fromfs(skb->data, from, len);
len204net/inet/packet.cskb->len = len;
len215net/inet/packet.creturn(len);
len224net/inet/packet.cint len, int noblock,  unsigned flags)
len226net/inet/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
len283net/inet/packet.cint packet_recvfrom(struct sock *sk, unsigned char *to, int len,
len328net/inet/packet.ctruesize = skb->len;
len329net/inet/packet.ccopied = min(len, truesize);
len365net/inet/packet.cint len, int noblock, unsigned flags)
len367net/inet/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len12net/inet/pe2.cunsigned long  len = skb->len;
len16net/inet/pe2.cdest_node, NULL, len - hard_len, skb);
len65net/inet/proc.cint len=0;
len70net/inet/proc.clen+=sprintf(buffer, "sl  local_address rem_address   st tx_queue rx_queue tr tm->when uid\n");
len93net/inet/proc.clen+=sprintf(buffer+len, "%2d: %08lX:%04X %08lX:%04X %02X %08lX:%08lX %02X:%08lX %08X %d %d\n",
len108net/inet/proc.cpos=begin+len;
len111net/inet/proc.clen=0;
len123net/inet/proc.clen-=(offset-begin);
len124net/inet/proc.cif(len>length)
len125net/inet/proc.clen=length;
len126net/inet/proc.creturn len;
len156net/inet/proc.cint len;
len161net/inet/proc.clen = sprintf (buffer,
len175net/inet/proc.clen += sprintf (buffer + len,
len192net/inet/proc.clen += sprintf (buffer + len,
len202net/inet/proc.clen += sprintf (buffer + len,
len212net/inet/proc.cif (offset >= len)
len218net/inet/proc.clen -= offset;
len219net/inet/proc.cif (len > length)
len220net/inet/proc.clen = length;
len221net/inet/proc.creturn len;
len33net/inet/protocol.hunsigned short len, unsigned long saddr,
len37net/inet/protocol.hunsigned short len, unsigned long saddr,
len428net/inet/rarp.cint len=0;
len439net/inet/rarp.clen+=size;
len446net/inet/rarp.clen+=size;
len458net/inet/rarp.csize = sprintf(buffer+len,
len469net/inet/rarp.clen+=size;
len470net/inet/rarp.cpos=begin+len;
len474net/inet/rarp.clen=0;
len484net/inet/rarp.clen-=(offset-begin);    /* Start slop */
len485net/inet/rarp.cif(len>length)
len486net/inet/rarp.clen=length;            /* Ending slop */
len487net/inet/rarp.creturn len;
len101net/inet/raw.cskb->len = ntohs(skb->ip_hdr->tot_len);
len127net/inet/raw.cint len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)
len173net/inet/raw.cskb=sock_alloc_send_skb(sk, len+sk->prot->max_header, noblock, &err);
len191net/inet/raw.cmemcpy_fromfs(skb->data + tmp, from, len);
len210net/inet/raw.cskb->len = tmp + len;
len214net/inet/raw.creturn(len);
len218net/inet/raw.cstatic int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len221net/inet/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
len242net/inet/raw.cint raw_recvfrom(struct sock *sk, unsigned char *to, int len,
len264net/inet/raw.ctruesize=skb->len;
len265net/inet/raw.ccopied = min(len, truesize);
len282net/inet/raw.cint raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags)
len284net/inet/raw.creturn(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len27net/inet/raw.hint len, int noblock, unsigned flags,
len30net/inet/raw.hint len, int noblock, unsigned flags);
len497net/inet/route.cint len=0;
len502net/inet/route.clen += sprintf(buffer,
len504net/inet/route.cpos=len;
len512net/inet/route.csize = sprintf(buffer+len, "%s\t%08lX\t%08lX\t%02X\t%d\t%lu\t%d\t%08lX\t%d\t%lu\n",
len516net/inet/route.clen+=size;
len520net/inet/route.clen=0;
len528net/inet/route.clen-=(offset-begin);
len529net/inet/route.cif(len>length)
len530net/inet/route.clen=length;
len531net/inet/route.creturn len;
len505net/inet/skbuff.cn->len=skb->len;
len519net/inet/sock.csk->data_ready(sk,skb->len);
len554net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
len205net/inet/sock.hint len, int nonblock, unsigned flags);
len207net/inet/sock.hint len, int nonblock, unsigned flags);
len209net/inet/sock.hunsigned char *from, int len, int noblock,
len213net/inet/sock.hunsigned char *from, int len, int noblock,
len220net/inet/sock.hstruct options *opt, int len, int tos, int ttl);
len232net/inet/sock.hunsigned short len, unsigned long saddr,
len400net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
len787net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
len950net/inet/tcp.cunsigned short tcp_check(struct tcphdr *th, int len,
len968net/inet/tcp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_TCP*256)
len1022net/inet/tcp.c: "0"(sum), "c"(len), "S"(th)
len1033net/inet/tcp.cunsigned long daddr, int len, struct sock *sk)
len1036net/inet/tcp.cth->check = tcp_check(th, len, saddr, daddr);
len1046net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
len1049net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
len1052net/inet/tcp.cskb, skb->data, th, skb->len);
len1183net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len1197net/inet/tcp.cbuff->len += tmp;
len1275net/inet/tcp.cint len, int nonblock, unsigned flags)
len1288net/inet/tcp.cwhile(len > 0) 
len1405net/inet/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
len1413net/inet/tcp.cmemcpy_fromfs(skb->data + skb->len, from, copy);
len1414net/inet/tcp.cskb->len += copy;
len1417net/inet/tcp.clen -= copy;
len1420net/inet/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
len1443net/inet/tcp.cif (copy > len)
len1444net/inet/tcp.ccopy = len;
len1519net/inet/tcp.cskb->len = 0;
len1541net/inet/tcp.cskb->len += tmp;
len1545net/inet/tcp.ctmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
len1560net/inet/tcp.cskb->len += tmp;
len1565net/inet/tcp.clen -= copy;
len1566net/inet/tcp.cskb->len += copy;
len1602net/inet/tcp.cint len, int nonblock, unsigned flags,
len1617net/inet/tcp.creturn tcp_write(sk, from, len, nonblock, flags);
len1650net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len1667net/inet/tcp.cbuff->len += tmp;
len1786net/inet/tcp.cunsigned char *to, int len, unsigned flags)
len1839net/inet/tcp.cint len, int nonblock, unsigned flags)
len1853net/inet/tcp.creturn tcp_read_urg(sk, nonblock, to, len, flags);
len1862net/inet/tcp.cwhile (len > 0) 
len1885net/inet/tcp.cif (offset < skb->len)
len1944net/inet/tcp.cused = skb->len - offset;
len1945net/inet/tcp.cif (len < used)
len1946net/inet/tcp.cused = len;
len1970net/inet/tcp.clen -= used;
len1975net/inet/tcp.cif (used + offset < skb->len)
len2064net/inet/tcp.cbuff->len = sizeof(*t1);
len2102net/inet/tcp.cbuff->len += tmp;
len2207net/inet/tcp.cbuff->len = sizeof(*t1);
len2228net/inet/tcp.cbuff->len += tmp;
len2547net/inet/tcp.cbuff->len = sizeof(struct tcphdr)+4;
len2577net/inet/tcp.cbuff->len += tmp;
len2744net/inet/tcp.cbuff->len = sizeof(*t1);
len2777net/inet/tcp.cbuff->len += tmp;
len2883net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
len2902net/inet/tcp.cextern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
len2952net/inet/tcp.cif (len != th->doff*4) 
len3445net/inet/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
len3532net/inet/tcp.cunsigned long saddr, unsigned short len)
len3541net/inet/tcp.cskb->len = len -(th->doff*4);
len3548net/inet/tcp.csk->bytes_rcv += skb->len;
len3550net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) 
len3575net/inet/tcp.cif(skb->len)  /* We don't care if its just an ack or
len3578net/inet/tcp.cnew_seq= th->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
len3656net/inet/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
len3691net/inet/tcp.cth->ack_seq = th->seq + skb->len;
len3891net/inet/tcp.cunsigned long saddr, unsigned long len)
len3914net/inet/tcp.cif (ptr >= len)
len4040net/inet/tcp.cbuff->len = 24;
len4067net/inet/tcp.cbuff->len += tmp;
len4150net/inet/tcp.cextern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
len4155net/inet/tcp.cnext_seq = len - 4*th->doff;
len4239net/inet/tcp.cunsigned long daddr, unsigned short len,
len4288net/inet/tcp.cif (tcp_check(th, len, saddr, daddr )) 
len4315net/inet/tcp.cskb->len = len;
len4437net/inet/tcp.cif(!tcp_ack(sk,th,saddr,len))
len4552net/inet/tcp.cif(!tcp_sequence(sk,th,len,opt,saddr,dev))
len4577net/inet/tcp.cif(th->ack && !tcp_ack(sk,th,saddr,len))
len4598net/inet/tcp.cif(tcp_urg(sk, th, saddr, len))
len4610net/inet/tcp.cif(tcp_data(skb,sk, saddr, len))
len4659net/inet/tcp.cbuff->len = sizeof(struct tcphdr);
len4675net/inet/tcp.cbuff->len += tmp;
len122net/inet/tcp.hunsigned short len, unsigned long saddr, int redo,
len129net/inet/tcp.hunsigned long daddr, int len, struct sock *sk);
len66net/inet/timer.cvoid reset_timer (struct sock *t, int timeout, unsigned long len)
len72net/inet/timer.cif ((int) len < 0)  /* prevent close to infinite timers. THEY _DO_ */
len73net/inet/timer.clen = 3;  /* happen (negative values ?) - don't ask me why ! -FB */
len75net/inet/timer.ct->timer.expires = len;
len83net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
len155net/inet/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr)
len163net/inet/udp.c: "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_UDP*256)
len166net/inet/udp.cif (len > 3) 
len175net/inet/udp.c: "0"(sum), "c"(len/4) ,"1"(uh)
len195net/inet/udp.cif ((len & 2) != 0) 
len209net/inet/udp.cif ((len & 1) != 0) 
len234net/inet/udp.cunsigned long daddr, int len, struct sock *sk)
len239net/inet/udp.cuh->check = udp_check(uh, len, saddr, daddr);
len252net/inet/udp.cunsigned char *from, int len, int rt)
len266net/inet/udp.csize = sk->prot->max_header + len;
len306net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
len314net/inet/udp.cuh->len = htons(len + sizeof(struct udphdr));
len323net/inet/udp.cmemcpy_fromfs(buff, from, len);
len329net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
len338net/inet/udp.creturn(len);
len342net/inet/udp.cstatic int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
len390net/inet/udp.ctmp = udp_send(sk, &sin, from, len, flags);
len401net/inet/udp.cstatic int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len404net/inet/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
len445net/inet/udp.camount = skb->len;
len467net/inet/udp.cint udp_recvfrom(struct sock *sk, unsigned char *to, int len,
len492net/inet/udp.ctruesize = skb->len;
len493net/inet/udp.ccopied = min(len, truesize);
len519net/inet/udp.cint udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
len522net/inet/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len568net/inet/udp.cunsigned long daddr, unsigned short len,
len590net/inet/udp.culen = ntohs(uh->len);
len592net/inet/udp.cif (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
len594net/inet/udp.cprintk("UDP: short packet: %d/%d\n", ulen, len);
len600net/inet/udp.cif (uh->check && udp_check(uh, len, saddr, daddr)) 
len609net/inet/udp.clen=ulen;
len632net/inet/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
len659net/inet/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
len662net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
len666net/inet/udp.cskb->len = len;
len680net/inet/udp.cskb->len = len - sizeof(*uh);  
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,
len143net/socket.cint len;
len148net/socket.clen=get_fs_long(ulen);
len149net/socket.cif(len>klen)
len150net/socket.clen=klen;
len151net/socket.cif(len<0 || len> MAX_SOCK_ADDR)
len153net/socket.cif(len)
len155net/socket.cif((err=verify_area(VERIFY_WRITE,uaddr,len))<0)
len157net/socket.cmemcpy_tofs(uaddr,kaddr,len);
len159net/socket.cput_fs_long(len,ulen);
len856net/socket.cint len;
len899net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
len900net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
len966net/socket.cint len;
len974net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
len977net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len991net/socket.cint len;
len999net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
len1002net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len1012net/socket.cstatic int sock_send(int fd, void * buff, int len, unsigned flags)
len1023net/socket.cif(len<0)
len1025net/socket.cerr=verify_area(VERIFY_READ, buff, len);
len1028net/socket.creturn(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
len1037net/socket.cstatic int sock_sendto(int fd, void * buff, int len, unsigned flags,
len1050net/socket.cif(len<0)
len1052net/socket.cerr=verify_area(VERIFY_READ,buff,len);
len1059net/socket.creturn(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
len1072net/socket.cstatic int sock_recv(int fd, void * buff, int len, unsigned flags)
len1084net/socket.cif(len<0)
len1086net/socket.cif(len==0)
len1088net/socket.cerr=verify_area(VERIFY_WRITE, buff, len);
len1092net/socket.creturn(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
len1101net/socket.cstatic int sock_recvfrom(int fd, void * buff, int len, unsigned flags,
len1113net/socket.cif(len<0)
len1115net/socket.cif(len==0)
len1118net/socket.cerr=verify_area(VERIFY_WRITE,buff,len);
len1122net/socket.clen=sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
len1125net/socket.cif(len<0)
len1126net/socket.creturn len;
len1130net/socket.creturn len;
len43net/unix/proc.cint len=0;
len50net/unix/proc.clen += sprintf(buffer, "Num RefCount Protocol Flags    Type St Path\n");
len63net/unix/proc.clen += sprintf(buffer+len, "%2d: %08X %08X %08lX %04X %02X", i,
len74net/unix/proc.clen += sprintf(buffer+len, " %s\n",
len79net/unix/proc.cbuffer[len++]='\n';
len82net/unix/proc.cpos=begin+len;
len85net/unix/proc.clen=0;
len96net/unix/proc.clen-=(offset-begin);
len97net/unix/proc.cif(len>length)
len98net/unix/proc.clen=length;
len99net/unix/proc.creturn len;
len80net/unix/sock.cstatic int unix_proto_send(struct socket *sock, void *buff, int len,
len82net/unix/sock.cstatic int unix_proto_recv(struct socket *sock, void *buff, int len,
len84net/unix/sock.cstatic int unix_proto_sendto(struct socket *sock, void *buff, int len,
len87net/unix/sock.cstatic int unix_proto_recvfrom(struct socket *sock, void *buff, int len,
len163net/unix/sock.cstatic int unix_proto_sendto(struct socket *sock, void *buff, int len, int nonblock, 
len169net/unix/sock.cstatic int unix_proto_recvfrom(struct socket *sock, void *buff, int len, int nonblock, 
len189net/unix/sock.cstatic int unix_proto_send(struct socket *sock, void *buff, int len, int nonblock,
len194net/unix/sock.creturn(unix_proto_write(sock, (char *) buff, len, nonblock));
len202net/unix/sock.cstatic int unix_proto_recv(struct socket *sock, void *buff, int len, int nonblock,
len207net/unix/sock.creturn(unix_proto_read(sock, (char *) buff, len, nonblock));
len585net/unix/sock.cint len;
len598net/unix/sock.clen = upd->sockaddr_len;
len599net/unix/sock.cmemcpy(usockaddr, &upd->sockaddr_un, len);
len600net/unix/sock.c*usockaddr_len=len;