taglinefilesource code
len93arch/alpha/kernel/irq.cint i, len = 0;
len99arch/alpha/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len104arch/alpha/kernel/irq.creturn len;
len156arch/alpha/kernel/osf_sys.casmlinkage unsigned long osf_mmap(unsigned long addr, unsigned long len,
len168arch/alpha/kernel/osf_sys.creturn do_mmap(file, addr, len, prot, flags, off);
len467arch/alpha/kernel/osf_sys.cunsigned len;
len474arch/alpha/kernel/osf_sys.clen = namelen;
len476arch/alpha/kernel/osf_sys.clen = 32;
len478arch/alpha/kernel/osf_sys.cfor (i = 0; i < len; ++i) {
len31arch/alpha/lib/checksum.cunsigned short len,
len36arch/alpha/lib/checksum.c((unsigned long) ntohs(len) << 16) +
len47arch/alpha/lib/checksum.cstatic inline unsigned long do_csum(unsigned char * buff, int len)
len52arch/alpha/lib/checksum.cif (len <= 0)
len57arch/alpha/lib/checksum.clen--;
len60arch/alpha/lib/checksum.ccount = len >> 1;    /* nr of 16-bit words.. */
len65arch/alpha/lib/checksum.clen -= 2;
len73arch/alpha/lib/checksum.clen -= 4;
len90arch/alpha/lib/checksum.cif (len & 4) {
len95arch/alpha/lib/checksum.cif (len & 2) {
len100arch/alpha/lib/checksum.cif (len & 1)
len130arch/alpha/lib/checksum.cunsigned int csum_partial(unsigned char * buff, int len, unsigned int sum)
len132arch/alpha/lib/checksum.cunsigned long result = do_csum(buff, len);
len149arch/alpha/lib/checksum.cunsigned int csum_partial_copy(char *src, char *dst, int len, int sum)
len158arch/alpha/lib/checksum.csum = csum_partial(src, len, sum);
len159arch/alpha/lib/checksum.cmemcpy(dst, src, len);
len167arch/alpha/lib/checksum.cunsigned short ip_compute_csum(unsigned char * buff, int len)
len169arch/alpha/lib/checksum.creturn ~from64to16(do_csum(buff,len));
len264arch/i386/boot/compressed/gzip.hvoid     copy_block OF((char *buf, unsigned len, int header));
len220arch/i386/boot/compressed/misc.cint len, i;
len225arch/i386/boot/compressed/misc.clen = INBUFSIZ-insize;
len226arch/i386/boot/compressed/misc.cif (len > (input_len-input_ptr+1)) len=input_len-input_ptr+1;
len227arch/i386/boot/compressed/misc.cif (len == 0 || len == EOF) break;
len229arch/i386/boot/compressed/misc.cfor (i=0;i<len;i++) inbuf[insize+i] = input_data[input_ptr+i];
len230arch/i386/boot/compressed/misc.cinsize += len;
len231arch/i386/boot/compressed/misc.cinput_ptr += len;
len398arch/i386/boot/compressed/misc.cunsigned len = (unsigned)get_byte();
len399arch/i386/boot/compressed/misc.clen |= ((unsigned)get_byte())<<8;
len400arch/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));
len165arch/i386/kernel/irq.cint i, len = 0;
len171arch/i386/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len176arch/i386/kernel/irq.creturn len;
len84arch/i386/kernel/setup.cint len = 0;
len119arch/i386/kernel/setup.cif (COMMAND_LINE_SIZE <= ++len)
len26arch/i386/lib/checksum.cunsigned int csum_partial(unsigned char * buff, int len, unsigned int sum) {
len93arch/i386/lib/checksum.c: "0"(sum), "c"(len), "S"(buff)
len105arch/i386/lib/checksum.cint len, int sum) {
len191arch/i386/lib/checksum.c: "0"(sum), "c"(len), "S"(src), "D" (dst)
len200arch/i386/lib/checksum.cint len, int sum) {
len286arch/i386/lib/checksum.c: "0"(sum), "c"(len), "S"(src), "D" (dst)
len114arch/mips/kernel/irq.cint i, len = 0;
len120arch/mips/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len125arch/mips/kernel/irq.creturn len;
len75arch/mips/kernel/setup.cint len = 0;
len106arch/mips/kernel/setup.cif (CL_SIZE <= ++len)
len153arch/sparc/kernel/idprom.cregister int len;
len159arch/sparc/kernel/idprom.clen = prom_getproperty(prom_root_node, "vac_hwflush",
len161arch/sparc/kernel/idprom.cif(len != 4) tmp1=0;
len163arch/sparc/kernel/idprom.clen = prom_getproperty(prom_root_node, "vac-hwflush",
len165arch/sparc/kernel/idprom.cif(len != 4) tmp2=0;
len46arch/sparc/kernel/ioport.cvoid *sparc_alloc_io (void *address, void *virtual, int len, char *name,
len59arch/sparc/kernel/ioport.cif (((unsigned long) virtual + len) > (IOBASE_VADDR + IOBASE_LEN)){
len63arch/sparc/kernel/ioport.cif (check_region (vaddr, len)){
len69arch/sparc/kernel/ioport.crequest_region (vaddr, len, name);
len73arch/sparc/kernel/ioport.cfor (; len > 0; len -= PAGE_SIZE){
len84arch/sparc/kernel/ioport.cvoid *sparc_dvma_malloc (int len, char *name)
len89arch/sparc/kernel/ioport.cif (check_region (vaddr, len)){
len93arch/sparc/kernel/ioport.cif (vaddr + len > (DVMA_VADDR + DVMA_LEN)){
len99arch/sparc/kernel/ioport.crequest_region (vaddr, len, name);
len104arch/sparc/kernel/ioport.cfor (; len > 0; len -= PAGE_SIZE){
len105arch/sparc/kernel/ioport.cprintk ("Len=%d\n", len);
len168arch/sparc/kernel/irq.cint i, len = 0;
len174arch/sparc/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len179arch/sparc/kernel/irq.creturn len;
len70arch/sparc/prom/misc.cint len;
len72arch/sparc/prom/misc.clen = prom_getproplen(prom_root_node, "idprom");
len73arch/sparc/prom/misc.cif((len>num_bytes) || (len==-1)) return 0xff;
len115arch/sparc/prom/tree.cint len;
len117arch/sparc/prom/tree.clen = prom_getproperty(node, prop, user_buf, ubuf_size);
len118arch/sparc/prom/tree.cif(len != -1) return;
len795drivers/block/ide-cd.cint cdrom_read_check_ireason (ide_dev_t *dev, int len, int ireason)
len809drivers/block/ide-cd.cwhile (len > 0)
len813drivers/block/ide-cd.clen -= 2;
len836drivers/block/ide-cd.cint ireason, len, sectors_to_transfer, nskip;
len845drivers/block/ide-cd.clen = IN_BYTE (HD_LCYL, DEV_HWIF) + 256 * IN_BYTE (HD_HCYL, DEV_HWIF);
len866drivers/block/ide-cd.cif (cdrom_read_check_ireason (dev, len, ireason)) return;
len870drivers/block/ide-cd.cif ((len % SECTOR_SIZE) != 0)
len873drivers/block/ide-cd.cdev->name, len);
len881drivers/block/ide-cd.csectors_to_transfer = len / SECTOR_SIZE;
len1134drivers/block/ide-cd.cint ireason, len, stat, thislen;
len1143drivers/block/ide-cd.clen = IN_BYTE (HD_LCYL, DEV_HWIF) + 256 * IN_BYTE (HD_HCYL, DEV_HWIF);
len1174drivers/block/ide-cd.cif (thislen > len) thislen = len;
len1193drivers/block/ide-cd.cwhile (len > thislen)
len1197drivers/block/ide-cd.clen -= 2;
len1222drivers/block/ide-cd.cwhile (len > thislen)
len1226drivers/block/ide-cd.clen -= 2;
len1263drivers/block/ide-cd.cint len;
len1267drivers/block/ide-cd.clen = pc->buflen;
len1268drivers/block/ide-cd.cif (len < 0) len = -len;
len1272drivers/block/ide-cd.cif (cdrom_start_packet_command (dev, len))
len35drivers/block/ramdisk.cint  len;
len41drivers/block/ramdisk.clen = CURRENT->current_nr_sectors << 9;
len44drivers/block/ramdisk.c(addr+len > rd_start+rd_length)) {
len51drivers/block/ramdisk.clen);
len55drivers/block/ramdisk.clen);
len310drivers/block/sjcd.cstatic int sjcd_load_response( void *buf, int len ){
len313drivers/block/sjcd.cfor( ; len; --len ){ 
len319drivers/block/sjcd.creturn( len );
len374drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len398drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
len72drivers/net/3c505.c#define INVALID_PCB_MSG(len) \
len73drivers/net/3c505.cprintk(invalid_pcb_msg, (len),filename,__FUNCTION__,__LINE__)
len542drivers/net/3c505.creceive_packet (struct device * dev, int len)
len554drivers/net/3c505.cif (len <= 0 || ((len & ~1) != len))
len557drivers/net/3c505.cprintk("*** bad packet len %d at %s(%d)\n",len,filename,__LINE__);
len561drivers/net/3c505.crlen = (len+1) & ~1;
len596drivers/net/3c505.cptr = (unsigned short *)skb_put(skb,len);
len631drivers/net/3c505.cint len;
len684drivers/net/3c505.clen = adapter->irx_pcb.data.rcv_resp.pkt_len;
len692drivers/net/3c505.cprintk("%s: interrupt - packet received of length %i (%i)\n", dev->name, len, dlen);
len931drivers/net/3c505.csend_packet (struct device * dev, unsigned char * ptr, int len)
len940drivers/net/3c505.cunsigned int nlen = (((len < 60) ? 60 : len) + 1) & (~1);
len947drivers/net/3c505.cif (nlen < len)
len948drivers/net/3c505.cprintk("Warning, bad length nlen=%d len=%d %s(%d)\n",nlen,len,filename,__LINE__);
len1009drivers/net/3c505.cif (skb->len <= 0)
len1013drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
len1034drivers/net/3c505.cif (!send_packet(dev, skb->data, skb->len)) {
len1040drivers/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;
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);
len175drivers/net/8390.clength = skb->len;
len176drivers/net/8390.cif (skb->len <= 0)
len620drivers/net/apricot.cif (skb->len <= 0) return 0;
len630drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len457drivers/net/arcnet.cvoid *daddr,void *saddr,unsigned len);
len1136drivers/net/arcnet.cout->length = 1 < skb->len ? skb->len : 1;
len1143drivers/net/arcnet.cfor( i=0; i< skb->len; i++)
len1454drivers/net/arcnet.cshort offset,length=skb->len+1;
len1511drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
len1919drivers/net/arcnet.cskb->len = length;
len1967drivers/net/arcnet.cfor( i=0; i< skb->len; i++)
len2059drivers/net/arcnet.cskb->len=sizeof(struct ClientData);
len2110drivers/net/arcnet.cmemcpy(skb->data+skb->len,
len2114drivers/net/arcnet.cskb->len+=length-sizeof(struct ClientData);
len2131drivers/net/arcnet.cfor( i=0; i< skb->len; i++)
len2168drivers/net/arcnet.cskb->len = length;
len2177drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len2239drivers/net/arcnet.cvoid *daddr,void *saddr,unsigned len)
len407drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len448drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len422drivers/net/de4x5.cstatic void    create_packet(struct device *dev, char *frame, int len);
len985drivers/net/de4x5.cif (lp->skb[i]->len != FAKE_FRAME_LEN) {
len997drivers/net/de4x5.cif (skb->len != FAKE_FRAME_LEN) {
len1032drivers/net/de4x5.c} else if (skb->len == FAKE_FRAME_LEN) {     /* Don't TX a fake frame! */
len1034drivers/net/de4x5.c} else if (skb->len > 0) {
len1042drivers/net/de4x5.cload_packet(dev, skb->data, TD_IC | TD_LS | TD_FS | skb->len, skb);
len1161drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
len1162drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
len1163drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
len2117drivers/net/de4x5.cstatic void create_packet(struct device *dev, char *frame, int len)
len2473drivers/net/de4x5.cskb->len= FAKE_FRAME_LEN;
len2501drivers/net/de4x5.cioc->len = ETH_ALEN;
len2502drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
len2508drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len2563drivers/net/de4x5.cioc->len = (HASH_TABLE_LEN >> 3);
len2564drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, ioc->data, ioc->len);
len2567drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
len2572drivers/net/de4x5.cif (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
len2573drivers/net/de4x5.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN * ioc->len))) {
len2574drivers/net/de4x5.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len2575drivers/net/de4x5.cset_multicast_list(dev, ioc->len, tmp.addr);
len2578drivers/net/de4x5.cset_multicast_list(dev, ioc->len, NULL);
len2604drivers/net/de4x5.cioc->len = sizeof(lp->pktStats);
len2605drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
len2610drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
len2652drivers/net/de4x5.cioc->len = j;
len2653drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len2654drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len2715drivers/net/de4x5.cioc->len = j;
len2716drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len2717drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len624drivers/net/de4x5.hunsigned short len;                /* Length of the data buffer */
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)
len488drivers/net/de620.cint len;
len524drivers/net/de620.cif ((len = skb->len) < RUNT)
len525drivers/net/de620.clen = RUNT;
len526drivers/net/de620.cif (len & 1) /* send an even number of bytes */
len527drivers/net/de620.c++len;
len534drivers/net/de620.c(int)skb->len, using_txbuf));
len555drivers/net/de620.cde620_write_block(buffer, len);
len838drivers/net/depca.c} else if (skb->len > 0) {
len943drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
len953drivers/net/depca.clen = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
len954drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
len955drivers/net/depca.cmemcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
len1568drivers/net/depca.cint i, entry, end, len, status = 0;
len1571drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
len1578drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
len1579drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
len1580drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
len1582drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
len1586drivers/net/depca.clen = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
len1592drivers/net/depca.clen -= TX_BUFF_SZ;
len1597drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);       /* packet length in last buff */
len1674drivers/net/depca.cioc->len = ETH_ALEN;
len1675drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len1676drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1743drivers/net/depca.cioc->len = (HASH_TABLE_LEN >> 3);
len1744drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1745drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
len1751drivers/net/depca.cif (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
len1752drivers/net/depca.cif (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
len1753drivers/net/depca.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len1754drivers/net/depca.cset_multicast_list(dev, ioc->len, tmp.addr);
len1757drivers/net/depca.cset_multicast_list(dev, ioc->len, NULL);
len1782drivers/net/depca.cioc->len = sizeof(lp->pktStats);
len1783drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1784drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
len1805drivers/net/depca.cioc->len = i+sizeof(struct depca_init);
len1806drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1807drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len164drivers/net/depca.hunsigned short len;                /* Length of the data buffer */
len651drivers/net/eepro.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len496drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len149drivers/net/eql.cunsigned len); /*  */
len366drivers/net/eql.cdev->name, eql_number_slaves (eql->queue), skb->len,
len372drivers/net/eql.cslave->bytes_queued += skb->len; 
len400drivers/net/eql.cunsigned len)
len798drivers/net/ewrk3.c} else if (skb->len > 0) {
len851drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
len852drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
len854drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
len860drivers/net/ewrk3.c*buf++ = (char)(skb->len & 0xff);         /* length (16 bit xfer)*/
len862drivers/net/ewrk3.c*buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
len864drivers/net/ewrk3.c*(buf + skb->len) = 0x00;               /* Write the XCT flag */
len867drivers/net/ewrk3.cmemcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
len868drivers/net/ewrk3.c*(buf + skb->len) = 0xff;               /* Write the XCT flag */
len870drivers/net/ewrk3.c*buf++ = (char)((skb->len >> 8) & 0xff);
len872drivers/net/ewrk3.cmemcpy(buf, skb->data, skb->len);       /* Write data bytes */
len1628drivers/net/ewrk3.cioc->len = ETH_ALEN;
len1632drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1696drivers/net/ewrk3.cioc->len = (HASH_TABLE_LEN >> 3);
len1697drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len); 
len1703drivers/net/ewrk3.cerr = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN * ioc->len);
len1706drivers/net/ewrk3.cif (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
len1707drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len1709drivers/net/ewrk3.cset_multicast_list(dev, ioc->len, tmp.addr);
len1740drivers/net/ewrk3.cioc->len = EWRK3_PKT_STAT_SZ;
len1776drivers/net/ewrk3.cerr = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
len1787drivers/net/ewrk3.cioc->len = EEPROM_MAX + 1 + ETH_ALEN;
len1788drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len295drivers/net/ewrk3.hunsigned short len;                /* Length of the data buffer */
len466drivers/net/hp100.cif ( ( i = ( hp100_inl( TX_MEM_FREE ) & ~0x7fffffff ) ) < skb -> len + 16 )
len516drivers/net/hp100.cif ( skb -> len <= 0 ) return 0;
len529drivers/net/hp100.cprintk( "hp100_start_xmit: irq_status = 0x%x, len = %d\n", val, (int)skb -> len );
len531drivers/net/hp100.cif ( skb -> len >= HP100_MIN_PACKET_SIZE )
len533drivers/net/hp100.chp100_outw( skb -> len, DATA32 );    /* length to memory manager */
len534drivers/net/hp100.chp100_outw( skb -> len, FRAGMENT_LEN );
len535drivers/net/hp100.coutsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
len542drivers/net/hp100.ci = skb -> len + 3;
len988drivers/net/ibmtr.cti->current_skb->len-18));
len998drivers/net/ibmtr.cti->current_skb->len-18+hdr_len);
len1008drivers/net/ibmtr.cxmit_resp->frame_length=htons(ti->current_skb->len
len1013drivers/net/ibmtr.cti->current_skb->len-sizeof(struct trh_hdr));
len758drivers/net/lance.cif (skb->len <= 0)
len793drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len795drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
len801drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
len805drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
len604drivers/net/ni52.cint len = ((char *) p->iscp - (char *) ptr - 8) / 6;
len605drivers/net/ni52.cif(len <= 0)
len611drivers/net/ni52.cif(len < num_addrs)
len613drivers/net/ni52.cnum_addrs = len;
len930drivers/net/ni52.cint len,i;
len978drivers/net/ni52.cif (skb->len <= 0)
len980drivers/net/ni52.cif(skb->len > XMIT_BUFF_SIZE)
len982drivers/net/ni52.cprintk("%s: Sorry, max. framelength is %d bytes. The length of your frame is %ld bytes.\n",dev->name,XMIT_BUFF_SIZE,skb->len);
len990drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
len991drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
len995drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1016drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1028drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
len499drivers/net/ni65.cint rmdstat,len;
len528drivers/net/ni65.clen = (rmdp->mlen & 0x0fff) - 4; /* -4: ignore FCS */
len533drivers/net/ni65.cmemcpy(skb_put(skb,len),p->recv_skb[p->rmdnum]->data,len);
len539drivers/net/ni65.crmdp->u.buffer = (unsigned long) skb_put(skb1,len);
len587drivers/net/ni65.cif (skb->len <= 0)
len602drivers/net/ni65.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len610drivers/net/ni65.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff),(char *)skb->data,skb->len);
len613drivers/net/ni65.ctmdp->blen = -len;
len444drivers/net/pi2.clength = lp->sndbuf->len - 1;
len703drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
len817drivers/net/pi2.clp->txcnt = (int) lp->sndbuf->len - 1;
len1078drivers/net/pi2.cvoid *daddr, void *saddr, unsigned len)
len1080drivers/net/pi2.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
len879drivers/net/plip.cif (skb->len > dev->mtu) {
len880drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
len891drivers/net/plip.csnd->length.h = skb->len;
len122drivers/net/ppp.cunsigned long saddr, unsigned len);
len1179drivers/net/ppp.cunsigned char *buf, int len)
len1184drivers/net/ppp.ctotlen = len+2;    /* including protocol */
len1197drivers/net/ppp.cwhile (len-- > 0) {
len1245drivers/net/ppp.cint len, i;
len1280drivers/net/ppp.cGETC (c); len = c << 8; GETC (c); len += c;
len1282drivers/net/ppp.cPRINTKN (4,(KERN_DEBUG "ppp_read: len = %d\n", len));
len1284drivers/net/ppp.cif (len + 2 > nr) {
len1288drivers/net/ppp.cnr, len+2));
len1289drivers/net/ppp.cppp->us_rbuff_head += len;
len1300drivers/net/ppp.ci = len;
len1308drivers/net/ppp.cPRINTKN (3,(KERN_DEBUG "ppp_read: passing %d bytes up\n", len + 2));
len1310drivers/net/ppp.creturn len + 2;
len1730drivers/net/ppp.cint len;
len1742drivers/net/ppp.clen   = skb->len;
len1769drivers/net/ppp.cif (len < sizeof(struct iphdr)) {
len1773drivers/net/ppp.clen = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
len1779drivers/net/ppp.cif (ppp_us_queue (ppp, proto, p, len))
len1796drivers/net/ppp.clen = slhc_compress(ppp->slcomp, p, len, ppp->cbuff, &p, 
len1817drivers/net/ppp.cdev->name, (int) proto, (int) len, (int) iph->saddr,
len1841drivers/net/ppp.cwhile (len-- > 0)
len1869drivers/net/ppp.cunsigned long daddr, unsigned long saddr, unsigned len)
len1889drivers/net/ppp.cvoid *daddr, void *saddr, unsigned len)
len408drivers/net/seeq8005.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
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 */
len1570drivers/net/sk_g16.cint len = (rmdp->mlen & 0x0fff);  /* extract message length from receive buffer */
len1573drivers/net/sk_g16.cskb = dev_alloc_skb(len+2); /* allocate socket buffer */ 
len1603drivers/net/sk_g16.cmemcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
len1604drivers/net/sk_g16.clen);
len340drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
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;
len93drivers/net/slip.cstatic int slip_esc(unsigned char *p, unsigned char *d, int len);
len96drivers/net/slip.cstatic int slip_esc6(unsigned char *p, unsigned char *d, int len);
len164drivers/net/slip.cint len;
len167drivers/net/slip.clen = dev->mtu * 2;
len173drivers/net/slip.cif (len < 576 * 2)  {
len174drivers/net/slip.clen = 576 * 2;
len177drivers/net/slip.cxbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len178drivers/net/slip.crbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len180drivers/net/slip.ccbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len216drivers/net/slip.cif (sl->xleft <= len)  {
len226drivers/net/slip.cif (sl->rcount <= len) {
len239drivers/net/slip.csl->buffsize = len;
len336drivers/net/slip.csl_encaps(struct slip *sl, unsigned char *icp, int len)
len350drivers/net/slip.cif (len > sl->mtu) {    /* Sigh, shouldn't occur BUT ... */
len351drivers/net/slip.clen = sl->mtu;
len361drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
len366drivers/net/slip.ccount = slip_esc6(p, (unsigned char *) sl->xbuff, len);
len369drivers/net/slip.ccount = slip_esc(p, (unsigned char *) sl->xbuff, len);
len460drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
len472drivers/net/slip.cvoid *daddr, void *saddr, unsigned len)
len479drivers/net/slip.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
len510drivers/net/slip.cunsigned long len;
len523drivers/net/slip.clen = dev->mtu * 2;
len529drivers/net/slip.cif (len < 576 * 2)  {
len530drivers/net/slip.clen = 576 * 2;
len532drivers/net/slip.csl->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len536drivers/net/slip.csl->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len541drivers/net/slip.csl->cbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len556drivers/net/slip.csl->buffsize = len;
len777drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
len795drivers/net/slip.cwhile (len-- > 0) {
len858drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
len878drivers/net/slip.cfor (i = 0; i < len; ++i) {
len406drivers/net/tulip.cif (skb == NULL || skb->len <= 0) {
len429drivers/net/tulip.ctp->tx_ring[entry].length = skb->len |
len206drivers/net/tunnel.cnewlen = (skb->len + ip_header_len);
len221drivers/net/tunnel.cmemcpy(skb2->data + ip_header_len, skb->data, skb->len);
len231drivers/net/tunnel.ciph->tot_len = htons(skb2->len);
len1437drivers/net/wavelan.clength = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
len2114drivers/net/wavelan.cint    len;
len2120drivers/net/wavelan.clen = 0;
len2127drivers/net/wavelan.clen += size;
len2138drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
len2140drivers/net/wavelan.clen += size;
len2141drivers/net/wavelan.cpos = begin + len;
len2145drivers/net/wavelan.clen = 0;
len2158drivers/net/wavelan.clen -= (offset - begin);    /* Start slop */
len2159drivers/net/wavelan.cif (len > length)
len2160drivers/net/wavelan.clen = length;      /* Ending slop */
len2162drivers/net/wavelan.creturn len;
len360drivers/net/znet.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len386drivers/net/znet.cmemcpy(zn.tx_cur, buf, skb->len);
len413drivers/pci/pci.cint reg, len = 0;
len427drivers/pci/pci.cif (len + 80 > size) {
len430drivers/pci/pci.clen += sprintf(buf + len, "  Bus %2d, device %3d, function %2d:\n",
len433drivers/pci/pci.cif (len + 80 > size) {
len436drivers/pci/pci.clen += sprintf(buf + len, "    %s: %s %s (rev %d).\n      ",
len441drivers/pci/pci.clen += sprintf(buf + len,
len452drivers/pci/pci.cif (len + strlen(str) > size) {
len455drivers/pci/pci.clen += sprintf(buf + len, str);
len459drivers/pci/pci.cif (len + strlen(fast_b2b_capable) > size) {
len462drivers/pci/pci.clen += sprintf(buf + len, fast_b2b_capable);
len468drivers/pci/pci.cif (len + strlen(BIST_capable) > size) {
len471drivers/pci/pci.clen += sprintf(buf + len, BIST_capable);
len476drivers/pci/pci.cif (len + 40 > size) {
len479drivers/pci/pci.clen += sprintf(buf + len, "IRQ %d.  ", dev->irq);
len483drivers/pci/pci.cif (len + 80 > size) {
len486drivers/pci/pci.clen += sprintf(buf + len, "Master Capable.  ");
len488drivers/pci/pci.clen += sprintf(buf + len, "Latency=%d.  ", latency); 
len490drivers/pci/pci.clen += sprintf(buf + len, "No bursts.  ");
len492drivers/pci/pci.clen += sprintf(buf + len, "Min Gnt=%d.", min_gnt);
len494drivers/pci/pci.clen += sprintf(buf + len, "Max Lat=%d.", max_lat);
len498drivers/pci/pci.cif (len + 40 > size) {
len508drivers/pci/pci.clen += sprintf(buf + len,
len532drivers/pci/pci.clen += sprintf(buf + len,
len539drivers/pci/pci.clen += sprintf(buf + len, "\n");
len540drivers/pci/pci.creturn len;
len550drivers/pci/pci.cint nprinted, len, size;
len556drivers/pci/pci.clen   = sprintf(buf, "PCI devices found:\n");
len559drivers/pci/pci.cnprinted = sprint_dev_config(dev, buf + len, size - len);
len561drivers/pci/pci.creturn len + sprintf(buf + len, MSG);
len563drivers/pci/pci.clen += nprinted;
len565drivers/pci/pci.creturn len;
len757drivers/pci/pci.cint len = get_pci_list(mem_start);
len758drivers/pci/pci.cif (len) {
len759drivers/pci/pci.c((char*)mem_start)[len] = '\0';
len2055drivers/scsi/53c7,8xx.csize_t len;
len2073drivers/scsi/53c7,8xx.clen = strlen(buf);
len2076drivers/scsi/53c7,8xx.csprintf(buf + len, "%08x\n", * (u32 *) bp->addr);
len2078drivers/scsi/53c7,8xx.csprintf(buf + len, "\n");
len2080drivers/scsi/53c7,8xx.clen = strlen(buf);
len2081drivers/scsi/53c7,8xx.cdebugger_kernel_write (host, buf, len);
len2093drivers/scsi/53c7,8xx.csize_t len;
len2155drivers/scsi/53c7,8xx.cint i, j, error, len;
len2176drivers/scsi/53c7,8xx.clen = strlen (debugger_tokens[i].name);
len2177drivers/scsi/53c7,8xx.cif (!strncmp(input_buf, debugger_tokens[i].name, len)) 
len2184drivers/scsi/53c7,8xx.cfor (ptr = input_buf + len, j = 0; j < debugger_tokens[i].nargs && *ptr;) {
len3737drivers/scsi/53c7,8xx.csize_t len = strlen(buf);
len3738drivers/scsi/53c7,8xx.cdebugger_kernel_write(host, buf, len);
len3894drivers/scsi/53c7,8xx.cint i, len;
len3905drivers/scsi/53c7,8xx.cptr += len, i -= len) {
len3907drivers/scsi/53c7,8xx.clen = print_msg (ptr);
len1172drivers/scsi/NCR5380.cint len;
len1412drivers/scsi/NCR5380.clen = 3;
len1416drivers/scsi/NCR5380.clen = 1;
len1423drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len1916drivers/scsi/NCR5380.cint len;
len2003drivers/scsi/NCR5380.clen = transfersize;
len2005drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
len2019drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
len2027drivers/scsi/NCR5380.clen = 1;
len2029drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2231drivers/scsi/NCR5380.clen = 2;
len2234drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2242drivers/scsi/NCR5380.cif (!len && extended_msg[1] <= 
len2246drivers/scsi/NCR5380.clen = extended_msg[1] - 1;
len2250drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2254drivers/scsi/NCR5380.cinstance->host_no, len);
len2264drivers/scsi/NCR5380.c} else if (len) {
len2298drivers/scsi/NCR5380.clen = 1;
len2301drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2313drivers/scsi/NCR5380.clen = cmd->cmd_len;
len2320drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, 
len2335drivers/scsi/NCR5380.clen = 1;
len2337drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2382drivers/scsi/NCR5380.cint len;
len2426drivers/scsi/NCR5380.clen = 1;
len2429drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2491drivers/scsi/NCR5380.clen = 1;
len2495drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2580drivers/scsi/NCR5380.cint len;
len2711drivers/scsi/NCR5380.clen = 1;
len2714drivers/scsi/NCR5380.cNCR5380_transfer_pio (instance, &phase, &len, &msgptr);
len154drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
len158drivers/scsi/aha1542.cif(len == 1) {
len171drivers/scsi/aha1542.cwhile (len--)
len181drivers/scsi/aha1542.cprintk("aha1542_out failed(%d): ", len+1); aha1542_stat();
len187drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
len193drivers/scsi/aha1542.cwhile (len--)
len202drivers/scsi/aha1542.cprintk("aha1542_in failed(%d): ", len+1); aha1542_stat();
len209drivers/scsi/aha1542.cstatic int aha1542_in1(unsigned int base, unchar *cmdp, int len)
len215drivers/scsi/aha1542.cwhile (len--)
len289drivers/scsi/aha1542.cint len;
len322drivers/scsi/aha1542.clen = 4;
len325drivers/scsi/aha1542.cwhile (len--)
len1177drivers/scsi/aic7xxx.cregister int len = ep - bp;
len1179drivers/scsi/aic7xxx.cstrncpy(buf, bp, len);
len1180drivers/scsi/aic7xxx.cbuf[len] = '\0';
len2339drivers/scsi/aic7xxx.cunsigned char len;
len2385drivers/scsi/aic7xxx.cfor (i = 0; i < seeprom_read.len; i = i + 1)
len250drivers/scsi/buslogic.csize_t len)
len254drivers/scsi/buslogic.cif (len == 1) {
len269drivers/scsi/buslogic.cwhile (len--) {
len278drivers/scsi/buslogic.cbuslogic_printk("failed(%u): ", len + 1);
len286drivers/scsi/buslogic.cstatic int buslogic_in(unsigned int base, unsigned char *cmdp, size_t len)
len292drivers/scsi/buslogic.cwhile (len--) {
len301drivers/scsi/buslogic.cbuslogic_printk("failed(%u): ", len + 1);
len493drivers/scsi/constants.cint len = 0, i;
len495drivers/scsi/constants.clen = 3 + msg[1];
len514drivers/scsi/constants.cfor (i = 2; i < len; ++i) 
len518drivers/scsi/constants.cfor (i = 0; i < len; ++i)
len531drivers/scsi/constants.clen = 1;
len542drivers/scsi/constants.clen = 1;
len555drivers/scsi/constants.clen = 2;
len562drivers/scsi/constants.creturn len;
len239drivers/scsi/eata.cushort len;          /* Number of bytes following this field */
len463drivers/scsi/eata.cconfig.len = (ushort) htons((ushort)510);
len458drivers/scsi/eata_dma.ccp->sg_list[i].len = htonl((u32) sl->length);
len803drivers/scsi/eata_dma.c(u32) ntohl(gc->len), gc->version,
len838drivers/scsi/eata_dma.cif(gc->HAA_valid == FALSE || ntohl(gc->len) < 0x22) 
len962drivers/scsi/eata_dma.cswitch (ntohl(gc->len)) {
len978drivers/scsi/eata_dma.cif(ntohl(gc->len) >= 0x22) {
len995drivers/scsi/eata_dma.cif(ntohl(gc->len) >= 0x22) {
len2drivers/scsi/eata_dma_proc.cint *size, int len);
len93drivers/scsi/eata_dma_proc.cint    size, len = 0;
len122drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) driver version: "
len124drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
len125drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
len127drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
len129drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
len131drivers/scsi/eata_dma_proc.clen += size; 
len132drivers/scsi/eata_dma_proc.cpos = begin + len;
len133drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
len135drivers/scsi/eata_dma_proc.clen += size;
len136drivers/scsi/eata_dma_proc.cpos = begin + len;
len137drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Hardware Configuration:\n");
len138drivers/scsi/eata_dma_proc.clen += size; 
len139drivers/scsi/eata_dma_proc.cpos = begin + len;
len143drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
len145drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
len146drivers/scsi/eata_dma_proc.clen += size; 
len147drivers/scsi/eata_dma_proc.cpos = begin + len;
len149drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len150drivers/scsi/eata_dma_proc.clen += size; 
len151drivers/scsi/eata_dma_proc.cpos = begin + len;
len152drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: EISA\n"); 
len153drivers/scsi/eata_dma_proc.clen += size; 
len154drivers/scsi/eata_dma_proc.cpos = begin + len;
len208drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "IRQ: %2d, %s triggered\n", cc->interrupt,
len210drivers/scsi/eata_dma_proc.clen += size; 
len211drivers/scsi/eata_dma_proc.cpos = begin + len;
len213drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
len215drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
len216drivers/scsi/eata_dma_proc.clen += size; 
len217drivers/scsi/eata_dma_proc.cpos = begin + len;
len218drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "CPU: MC680%02d %dMHz\n", bt->cpu_type,
len220drivers/scsi/eata_dma_proc.clen += size; 
len221drivers/scsi/eata_dma_proc.cpos = begin + len;
len222drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len223drivers/scsi/eata_dma_proc.clen += size; 
len224drivers/scsi/eata_dma_proc.cpos = begin + len;
len225drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
len229drivers/scsi/eata_dma_proc.clen += size; 
len230drivers/scsi/eata_dma_proc.cpos = begin + len;
len231drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI Bus:%s%s Speed: %sMB/sec. %s\n",
len236drivers/scsi/eata_dma_proc.clen += size; 
len237drivers/scsi/eata_dma_proc.cpos = begin + len;
len238drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI channel expansion Module: %s present\n",
len241drivers/scsi/eata_dma_proc.clen += size; 
len242drivers/scsi/eata_dma_proc.cpos = begin + len;
len243drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartRAID hardware: %spresent.\n",
len245drivers/scsi/eata_dma_proc.clen += size; 
len246drivers/scsi/eata_dma_proc.cpos = begin + len;
len247drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
len253drivers/scsi/eata_dma_proc.clen += size; 
len254drivers/scsi/eata_dma_proc.cpos = begin + len;
len256drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max array groups:              %d\n",
len258drivers/scsi/eata_dma_proc.clen += size; 
len259drivers/scsi/eata_dma_proc.cpos = begin + len;
len260drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 0 array:   %d\n",
len262drivers/scsi/eata_dma_proc.clen += size; 
len263drivers/scsi/eata_dma_proc.cpos = begin + len;
len264drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 3/5 array: %d\n",
len266drivers/scsi/eata_dma_proc.clen += size; 
len267drivers/scsi/eata_dma_proc.cpos = begin + len;
len268drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Cache Module: %spresent.\n",
len270drivers/scsi/eata_dma_proc.clen += size; 
len271drivers/scsi/eata_dma_proc.cpos = begin + len;
len272drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
len278drivers/scsi/eata_dma_proc.clen += size; 
len279drivers/scsi/eata_dma_proc.cpos = begin + len;
len281drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Bank%d: %dMB with%s ECC\n",x,
len284drivers/scsi/eata_dma_proc.clen += size; 
len285drivers/scsi/eata_dma_proc.cpos = begin + len;      
len287drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Timer Mod.: %spresent\n",
len289drivers/scsi/eata_dma_proc.clen += size; 
len290drivers/scsi/eata_dma_proc.cpos = begin + len;
len291drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "NVRAM     : %spresent\n",
len293drivers/scsi/eata_dma_proc.clen += size; 
len294drivers/scsi/eata_dma_proc.cpos = begin + len;
len295drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartROM  : %sabled\n",
len297drivers/scsi/eata_dma_proc.clen += size; 
len298drivers/scsi/eata_dma_proc.cpos = begin + len;
len299drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Alarm     : %s\n",
len301drivers/scsi/eata_dma_proc.clen += size; 
len302drivers/scsi/eata_dma_proc.cpos = begin + len;
len305drivers/scsi/eata_dma_proc.clen = 0;
len357drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host<->Disk command statistics:\n"
len359drivers/scsi/eata_dma_proc.clen += size; 
len360drivers/scsi/eata_dma_proc.cpos = begin + len;
len362drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u\n", 1 << x,
len365drivers/scsi/eata_dma_proc.clen += size; 
len366drivers/scsi/eata_dma_proc.cpos = begin + len;
len368drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u\n",
len371drivers/scsi/eata_dma_proc.clen += size; 
len372drivers/scsi/eata_dma_proc.cpos = begin + len;
len373drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Sum   : %12u %12u\n",
len376drivers/scsi/eata_dma_proc.clen += size; 
len377drivers/scsi/eata_dma_proc.cpos = begin + len;
len381drivers/scsi/eata_dma_proc.clen = 0;
len388drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Latency Command Statistics:\n"
len391drivers/scsi/eata_dma_proc.clen += size; 
len392drivers/scsi/eata_dma_proc.cpos = begin + len;
len394drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
len403drivers/scsi/eata_dma_proc.clen += size; 
len404drivers/scsi/eata_dma_proc.cpos = begin + len;
len406drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
len414drivers/scsi/eata_dma_proc.clen += size; 
len415drivers/scsi/eata_dma_proc.cpos = begin + len;
len418drivers/scsi/eata_dma_proc.clen = 0;
len424drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len,
len426drivers/scsi/eata_dma_proc.clen += size; 
len427drivers/scsi/eata_dma_proc.cpos = begin + len;
len429drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
len438drivers/scsi/eata_dma_proc.clen += size; 
len439drivers/scsi/eata_dma_proc.cpos = begin + len;
len441drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
len449drivers/scsi/eata_dma_proc.clen += size; 
len450drivers/scsi/eata_dma_proc.cpos = begin + len;
len453drivers/scsi/eata_dma_proc.clen = 0;
len462drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len463drivers/scsi/eata_dma_proc.clen += size; 
len464drivers/scsi/eata_dma_proc.cpos = begin + len;
len468drivers/scsi/eata_dma_proc.cproc_print_scsidevice(scd, buffer, &size, len);
len469drivers/scsi/eata_dma_proc.clen += size; 
len470drivers/scsi/eata_dma_proc.cpos = begin + len;
len473drivers/scsi/eata_dma_proc.clen = 0;
len483drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
len485drivers/scsi/eata_dma_proc.clen-=(offset-begin);      /* Start slop */
len486drivers/scsi/eata_dma_proc.cif(len>length)
len487drivers/scsi/eata_dma_proc.clen = length;        /* Ending slop */
len488drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
len490drivers/scsi/eata_dma_proc.creturn (len);     
len200drivers/scsi/eata_generic.h__u32  len;          /* Should return 0x22, 0x24, etc    */
len251drivers/scsi/eata_generic.h__u32 len;
len645drivers/scsi/eata_pio.c(uint) ntohl(gc->len), gc->version,
len754drivers/scsi/eata_pio.cswitch (ntohl(gc->len)) {
len784drivers/scsi/eata_pio.cif(ntohl(gc->len) >= 0x22) {
len44drivers/scsi/eata_pio_proc.cint   size, len = 0;
len61drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) PIO driver version: "
len63drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
len64drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
len66drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
len68drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
len70drivers/scsi/eata_pio_proc.clen += size; 
len71drivers/scsi/eata_pio_proc.cpos = begin + len;
len72drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
len74drivers/scsi/eata_pio_proc.clen += size;
len75drivers/scsi/eata_pio_proc.cpos = begin + len;
len76drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "IO: PIO\n");
len77drivers/scsi/eata_pio_proc.clen += size; 
len78drivers/scsi/eata_pio_proc.cpos = begin + len;
len79drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len80drivers/scsi/eata_pio_proc.clen += size; 
len81drivers/scsi/eata_pio_proc.cpos = begin + len;
len82drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
len86drivers/scsi/eata_pio_proc.clen += size; 
len87drivers/scsi/eata_pio_proc.cpos = begin + len;
len90drivers/scsi/eata_pio_proc.clen = 0;
len98drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len99drivers/scsi/eata_pio_proc.clen += size; 
len100drivers/scsi/eata_pio_proc.cpos = begin + len;
len105drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Channel: %02d Id: %02d Lun: %02d\n  Vendor: ",
len109drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "%c", scd->vendor[x]);
len111drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size," ");
len113drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, " Model: ");
len116drivers/scsi/eata_pio_proc.csize +=  sprintf(buffer + len + size, "%c", scd->model[x]);
len118drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, " ");
len120drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, " Rev: ");
len123drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "%c", scd->rev[x]);
len125drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, " ");
len127drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "\n");
len129drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "  Type:   %s ",
len132drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "               ANSI"
len135drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, " CCS\n");
len137drivers/scsi/eata_pio_proc.csize += sprintf(buffer + len + size, "\n");
len138drivers/scsi/eata_pio_proc.clen += size; 
len139drivers/scsi/eata_pio_proc.cpos = begin + len;
len142drivers/scsi/eata_pio_proc.clen = 0;
len152drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
len154drivers/scsi/eata_pio_proc.clen-=(offset-begin);            /* Start slop */
len155drivers/scsi/eata_pio_proc.cif(len>length)
len156drivers/scsi/eata_pio_proc.clen = length;               /* Ending slop */
len157drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
len159drivers/scsi/eata_pio_proc.creturn (len);     
len482drivers/scsi/pas16.cint len) {
len486drivers/scsi/pas16.cregister i = len;
len515drivers/scsi/pas16.cint len) {
len518drivers/scsi/pas16.cregister i = len;
len115drivers/scsi/scsi.cint *size, int len);
len2086drivers/scsi/scsi.cvoid *scsi_malloc(unsigned int len)
len2091drivers/scsi/scsi.cif((len & 0x1ff) || len > (1<<MALLOC_PAGEBITS))
len2096drivers/scsi/scsi.cnbits = len >> 9;
len2106drivers/scsi/scsi.cprintk("SMalloc: %d %p ",len, dma_malloc_pages[i] + (j << 9));
len2115drivers/scsi/scsi.cint scsi_free(void *obj, unsigned int len)
len2122drivers/scsi/scsi.cprintk("Sfree %p %d\n",obj, len);
len2140drivers/scsi/scsi.cnbits = len >> 9;
len2437drivers/scsi/scsi.cint    size, len = 0;
len2445drivers/scsi/scsi.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len2446drivers/scsi/scsi.clen += size; 
len2447drivers/scsi/scsi.cpos = begin + len;
len2450drivers/scsi/scsi.csize += sprintf(buffer+len,"scsi%2d: %s\n", (int) HBA_ptr->host_no, HBA_ptr->hostt->procname);
len2451drivers/scsi/scsi.clen += size; 
len2452drivers/scsi/scsi.cpos = begin + len;
len2457drivers/scsi/scsi.cproc_print_scsidevice(scd, buffer, &size, len);
len2458drivers/scsi/scsi.clen += size; 
len2459drivers/scsi/scsi.cpos = begin + len;
len2462drivers/scsi/scsi.clen = 0;
len2475drivers/scsi/scsi.clen-=(offset-begin);      /* Start slop */
len2476drivers/scsi/scsi.cif(len>length)
len2477drivers/scsi/scsi.clen = length;        /* Ending slop */
len2478drivers/scsi/scsi.creturn (len);     
len622drivers/scsi/scsi_debug.cint len, pos, begin;
len656drivers/scsi/scsi_debug.cpos = len = sprintf(buffer, 
len662drivers/scsi/scsi_debug.clen = 0;
len667drivers/scsi/scsi_debug.clen -= (offset - begin);
len668drivers/scsi/scsi_debug.cif(len > length)
len669drivers/scsi/scsi_debug.clen = length;
len671drivers/scsi/scsi_debug.creturn(len);
len46drivers/scsi/scsi_ioctl.cunsigned int len,slen;
len53drivers/scsi/scsi_ioctl.clen = get_user ((unsigned int *) buffer);
len60drivers/scsi/scsi_ioctl.cif (len > slen)
len61drivers/scsi/scsi_ioctl.clen = slen + 1;
len62drivers/scsi/scsi_ioctl.cresult = verify_area(VERIFY_WRITE, buffer, len);
len65drivers/scsi/scsi_ioctl.cmemcpy_tofs (buffer, string, len);
len81drivers/scsi/scsi_proc.cint len, pos, begin;
len87drivers/scsi/scsi_proc.cpos = len = sprintf(buffer, 
len90drivers/scsi/scsi_proc.clen = 0;
len95drivers/scsi/scsi_proc.clen -= (offset - begin);
len96drivers/scsi/scsi_proc.cif(len > length)
len97drivers/scsi/scsi_proc.clen = length;
len99drivers/scsi/scsi_proc.creturn(len);
len348drivers/scsi/scsi_proc.cvoid proc_print_scsidevice(Scsi_Device *scd, char *buffer, int *size, int len)
len352drivers/scsi/scsi_proc.cy = sprintf(buffer + len, 
len357drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "%c", scd->vendor[x]);
len359drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y," ");
len361drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " Model: ");
len364drivers/scsi/scsi_proc.cy +=  sprintf(buffer + len + y, "%c", scd->model[x]);
len366drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " ");
len368drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " Rev: ");
len371drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "%c", scd->rev[x]);
len373drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " ");
len375drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "\n");
len377drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "  Type:   %s ",
len380drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "               ANSI"
len383drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " CCS\n");
len385drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "\n");
len587drivers/scsi/seagate.cint len = 0;
len716drivers/scsi/seagate.clen=current_bufflen;    /* WDE add */
len914drivers/scsi/seagate.clen = buffer->length;
len921drivers/scsi/seagate.clen = SCint->request_bufflen;
len926drivers/scsi/seagate.cprintk("scsi%d : len = %d\n", hostno, len);
len1039drivers/scsi/seagate.cif (!len) {
len1049drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1057drivers/scsi/seagate.cSCint->transfersize, len, data);
len1079drivers/scsi/seagate.clen -= transfersize;
len1084drivers/scsi/seagate.chostno, len, data);
len1140drivers/scsi/seagate.c"=S" (data), "=c" (len) :
len1142drivers/scsi/seagate.c"0" (data), "1" (len) :
len1147drivers/scsi/seagate.cif (!len && nobuffs) {
len1150drivers/scsi/seagate.clen = buffer->length;
len1154drivers/scsi/seagate.chostno, len, data);
len1163drivers/scsi/seagate.ctransfered += len;
len1165drivers/scsi/seagate.cfor (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN |
len1166drivers/scsi/seagate.cSTAT_REQ); --len) {
len1171drivers/scsi/seagate.ctransfered -= len;
len1176drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1184drivers/scsi/seagate.cSCint->transfersize, len, data);
len1206drivers/scsi/seagate.clen -= transfersize;
len1216drivers/scsi/seagate.chostno, len, data);
len1224drivers/scsi/seagate.cprintk("scsi%d: transfered += %d\n", hostno, len);
len1225drivers/scsi/seagate.ctransfered += len;  /* Assume we'll transfer it all, then
len1280drivers/scsi/seagate.c"=D" (data), "=c" (len) :
len1282drivers/scsi/seagate.c"0" (data), "1" (len) :
len1287drivers/scsi/seagate.cprintk("scsi%d: transfered -= %d\n", hostno, len);
len1288drivers/scsi/seagate.ctransfered -= len;    /* Since we assumed all of Len got 
len1293drivers/scsi/seagate.cif (!len && nobuffs) {
len1296drivers/scsi/seagate.clen = buffer->length;
len1300drivers/scsi/seagate.chostno, len, data);
len1367drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1399drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1410drivers/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;
len209drivers/scsi/wd7000.cunsigned len;           /* length of string */
len325drivers/scsi/wd7000.cunchar len[3];
len381drivers/scsi/wd7000.cunchar len[3];                /* command buffer length */
len423drivers/scsi/wd7000.cunchar len[3];                /* buffer length */
len439drivers/scsi/wd7000.cunchar len[3];                /* parms buffer length */
len571drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
len574drivers/scsi/wd7000.cwhile (len--)  {
len584drivers/scsi/wd7000.cprintk("wd7000 command_out: WAIT failed(%d)\n", len+1);
len931drivers/scsi/wd7000.cany2scsi(sgb[i].len, sg[i].length);
len961drivers/scsi/wd7000.cany2scsi(icb.len, sizeof(buf));
len1114drivers/scsi/wd7000.cif (!memcmp(cfg->bios+sig->ofs, sig->sig, sig->len))  {
len510drivers/sound/aedsp16.cint             len = 0;
len522drivers/sound/aedsp16.cver[len++] = ret;
len524drivers/sound/aedsp16.cwhile (len < CARDVERLEN);
len532drivers/sound/aedsp16.cint             len = 0;
len542drivers/sound/aedsp16.creturn (len ? 0 : -1);
len544drivers/sound/aedsp16.cAudioExcelName[len++] = ret;
len547drivers/sound/aedsp16.cwhile (len < CARDNAMELEN);
len221drivers/sound/configure.cint             len;
len223drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len233drivers/sound/configure.cif (len < 2)      /*
len238drivers/sound/configure.cansw[len - 1] = 0;
len250drivers/sound/configure.cint             len, num;
len254drivers/sound/configure.cif ((len = read (0, &answ, sizeof (answ))) < 1)
len264drivers/sound/configure.cif (len < 2)      /*
len269drivers/sound/configure.cansw[len - 1] = 0;
len145drivers/sound/dev_table.hsnd_rw_buf *userbuf, int useroffs, int len);
len299drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
len370drivers/sound/dmabuf.c*len = dmap->fragment_size - dmap->counts[dmap->qhead];
len511drivers/sound/dmabuf.cint             len, max, tmp;
len523drivers/sound/dmabuf.clen = dmap->qlen;
len528drivers/sound/dmabuf.cif (tmp & len)
len532drivers/sound/dmabuf.clen += tmp;
len535drivers/sound/dmabuf.cif (len >= max)
len997drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
len465drivers/sound/gus_wave.cif (position < samples[sample_no].len)
len1321drivers/sound/gus_wave.c((sample_ptrs[sample] + samples[sample].len) >> 18))
len1348drivers/sound/gus_wave.cgus_write_addr (0x0a, sample_ptrs[sample] + samples[sample].len -
len1381drivers/sound/gus_wave.cgus_write_addr (0x04, sample_ptrs[sample] + samples[sample].len - 1,
len1553drivers/sound/gus_wave.cif (count < patch.len)
len1556drivers/sound/gus_wave.ccount, (int) patch.len);
len1557drivers/sound/gus_wave.cpatch.len = count;
len1560drivers/sound/gus_wave.cif (patch.len <= 0 || patch.len > gus_mem_size)
len1562drivers/sound/gus_wave.cprintk ("GUS: Invalid sample length %d\n", (int) patch.len);
len1568drivers/sound/gus_wave.cif (patch.loop_start < 0 || patch.loop_start >= patch.len)
len1574drivers/sound/gus_wave.cif (patch.loop_end < patch.loop_start || patch.loop_end > patch.len)
len1590drivers/sound/gus_wave.cif (patch.len >= GUS_BANK_SIZE)
len1592drivers/sound/gus_wave.cprintk ("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
len1597drivers/sound/gus_wave.c((free_mem_ptr + patch.len) / GUS_BANK_SIZE))
len1602drivers/sound/gus_wave.cif ((tmp_mem + patch.len) > gus_mem_size)
len1609drivers/sound/gus_wave.cif ((free_mem_ptr + patch.len) > gus_mem_size)
len1634drivers/sound/gus_wave.cleft = patch.len;
len1747drivers/sound/gus_wave.cfree_mem_ptr += patch.len;
len2390drivers/sound/gus_wave.csnd_rw_buf * userbuf, int useroffs, int len)
len2394drivers/sound/gus_wave.cCOPY_FROM_USER (&localbuf[localoffs], userbuf, useroffs, len);
len2403drivers/sound/gus_wave.clen /= 2;
len2408drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2423drivers/sound/gus_wave.clen /= 4;
len2429drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2573drivers/sound/gus_wave.cif (pat->len > samples[ptr].len)  /* Cannot expand sample */
len2596drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2599drivers/sound/gus_wave.cn = samples[sample].len - offs;    /* Num of bytes left */
len2637drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2642drivers/sound/gus_wave.cn = samples[sample].len - offs;    /*
len48drivers/sound/midi_synth.cint len; \
len51drivers/sound/midi_synth.cseq_input_event(obuf, len); \
len55drivers/sound/midi_synth.c#define _SEQ_ADVBUF(x) len=x
len495drivers/sound/midi_synth.cif (count < sysex.len)
len498drivers/sound/midi_synth.ccount, (int) sysex.len);
len499drivers/sound/midi_synth.csysex.len = count;
len502drivers/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;
len152drivers/sound/mpu401.cint len; \
len155drivers/sound/mpu401.cseq_input_event(obuf, len); \
len159drivers/sound/mpu401.c#define _SEQ_ADVBUF(x) len=x
len452drivers/sound/pss.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
len455drivers/sound/pss.cif (!pss_download_boot (devc, buf->data, buf->len, buf->flags))
len156drivers/sound/sequencer.cseq_copy_to_input (unsigned char *event, int len)
len164drivers/sound/sequencer.cif (len != 4 && len != 8)
len166drivers/sound/sequencer.cif ((seq_mode == SEQ_1) != (len == 4))
len173drivers/sound/sequencer.cmemcpy (&iqueue[iqtail * IEV_SZ], event, len);
len211drivers/sound/sequencer.cseq_input_event (unsigned char *event, int len)
len234drivers/sound/sequencer.cseq_copy_to_input (event, len);
len8drivers/sound/sound_calls.hint DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock);
len55drivers/sound/sound_calls.hvoid seq_input_event(unsigned char *event, int len);
len56drivers/sound/sound_calls.hvoid seq_copy_to_input (unsigned char *event, int len);
len153drivers/sound/soundcard.cint             len, err;
len155drivers/sound/soundcard.clen = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;
len159drivers/sound/soundcard.cif ((err = verify_area (VERIFY_READ, (void *) arg, len)) < 0)
len165drivers/sound/soundcard.cif ((err = verify_area (VERIFY_WRITE, (void *) arg, len)) < 0)
len579drivers/sound/sscape.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
len582drivers/sound/sscape.cif (!sscape_download_boot (devc, buf->data, buf->len, buf->flags))
len179fs/binfmt_elf.cunsigned int len;
len273fs/binfmt_elf.clen = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
len276fs/binfmt_elf.cif (last_bss > len)
len277fs/binfmt_elf.cdo_mmap(NULL, len, last_bss-len,
len682fs/binfmt_elf.cunsigned int len;
len690fs/binfmt_elf.clen = 0;
len762fs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len764fs/binfmt_elf.cif (bss > len)
len765fs/binfmt_elf.cdo_mmap(NULL, len, bss-len,
len1049fs/binfmt_elf.cint i, len;
len1053fs/binfmt_elf.clen = current->mm->arg_end - current->mm->arg_start;
len1054fs/binfmt_elf.clen = len >= ELF_PRARGSZ ? ELF_PRARGSZ : len;
len1056fs/binfmt_elf.c(const char *)current->mm->arg_start, len);
len1057fs/binfmt_elf.cfor(i = 0; i < len; i++)
len1060fs/binfmt_elf.cpsinfo.pr_psargs[len] = 0;
len1148fs/binfmt_elf.cunsigned long len = vma->vm_end - vma->vm_start;
len1154fs/binfmt_elf.cprintk("elf_core_dump: writing %08lx %lx\n", addr, len);
len1156fs/binfmt_elf.cDUMP_WRITE((void *)addr, 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;
len391fs/exec.cint len, offset = 0;
len407fs/exec.clen=0;    /* remember zero-padding */
len409fs/exec.clen++;
len411fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
len415fs/exec.cwhile (len) {
len416fs/exec.c--p; --tmp; --len;
len870fs/exec.cunsigned int len;
len910fs/exec.clen = PAGE_ALIGN(ex.a_text + ex.a_data);
len912fs/exec.cif (bss > len)
len913fs/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))) {
len303fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
len321fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len337fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len345fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len380fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len396fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
len402fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len447fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len524fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
len532fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len578fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
len587fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len621fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
len651fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len660fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len676fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len691fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len698fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len36fs/ext2/balloc.c#define in_range(b, first, len)    ((b) >= (first) && (b) <= (first) + (len) - 1)
len44fs/ext2/namei.cstatic int ext2_match (int len, const char * const name,
len47fs/ext2/namei.cif (!de || !de->inode || len > EXT2_NAME_LEN)
len52fs/ext2/namei.cif (!len && de->name_len == 1 && (de->name[0] == '.') &&
len55fs/ext2/namei.cif (len != de->name_len)
len57fs/ext2/namei.creturn !memcmp(name, de->name, len);
len165fs/ext2/namei.cint ext2_lookup (struct inode * dir, const char * name, int len,
len179fs/ext2/namei.cif (dcache_lookup(dir, name, len, &ino)) {
len192fs/ext2/namei.cif (!(bh = ext2_find_entry (dir, name, len, &de))) {
len194fs/ext2/namei.cdcache_add(dir, name, len, 0);
len199fs/ext2/namei.cdcache_add(dir, name, len, ino);
len367fs/ext2/namei.cint ext2_create (struct inode * dir,const char * name, int len, int mode,
len386fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len408fs/ext2/namei.cint ext2_mknod (struct inode * dir, const char * name, int len, int mode,
len418fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len450fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len472fs/ext2/namei.cint ext2_mkdir (struct inode * dir, const char * name, int len, int mode)
len481fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len524fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len607fs/ext2/namei.cint ext2_rmdir (struct inode * dir, const char * name, int len)
len618fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len688fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
len700fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len749fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
len798fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len807fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len830fs/ext2/namei.cconst char * name, int len)
len851fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len858fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len363fs/hpfs/hpfs.hunsigned char len, name[15];    /* true length, truncated name */
len236fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len);
len244fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len252fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
len254fs/hpfs/hpfs_fs.cunsigned len);
len528fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len)
len531fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
len944fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
len951fs/hpfs/hpfs_fs.cwhile (len--) {
len954fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
len976fs/hpfs/hpfs_fs.cunsigned len)
len980fs/hpfs/hpfs_fs.cwhile (len--) {
len982fs/hpfs/hpfs_fs.cif (c == '\r' && (len == 0 || *in == '\n'));
len1101fs/hpfs/hpfs_fs.cstatic int hpfs_lookup(struct inode *dir, const char *name, int len,
len1122fs/hpfs/hpfs_fs.cif (name[0] == '.' && len == 1)
len1124fs/hpfs/hpfs_fs.celse if (name[0] == '.' && name[1] == '.' && len == 2)
len1129fs/hpfs/hpfs_fs.cde = map_dirent(dir, dir->i_hpfs_dno, name, len, &qbh);
len1224fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len1253fs/hpfs/hpfs_fs.cl = len < de->namelen ? len : de->namelen;
len1260fs/hpfs/hpfs_fs.ct = len - de->namelen;
len1277fs/hpfs/hpfs_fs.cname, len, qbh);
len1334fs/hpfs/hpfs_fs.cstatic void translate_hpfs_name(const unsigned char * from, int len, char * to, int lowercase)
len1336fs/hpfs/hpfs_fs.cwhile (len > 0) {
len1338fs/hpfs/hpfs_fs.clen--;
len80fs/isofs/dir.cstatic int isofs_name_translate(char * old, int len, char * new)
len84fs/isofs/dir.cfor (i = 0; i < len; i++) {
len92fs/isofs/dir.cif (c == '.' && i == len - 3 && old[i + 1] == ';' && old[i + 2] == '1')
len96fs/isofs/dir.cif (c == ';' && i == len - 2 && old[i + 1] == '1')
len120fs/isofs/dir.cint len, rrflag;
len227fs/isofs/dir.clen = de->name_len[0];
len229fs/isofs/dir.crrflag = get_rock_ridge_filename(de, &name, &len, inode);
len233fs/isofs/dir.crrflag = filldir(dirent, name, len, filp->f_pos, inode_number);
len234fs/isofs/dir.cdcache_add(inode, name, len, inode_number);
len244fs/isofs/dir.clen = isofs_name_translate(name, len, tmpname);
len245fs/isofs/dir.cif (filldir(dirent, tmpname, len, filp->f_pos, inode_number) < 0)
len247fs/isofs/dir.cdcache_add(inode, tmpname, len, inode_number);
len252fs/isofs/dir.cif (filldir(dirent, name, len, filp->f_pos, inode_number) < 0)
len255fs/isofs/dir.cdcache_add(inode, name, len, inode_number);
len31fs/isofs/namei.cstatic int isofs_match(int len,const char * name, char * compare, int dlen)
len40fs/isofs/namei.cif (!len)
len49fs/isofs/namei.cif (len <= 2) printk("Match: %d %d %s %d %d \n",len,dlen,compare,de->name[0], dlen);
len52fs/isofs/namei.cif (dlen != len)
len54fs/isofs/namei.creturn !memcmp(name, compare, len);
len222fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
len229fs/isofs/namei.cprintk("lookup: %x %d\n",dir->i_ino, len);
len242fs/isofs/namei.cif (dcache_lookup(dir, name, len, &ino)) ino_back = dir->i_ino;
len245fs/isofs/namei.cif (!(bh = isofs_find_entry(dir,name,len, &ino, &ino_back))) {
len250fs/isofs/namei.cdcache_add(dir, name, len, ino);
len87fs/isofs/rock.clen = cont_size; \
len103fs/isofs/rock.cint len;
len118fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len124fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len126fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len128fs/isofs/rock.cchr += rr->len; 
len129fs/isofs/rock.clen -= rr->len;
len176fs/isofs/rock.cint len;
len184fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len190fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len192fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len194fs/isofs/rock.cchr += rr->len; 
len195fs/isofs/rock.clen -= rr->len;
len225fs/isofs/rock.cif((strlen(retname) + rr->len - 5) >= 254) {
len229fs/isofs/rock.cstrncat(retname, rr->u.NM.name, rr->len - 5);
len230fs/isofs/rock.cretnamlen += rr->len - 5;
len259fs/isofs/rock.cint len;
len265fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len273fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len275fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len277fs/isofs/rock.cchr += rr->len; 
len278fs/isofs/rock.clen -= rr->len;
len338fs/isofs/rock.cslen = rr->len - 5;
len345fs/isofs/rock.cinode->i_size += slp->len;
len360fs/isofs/rock.cslen -= slp->len + 2;
len361fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len418fs/isofs/rock.cint len;
len460fs/isofs/rock.cSETUP_ROCK_RIDGE(raw_inode, chr, len);
len463fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len466fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len468fs/isofs/rock.cchr += rr->len; 
len469fs/isofs/rock.clen -= rr->len;
len481fs/isofs/rock.cslen = rr->len - 5;
len492fs/isofs/rock.cstrncat(rpnt,slp->text, slp->len);
len507fs/isofs/rock.cslen -= slp->len + 2;
len508fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len44fs/isofs/rock.hunsigned char len;
len87fs/isofs/rock.hunsigned char len;
len27fs/minix/namei.cstatic inline int namecompare(int len, int maxlen,
len30fs/minix/namei.cif (len > maxlen)
len32fs/minix/namei.cif (len < maxlen && buffer[len])
len34fs/minix/namei.creturn !memcmp(name, buffer, len);
len44fs/minix/namei.cstatic int minix_match(int len, const char * name,
len52fs/minix/namei.cif (!de->inode || len > info->s_namelen)
len55fs/minix/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len57fs/minix/namei.creturn namecompare(len,info->s_namelen,name,de->name);
len111fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
len125fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
len215fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
len234fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
len250fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len259fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len291fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len307fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
len320fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len358fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len433fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
len441fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len490fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
len500fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len544fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
len574fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len583fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
len599fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len615fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len622fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len41fs/msdos/namei.cstatic int msdos_format_name(char conv,const char *name,int len,char *res,
len49fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len52fs/msdos/namei.cwhile (len--) *res++ = '.';
len57fs/msdos/namei.cfor (walk = res; len && walk-res < 8; walk++) {
len59fs/msdos/namei.clen--;
len69fs/msdos/namei.cif (conv == 's' && len && c != '.') {
len71fs/msdos/namei.clen--;
len74fs/msdos/namei.cwhile (c != '.' && len--) c = *name++;
len77fs/msdos/namei.cwhile (len > 0 && walk-res < MSDOS_NAME) {
len79fs/msdos/namei.clen--;
len90fs/msdos/namei.cif (conv == 's' && len) return -EINVAL;
len101fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
len107fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len113fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
len131fs/msdos/namei.cif (len == 1 && name[0] == '.') {
len135fs/msdos/namei.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len143fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
len217fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
len227fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len266fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
len275fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len317fs/msdos/namei.cif (msdos_rmdir(dir,name,len) < 0)
len350fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
len361fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len363fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
len391fs/msdos/namei.cint len,
len402fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
len425fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
len427fs/msdos/namei.creturn msdos_unlinkx (dir,name,len,1);
len432fs/msdos/namei.cint msdos_unlink_umsdos(struct inode *dir,const char *name,int len)
len434fs/msdos/namei.creturn msdos_unlinkx (dir,name,len,0);
len153fs/namei.cint lookup(struct inode * dir,const char * name, int len,
len164fs/namei.cif (len==2 && name[0] == '.' && name[1] == '.') {
len184fs/namei.cif (!len) {
len188fs/namei.creturn dir->i_op->lookup(dir,name,len,result);
len219fs/namei.cint len,error;
len235fs/namei.cfor(len=0;(c = *(pathname++))&&(c != '/');len++)
len240fs/namei.cerror = lookup(base,thisname,len,&inode);
len254fs/namei.c*namelen = len;
len28fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
len30fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len32fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
len33fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
len34fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
len35fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
len38fs/nfs/dir.cconst char *name, int len);
len39fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
len299fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
len304fs/nfs/dir.cchar name[len > NFS_MAXNAMLEN? 1 : len+1];
len313fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len317fs/nfs/dir.cmemcpy(name,__name,len);
len318fs/nfs/dir.cname[len] = '\0';
len319fs/nfs/dir.cif (len == 1 && name[0] == '.') { /* cheat for "." */
len340fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len354fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len375fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
len388fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len407fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
len419fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len434fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
len443fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len454fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
len463fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len474fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
len485fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len503fs/nfs/dir.cconst char *name, int len)
len519fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len72fs/nfs/file.cint    len;    /* size of data */
len125fs/nfs/file.c&& (cache[i].file_pos + cache[i].len >= pos + count)
len183fs/nfs/file.ccache[tail].len = result;
len101fs/nfs/proc.c#define QUADLEN(len) (((len) + 3) >> 2)
len117fs/nfs/proc.cint len = strlen(string);
len118fs/nfs/proc.cint quadlen = QUADLEN(len);
len121fs/nfs/proc.c*p++ = htonl(len);
len122fs/nfs/proc.cmemcpy(p, string, len);
len128fs/nfs/proc.cunsigned int len = ntohl(*p++);
len129fs/nfs/proc.cif (len > maxlen)
len131fs/nfs/proc.cmemcpy(string, p, len);
len132fs/nfs/proc.cstring[len] = '\0';
len133fs/nfs/proc.creturn p + QUADLEN(len);
len136fs/nfs/proc.cstatic inline int *xdr_decode_string2(int *p, char **string, unsigned int *len,
len139fs/nfs/proc.c*len = ntohl(*p++);
len140fs/nfs/proc.cif (*len > maxlen)
len143fs/nfs/proc.creturn p + QUADLEN(*len);
len147fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, char *data, int len)
len149fs/nfs/proc.cint quadlen = QUADLEN(len);
len152fs/nfs/proc.c*p++ = htonl(len);
len153fs/nfs/proc.cmemcpy_fromfs(p, data, len);
len160fs/nfs/proc.cunsigned len = *lenp = ntohl(*p++);
len161fs/nfs/proc.cif (len > maxlen)
len164fs/nfs/proc.cmemcpy_tofs(data, p, len);
len166fs/nfs/proc.cmemcpy(data, p, len);
len167fs/nfs/proc.creturn p + QUADLEN(len);
len345fs/nfs/proc.cint **p0, char **string, unsigned int *len, unsigned int maxlen)
len361fs/nfs/proc.cif (!(p = xdr_decode_string2(p, string, len, maxlen))) {
len385fs/nfs/proc.cint len;
len404fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
len409fs/nfs/proc.cstatus = len;
len410fs/nfs/proc.cPRINTK("NFS reply read %d\n", len);
len60fs/nfs/sock.cint len;
len77fs/nfs/sock.clen = ((char *) end) - ((char *) start);
len107fs/nfs/sock.cresult = sock->ops->sendto(sock, (void *) start, len, 0, 0,
len54fs/nfs/symlink.cunsigned int len;
len77fs/nfs/symlink.c&res, &len, NFS_MAXPATHLEN);
len87fs/nfs/symlink.cmemcpy(res2, res, len);
len88fs/nfs/symlink.cres2[len] = '\0';
len101fs/nfs/symlink.cunsigned int len;
len111fs/nfs/symlink.c&res, &len, buflen);
len114fs/nfs/symlink.cmemcpy_tofs(buffer, res, len);
len115fs/nfs/symlink.cput_user('\0', buffer + len);
len116fs/nfs/symlink.cerror = len;
len187fs/proc/array.cint i, len;
len192fs/proc/array.clen = sprintf(buffer,
len212fs/proc/array.clen += sprintf(buffer + len, " %u", kstat.interrupts[i]);
len213fs/proc/array.clen += sprintf(buffer + len,
len218fs/proc/array.creturn len;
len638fs/proc/array.cint len;
len656fs/proc/array.clen = sprintf(line, MAPS_LINE_FORMAT,
len660fs/proc/array.cif (column >= len) {
len667fs/proc/array.ci = len-column;
len673fs/proc/array.cif (column >= 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) {
len186fs/proc/net.cstatic int proc_lookupnet(struct inode * dir,const char * name, int len,
len199fs/proc/net.cif (!proc_match(len, name, de))
len88fs/proc/root.cstatic int proc_lookuproot(struct inode * dir,const char * name, int len,
len102fs/proc/root.cwhile (i-- > 0 && !proc_match(len,name,root_dir+i))
len114fs/proc/root.cwhile (len-- > 0) {
len136fs/proc/scsi.cstatic int proc_lookupscsi(struct inode * dir, const char * name, int len,
len159fs/proc/scsi.cif (!proc_match(len, name, de))
len203fs/proc/scsi.cint len, pos, begin;
len206fs/proc/scsi.cpos = len = sprintf(buffer, 
len209fs/proc/scsi.clen = 0;
len214fs/proc/scsi.clen -= (offset - begin);
len215fs/proc/scsi.cif(len > length)
len216fs/proc/scsi.clen = length;
len218fs/proc/scsi.creturn(len);
len35fs/smbfs/dir.cget_pname(struct inode *dir, const char *name, int len,
len39fs/smbfs/dir.cget_pname_static(struct inode *dir, const char *name, int len,
len53fs/smbfs/dir.cint len, struct inode **result);
len56fs/smbfs/dir.csmb_create(struct inode *dir, const char *name, int len, int mode, 
len60fs/smbfs/dir.csmb_mkdir(struct inode *dir, const char *name, int len, int mode);
len63fs/smbfs/dir.csmb_rmdir(struct inode *dir, const char *name, int len);
len66fs/smbfs/dir.csmb_unlink(struct inode *dir, const char *name, int len);
len341fs/smbfs/dir.cget_pname_static(struct inode *dir, const char *name, int len,
len345fs/smbfs/dir.cint   parentlen  = SMB_INOP(dir)->finfo.len;
len358fs/smbfs/dir.cif (len > SMB_MAXNAMELEN) {
len363fs/smbfs/dir.cif (len == 0 || (len == 1 && name[0] == '.')) {
len371fs/smbfs/dir.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len393fs/smbfs/dir.clen = pos - parentname;
len395fs/smbfs/dir.cmemcpy(path, parentname, len);
len396fs/smbfs/dir.cpath[len] = '\0';
len400fs/smbfs/dir.cif (len + parentlen + 2 > SMB_MAXPATHLEN) 
len405fs/smbfs/dir.cmemcpy(path + parentlen + 1, name, len);
len406fs/smbfs/dir.cpath[parentlen + 1 + len] = '\0';
len407fs/smbfs/dir.clen = parentlen + len + 1;
len422fs/smbfs/dir.c*res_len = len;
len430fs/smbfs/dir.cget_pname(struct inode *dir, const char *name, int len,
len437fs/smbfs/dir.cif ((res = get_pname_static(dir,name,len,result,&result_len) != 0)) {
len466fs/smbfs/dir.cint error, len;
len480fs/smbfs/dir.clen = strlen(path);
len484fs/smbfs/dir.cpath, len, &newent);
len509fs/smbfs/dir.cnew_inode_info->finfo.len    = len;
len547fs/smbfs/dir.csmb_kfree_s(i->finfo.path, i->finfo.len+1);
len563fs/smbfs/dir.croot->finfo.len  = strlen(root->finfo.path);
len579fs/smbfs/dir.cif (root->finfo.len == 0) {
len585fs/smbfs/dir.croot->finfo.path, root->finfo.len,
len656fs/smbfs/dir.csmb_lookup(struct inode *dir, const char *__name, int len,
len676fs/smbfs/dir.cif (len == 0 || (len == 1 && __name[0] == '.')) {
len682fs/smbfs/dir.cif ((error = get_pname(dir, __name, len, &name, &len)) < 0) {
len743fs/smbfs/dir.cerror = smb_proc_getattr(SMB_SERVER(dir), name, len, &finfo);
len763fs/smbfs/dir.csmb_create(struct inode *dir, const char *name, int len, int mode,
len779fs/smbfs/dir.cif ((error = get_pname(dir, name, len, &path, &len)) < 0) {
len790fs/smbfs/dir.cerror = smb_proc_create(SMB_SERVER(dir), path, len, &entry);
len809fs/smbfs/dir.csmb_mkdir(struct inode *dir, const char *name, int len, int mode)
len821fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len826fs/smbfs/dir.cif ((error = smb_proc_mkdir(SMB_SERVER(dir), path, len)) == 0) {
len835fs/smbfs/dir.csmb_rmdir(struct inode *dir, const char *name, int len)
len845fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len852fs/smbfs/dir.cif ((error = smb_proc_rmdir(SMB_SERVER(dir), path, len)) == 0)
len860fs/smbfs/dir.csmb_unlink(struct inode *dir, const char *name, int len)
len870fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len877fs/smbfs/dir.cif ((error = smb_proc_unlink(SMB_SERVER(dir), path, len)) == 0)
len50fs/smbfs/file.cdirent->path, dirent->len,
len85fs/smbfs/proc.csmb_encode_smb_length(byte *p, dword len)
len88fs/smbfs/proc.cp[2] = (len & 0xFF00) >> 8;
len89fs/smbfs/proc.cp[3] = (len & 0xFF);
len90fs/smbfs/proc.cif (len > 0xFFFF)
len96fs/smbfs/proc.csmb_encode_dialect(byte *p, const byte *name, int len)
len100fs/smbfs/proc.creturn p + len + 1;
len104fs/smbfs/proc.csmb_encode_ascii(byte *p, const byte *name, int len)
len108fs/smbfs/proc.creturn p + len + 1;
len112fs/smbfs/proc.csmb_encode_vblock(byte *p, const byte *data, word len, int fs)
len115fs/smbfs/proc.cp = smb_encode_word(p, len);
len117fs/smbfs/proc.cmemcpy_fromfs(p, data, len);
len119fs/smbfs/proc.cmemcpy(p, data, len);
len120fs/smbfs/proc.creturn p + len;
len126fs/smbfs/proc.cword len;
len133fs/smbfs/proc.clen = WVAL(p, 1);
len137fs/smbfs/proc.cmemcpy_tofs(data, p, len);
len139fs/smbfs/proc.cmemcpy(data, p, len);
len141fs/smbfs/proc.c*data_len = len;
len143fs/smbfs/proc.creturn p + len;
len149fs/smbfs/proc.cint len, pad = 0;
len151fs/smbfs/proc.clen = strlen(name);
len153fs/smbfs/proc.cif (len < 16)
len154fs/smbfs/proc.cpad = 16 - len;
len156fs/smbfs/proc.c*p ++ = 2 * (len + pad);
len362fs/smbfs/proc.cint i, j, len;
len369fs/smbfs/proc.clen = smb_len(packet), smb_valid_packet(packet));
len379fs/smbfs/proc.cif (len > 100)
len380fs/smbfs/proc.clen = 100;
len382fs/smbfs/proc.cfor (i = 0; i < len; i += 10) {
len385fs/smbfs/proc.cif (j < len)
len391fs/smbfs/proc.cif (j < len)
len545fs/smbfs/proc.csmb_proc_open(struct smb_server *server, const char *pathname, int len,
len558fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
len561fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
len574fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
len577fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
len689fs/smbfs/proc.csmb_proc_do_create(struct smb_server *server, const char *path, int len, 
len698fs/smbfs/proc.cp = smb_setup_header(server, command, 3, len + 2);
len701fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len721fs/smbfs/proc.csmb_proc_create(struct smb_server *server, const char *path, int len,
len724fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBcreate);
len728fs/smbfs/proc.csmb_proc_mknew(struct smb_server *server, const char *path, int len,
len731fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBmknew);
len761fs/smbfs/proc.csmb_proc_mkdir(struct smb_server *server, const char *path, const int len)
len769fs/smbfs/proc.cp = smb_setup_header(server, SMBmkdir, 0, 2 + len);
len770fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len782fs/smbfs/proc.csmb_proc_rmdir(struct smb_server *server, const char *path, const int len)
len790fs/smbfs/proc.cp = smb_setup_header(server, SMBrmdir, 0, 2 + len);
len791fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len803fs/smbfs/proc.csmb_proc_unlink(struct smb_server *server, const char *path, const int len)
len812fs/smbfs/proc.cp = smb_setup_header(server, SMBunlink, 1, 2 + len);
len814fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len1010fs/smbfs/proc.cfinfo->len  = strlen(finfo->path);
len1025fs/smbfs/proc.cfinfo->len  = strlen(finfo->path);
len1061fs/smbfs/proc.cfinfo->len = namelen;
len1312fs/smbfs/proc.csmb_proc_getattr_core(struct smb_server *server, const char *path, int len, 
len1324fs/smbfs/proc.cp = smb_setup_header(server, SMBgetatr, 0, 2 + len);
len1325fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len1371fs/smbfs/proc.csmb_proc_getattr(struct smb_server *server, const char *path, int len, 
len1379fs/smbfs/proc.cif ((result=smb_proc_open(server,path,len,
len1383fs/smbfs/proc.creturn smb_proc_getattr_core(server,path,len,entry);
len1398fs/smbfs/proc.creturn smb_proc_getattr_core(server, path, len, entry);
len1407fs/smbfs/proc.cconst char *path, int len,
len1417fs/smbfs/proc.cp = smb_setup_header(server, SMBsetatr, 8, 4 + len);
len1420fs/smbfs/proc.cp = smb_encode_ascii(p, path, len);
len1474fs/smbfs/proc.creturn smb_proc_setattr_core(server, finfo->path, finfo->len,
len34fs/smbfs/sock.csmb_data_callback(struct sock *sk,int len)
len184fs/smbfs/sock.cint len, result;
len220fs/smbfs/sock.clen = smb_len(peek_buf) + 4; 
len221fs/smbfs/sock.cif (len > server->max_xmit) { 
len223fs/smbfs/sock.clen, server->max_xmit);
len230fs/smbfs/sock.cwhile (already_read < len) {
len235fs/smbfs/sock.clen - already_read, 0, 0,
len437fs/smbfs/sock.cint len, result, result2;
len462fs/smbfs/sock.clen = smb_len(buffer) + 4;
len464fs/smbfs/sock.cDDPRINTK("smb_request: len = %d cmd = 0x%X\n", len, buffer[8]);
len471fs/smbfs/sock.cresult = sock->ops->send(sock, (void *)buffer, len, 0, 0);
len516fs/smbfs/sock.cint len, result, result2;
len541fs/smbfs/sock.clen = smb_len(buffer) + 4;
len543fs/smbfs/sock.cDDPRINTK("smb_request: len = %d cmd = 0x%X\n", len, buffer[8]);
len550fs/smbfs/sock.cresult = sock->ops->send(sock, (void *)buffer, len, 0, 0);
len100fs/super.cint err, len;
len109fs/super.clen = strlen(tmp->name) + 1;
len110fs/super.cerr = verify_area(VERIFY_WRITE, buf, len);
len113fs/super.cmemcpy_tofs(buf, tmp->name, len);
len158fs/super.cint len = 0;
len162fs/super.cwhile (tmp && len < PAGE_SIZE - 80) {
len163fs/super.clen += sprintf(buf+len, "%s\t%s\n",
len168fs/super.creturn len;
len29fs/sysv/namei.cstatic inline int namecompare(int len, int maxlen,
len32fs/sysv/namei.cif (len > maxlen)
len34fs/sysv/namei.cif (len < maxlen && buffer[len])
len36fs/sysv/namei.creturn !memcmp(name, buffer, len);
len46fs/sysv/namei.cstatic int sysv_match(int len, const char * name, struct sysv_dir_entry * de)
len48fs/sysv/namei.cif (!de->inode || len > SYSV_NAMELEN)
len51fs/sysv/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len53fs/sysv/namei.creturn namecompare(len,SYSV_NAMELEN,name,de->name);
len107fs/sysv/namei.cint sysv_lookup(struct inode * dir,const char * name, int len,
len121fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
len208fs/sysv/namei.cint sysv_create(struct inode * dir,const char * name, int len, int mode,
len227fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
len243fs/sysv/namei.cint sysv_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len252fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len284fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len300fs/sysv/namei.cint sysv_mkdir(struct inode * dir, const char * name, int len, int mode)
len311fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len349fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len425fs/sysv/namei.cint sysv_rmdir(struct inode * dir, const char * name, int len)
len433fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len481fs/sysv/namei.cint sysv_unlink(struct inode * dir, const char * name, int len)
len491fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len534fs/sysv/namei.cint sysv_symlink(struct inode * dir, const char * name, int len, const char * symname)
len569fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len578fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
len594fs/sysv/namei.cint sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len610fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len617fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len201fs/umsdos/dir.c,info.fake.len,&inode);
len606fs/umsdos/dir.cint len)
len616fs/umsdos/dir.c&& len == 3
len626fs/umsdos/dir.cint len,
len633fs/umsdos/dir.cif (len == 1 && name[0] == '.'){
len637fs/umsdos/dir.c}else if (len == 2 && name[0] == '.' && name[1] == '.'){
len669fs/umsdos/dir.c}else if (umsdos_is_pseudodos(dir,name,len)){
len679fs/umsdos/dir.cret = umsdos_parse (name,len,&info);
len682fs/umsdos/dir.c,info.fake.len));
len694fs/umsdos/dir.cret = umsdos_real_lookup (dir,info.fake.fname,info.fake.len,result);
len735fs/umsdos/dir.cint len,
len738fs/umsdos/dir.creturn umsdos_lookup_x(dir,name,len,result,0);
len767fs/umsdos/dir.cint len;
len769fs/umsdos/dir.clen = (int)(pt - start);
len773fs/umsdos/dir.cret = umsdos_rlookup_x(dir,start,len,result,1);
len775fs/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);
len159fs/umsdos/ioctl.c,info.fake.fname,info.fake.len+1);
len77fs/umsdos/mangle.cchar *pt = info->fake.fname + info->fake.len;
len102fs/umsdos/mangle.cinfo->fake.len += 4;
len111fs/umsdos/mangle.cint umsdos_evalrecsize (int len)
len114fs/umsdos/mangle.cint nbrec = 1+((len-1+(dirent.name-(char*)&dirent))
len123fs/umsdos/mangle.cint umsdos_evalrecsize_old (int len)
len126fs/umsdos/mangle.cint size = len + (dirent.name-(char*)&dirent);
len139fs/umsdos/mangle.cint len,
len148fs/umsdos/mangle.cif (len > UMSDOS_MAXNAME) len = UMSDOS_MAXNAME;
len156fs/umsdos/mangle.cint msdos_len = len;
len195fs/umsdos/mangle.cif (len<=(8+1+3)){
len197fs/umsdos/mangle.cconst char *endpt = fname + len;
len258fs/umsdos/mangle.c|| (firstpt == NULL && len > 8)
len259fs/umsdos/mangle.c|| (len == UMSDOS_EMD_NAMELEN
len305fs/umsdos/mangle.cstrncpy (info->fake.fname,fname,len);
len307fs/umsdos/mangle.cbase_len = firstpt != NULL ? (int)(firstpt - fname) : len;
len376fs/umsdos/mangle.cinfo->fake.len = msdos_len;
len378fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
len379fs/umsdos/mangle.cinfo->entry.name_len = len;
len385fs/umsdos/mangle.cinfo->recsize = umsdos_evalrecsize (len);
len165fs/umsdos/namei.cint len,
len169fs/umsdos/namei.cif (umsdos_is_pseudodos(dir,name,len)){
len180fs/umsdos/namei.c&& (len == 1 || (len == 2 && name[1] == '.'))){
len206fs/umsdos/namei.cint len,        /* Length of the name */
len214fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len217fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len233fs/umsdos/namei.cret = msdos_create (dir,info.fake.fname,info.fake.len
len352fs/umsdos/namei.cPRINTK (("ret %d %d ",ret,new_info.fake.len));
len358fs/umsdos/namei.c,old_info.fake.fname,old_info.fake.len
len360fs/umsdos/namei.c,new_info.fake.fname,new_info.fake.len);
len427fs/umsdos/namei.cint len,
len446fs/umsdos/namei.cret = umsdos_create_any (dir,name,len,mode,0,flags,&inode);
len449fs/umsdos/namei.cint len = strlen(symname);
len453fs/umsdos/namei.cret = umsdos_file_write_kmem (inode,&filp,(char*)symname,len);
len456fs/umsdos/namei.cif (ret != len){
len465fs/umsdos/namei.cUMSDOS_unlink (dir,name,len);
len480fs/umsdos/namei.cint len,
len483fs/umsdos/namei.creturn umsdos_symlink_x (dir,name,len,symname,S_IFLNK|0777,0);
len492fs/umsdos/namei.cint len)
len571fs/umsdos/namei.c}else if ((ret = umsdos_nevercreat(dir,name,len,-EPERM))==0){
len621fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len
len638fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len,path
len671fs/umsdos/namei.cint len,        /* Length of the name */
len676fs/umsdos/namei.creturn umsdos_create_any (dir,name,len,mode,0,0,result);
len684fs/umsdos/namei.cint len,
len687fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len690fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len707fs/umsdos/namei.cret = msdos_mkdir (dir,info.fake.fname,info.fake.len,mode);
len723fs/umsdos/namei.c,info.fake.len,&subdir);
len750fs/umsdos/namei.cint len,
len769fs/umsdos/namei.cint ret = umsdos_create_any (dir,name,len,mode,rdev,0,&inode);
len780fs/umsdos/namei.cint len)
len869fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len873fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&sdir);
len899fs/umsdos/namei.cumsdos_parse (name,len,&info);
len904fs/umsdos/namei.c,info.fake.len);
len934fs/umsdos/namei.cint len)
len936fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len939fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len964fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&inode);
len993fs/umsdos/namei.c,info.fake.len);
len90fs/umsdos/rdir.cint len,
len97fs/umsdos/rdir.c&& len == 2
len110fs/umsdos/rdir.cret = umsdos_real_lookup (dir,name,len,result);
len134fs/umsdos/rdir.cint len,
len137fs/umsdos/rdir.creturn umsdos_rlookup_x(dir,name,len,result,0);
len143fs/umsdos/rdir.cint len)
len160fs/umsdos/rdir.cif (umsdos_is_pseudodos(dir,name,len)){
len173fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
len177fs/umsdos/rdir.cret = UMSDOS_rlookup (dir,name,len,&sdir);
len196fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
len35fs/xiafs/namei.cstatic int xiafs_match(int len, const char * name, struct xiafs_direct * dep)
len39fs/xiafs/namei.cif (!dep || !dep->d_ino || len > _XIAFS_NAME_LEN)
len42fs/xiafs/namei.cif (!len && (dep->d_name[0]=='.') && (dep->d_name[1]=='\0'))
len44fs/xiafs/namei.cif (len != dep->d_name_len)
len46fs/xiafs/namei.cfor (i=0; i < len; i++)
len119fs/xiafs/namei.cint xiafs_lookup(struct inode * dir, const char * name, int len,
len133fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
len248fs/xiafs/namei.cint xiafs_create(struct inode * dir, const char * name, int len, int mode,
len266fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len282fs/xiafs/namei.cint xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
len290fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len323fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len339fs/xiafs/namei.cint xiafs_mkdir(struct inode * dir, const char * name, int len, int mode)
len345fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len389fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len489fs/xiafs/namei.cint xiafs_rmdir(struct inode * dir, const char * name, int len)
len497fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len541fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
len551fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len589fs/xiafs/namei.cint len, const char * symname)
len597fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
len624fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len641fs/xiafs/namei.cconst char * name, int len)
len656fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
len663fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len17include/asm-alpha/checksum.hunsigned short len,
len33include/asm-alpha/checksum.hextern unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum);
len42include/asm-alpha/checksum.hunsigned int csum_partial_copy( char *src, char *dst, int len, int sum);
len56include/asm-alpha/checksum.hextern unsigned short ip_compute_csum(unsigned char * buff, int len);
len124include/asm-alpha/io.h#define memset_io(addr,c,len)    (memset_io)((unsigned long)(addr),(c),(len))
len125include/asm-alpha/io.h#define memcpy_fromio(to,from,len)  (memcpy_fromio)((to),(unsigned long)(from),(len))
len126include/asm-alpha/io.h#define memcpy_toio(to,from,len)  (memcpy_toio)((unsigned long)(to),(from),(len))
len7include/asm-alpha/ipsum.hextern inline unsigned short udp_check(struct udphdr *uh, int len, u32 saddr, u32 daddr)
len16include/asm-alpha/ipsum.hextern inline unsigned short tcp_check(struct tcphdr *th, int len, u32 saddr, u32 daddr)
len28include/asm-alpha/ipsum.hextern inline unsigned short ip_compute_csum(unsigned char * buff, int len)
len16include/asm-i386/checksum.hunsigned int csum_partial(unsigned char * buff, int len, unsigned int sum);
len26include/asm-i386/checksum.hunsigned int csum_partial_copy( char *src, char *dst, int len, int sum);
len36include/asm-i386/checksum.hunsigned int csum_partial_copy_fromuser( char *src, char *dst, int len, int sum);
len83include/asm-i386/checksum.hunsigned short len,
len98include/asm-i386/checksum.h: "0" (daddr), "1"(saddr), "r"((ntohs(len)<<16)+proto*256), "r"(sum));
len107include/asm-i386/checksum.hstatic inline unsigned short ip_compute_csum(unsigned char * buff, int len) {
len119include/asm-i386/checksum.h: "0" (csum_partial(buff, len, 0)));
len11include/asm-sparc/ipsum.hextern inline unsigned short udp_check(struct udphdr *uh, int len, u32 saddr, u32 daddr)
len20include/asm-sparc/ipsum.hextern inline unsigned short tcp_check(struct tcphdr *th, int len, u32 saddr, u32 daddr)
len32include/asm-sparc/ipsum.hextern inline unsigned short ip_compute_csum(unsigned char * buff, int len)
len182include/asm-sparc/openprom.hvoid  (*pv_putstr)(char *str, int len);
len197include/asm-sparc/openprom.hvoid  (*v0_eval)(int len, char *str);
len299include/asm-sparc/openprom.hint  (*no_setprop)(int node, char*  name, char*  val, int len);
len76include/asm-sparc/string.hextern __inline__ char *strncat(char *dest, const char *src, size_t len)
len80include/asm-sparc/string.hif (len) {
len84include/asm-sparc/string.hif (--len == 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);
len209include/linux/mm.hextern unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
len145include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len,
len147include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
len149include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
len150include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
len151include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
len152include/linux/msdos_fs.hextern int msdos_unlink_umsdos(struct inode *dir,const char *name,int len);
len111include/linux/net.hint  (*listen)  (struct socket *sock, int len);
len112include/linux/net.hint  (*send)    (struct socket *sock, void *buff, int len, int nonblock,
len114include/linux/net.hint  (*recv)    (struct socket *sock, void *buff, int len, int nonblock,
len116include/linux/net.hint  (*sendto)  (struct socket *sock, void *buff, int len, int nonblock,
len118include/linux/net.hint  (*recvfrom)  (struct socket *sock, void *buff, int len, int nonblock,
len151include/linux/netdevice.hunsigned len);
len207include/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)
len66include/linux/skbuff.hunsigned long     len;      /* Length of actual data      */
len134include/linux/skbuff.hextern unsigned char *    skb_put(struct sk_buff *skb, int len);
len135include/linux/skbuff.hextern unsigned char *    skb_push(struct sk_buff *skb, int len);
len136include/linux/skbuff.hextern int      skb_pull(struct sk_buff *skb, int len);
len139include/linux/skbuff.hextern void      skb_reserve(struct sk_buff *skb, int len);
len140include/linux/skbuff.hextern void       skb_trim(struct sk_buff *skb, int len);
len308include/linux/skbuff.hextern __inline__ unsigned char *skb_put(struct sk_buff *skb, int len)
len311include/linux/skbuff.hskb->tail+=len;
len312include/linux/skbuff.hskb->len+=len;
len314include/linux/skbuff.hpanic("skput:over: %p:%d", __builtin_return_address(0),len);
len318include/linux/skbuff.hextern __inline__ unsigned char *skb_push(struct sk_buff *skb, int len)
len320include/linux/skbuff.hskb->data-=len;
len321include/linux/skbuff.hskb->len+=len;
len323include/linux/skbuff.hpanic("skpush:under: %p:%d", __builtin_return_address(0),len);
len327include/linux/skbuff.hextern __inline__ int skb_pull(struct sk_buff *skb, int len)
len329include/linux/skbuff.hif(len>skb->len)
len330include/linux/skbuff.hlen=skb->len;
len331include/linux/skbuff.hskb->data+=len;
len332include/linux/skbuff.hskb->len-=len;
len333include/linux/skbuff.hreturn len;
len346include/linux/skbuff.hextern __inline__ void skb_reserve(struct sk_buff *skb, int len)
len348include/linux/skbuff.hskb->data+=len;
len349include/linux/skbuff.hskb->tail+=len;
len352include/linux/skbuff.hextern __inline__ void skb_trim(struct sk_buff *skb, int len)
len354include/linux/skbuff.hif(skb->len>len)
len356include/linux/skbuff.hskb->len=len;
len357include/linux/skbuff.hskb->tail=skb->data+len;
len101include/linux/smb.hint             len;  /* Namelength. */
len128include/linux/smb_fs.hint len, struct smb_dirent *entry);
len135include/linux/smb_fs.hint len, struct smb_dirent *entry);
len136include/linux/smb_fs.hint smb_proc_mknew(struct smb_server *server, const char *path, int len,
len140include/linux/smb_fs.hint smb_proc_mkdir(struct smb_server *server, const char *path, const int len);
len141include/linux/smb_fs.hint smb_proc_rmdir(struct smb_server *server, const char *path, const int len);
len143include/linux/smb_fs.hconst int len);
len148include/linux/smb_fs.hint len, struct smb_dirent *entry);
len152include/linux/smb_fs.hint smb_proc_chkpath(struct smb_server *server, char *path, int len,
len178include/linux/soundcard.hlong len;  /* Size of the wave data in bytes */
len238include/linux/soundcard.hlong len;  /* Size of the sysex data in bytes */
len624include/linux/soundcard.hint len;
len635include/linux/soundcard.hint len;  /* Length of data in bytes */
len639include/linux/soundcard.hint len;
len885include/linux/soundcard.h#define SEQ_DEFINEBUF(len)    unsigned char _seqbuf[len]; int _seqbuflen = len;int _seqbufptr = 0
len889include/linux/soundcard.h#define _SEQ_NEEDBUF(len)    if ((_seqbufptr+(len)) > _seqbuflen) seqbuf_dump()
len890include/linux/soundcard.h#define _SEQ_ADVBUF(len)    _seqbufptr += len
len907include/linux/soundcard.h#define _SEQ_NEEDBUF(len)  /* empty */
len1050include/linux/soundcard.h#define SEQ_WRPATCH(patchx, len)    {if (_seqbufptr) seqbuf_dump();\
len1051include/linux/soundcard.hif (write(seqfd, (char*)(patchx), len)==-1) \
len1053include/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);
len33include/linux/trdevice.hvoid *saddr, unsigned len);
len24include/linux/udp.hunsigned short  len;
len22include/linux/umsdos_fs.hint  len;
len67include/linux/xia_fs.hextern int xiafs_lookup(struct inode * dir,const char * name, int len, 
len69include/linux/xia_fs.hextern int xiafs_create(struct inode * dir,const char * name, int len, int mode,
len71include/linux/xia_fs.hextern int xiafs_mkdir(struct inode * dir, const char * name, int len, int mode);
len72include/linux/xia_fs.hextern int xiafs_rmdir(struct inode * dir, const char * name, int len);
len73include/linux/xia_fs.hextern int xiafs_unlink(struct inode * dir, const char * name, int len);
len74include/linux/xia_fs.hextern int xiafs_symlink(struct inode * inode, const char * name, int len,
len77include/linux/xia_fs.hconst char * name, int len);
len78include/linux/xia_fs.hextern int xiafs_mknod(struct inode * dir, const char * name, int len, 
len29include/net/eth.hvoid *saddr, unsigned len);
len32include/net/icmp.hunsigned short len, unsigned long saddr,
len54include/net/ip.hint    len;    /* length of this fragment    */
len65include/net/ip.hint    len;    /* total length of original datagram  */
len86include/net/ip.hstruct options *opt, int len,
len2include/net/ipip.hunsigned long daddr, unsigned short len, unsigned long saddr,
len33include/net/protocol.hunsigned short len, unsigned long saddr,
len37include/net/protocol.hunsigned short len, unsigned long saddr,
len27include/net/raw.hint len, int noblock, unsigned flags,
len30include/net/raw.hint len, int noblock, unsigned flags);
len222include/net/sock.hint len, int nonblock, unsigned flags);
len224include/net/sock.hint len, int nonblock, unsigned flags);
len226include/net/sock.hunsigned char *from, int len, int noblock,
len230include/net/sock.hunsigned char *from, int len, int noblock,
len237include/net/sock.hstruct options *opt, int len, int tos, int ttl);
len249include/net/sock.hunsigned short len, unsigned long saddr,
len334include/net/sock.hsk->data_ready(sk,skb->len);
len131include/net/tcp.hunsigned short len, unsigned long saddr, int redo,
len138include/net/tcp.hunsigned long daddr, int len, struct sock *sk);
len37include/net/udp.hunsigned long daddr, int len, struct sock *sk);
len39include/net/udp.hint len, int noblock, unsigned flags,
len42include/net/udp.hint len, int noblock, unsigned flags);
len47include/net/udp.hunsigned short len, unsigned long saddr, int redo,
len332init/main.cint len = strlen(devnames[n]);
len333init/main.cif (!strncmp(line,devnames[n],len)) {
len334init/main.cROOT_DEV = devnums[n]+simple_strtoul(line+len,NULL,0);
len59kernel/dma.cint i, len = 0;
len63kernel/dma.clen += sprintf(buf+len, "%2d: %s\n",
len68kernel/dma.creturn len;
len55kernel/printk.casmlinkage int sys_syslog(int type, char * buf, int len)
len70kernel/printk.cif (!buf || len < 0)
len72kernel/printk.cif (!len)
len74kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len86kernel/printk.cwhile (log_size && i < len) {
len103kernel/printk.cif (!buf || len < 0)
len105kernel/printk.cif (!len)
len107kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len110kernel/printk.ccount = len;
len133kernel/printk.cif (len < 1 || len > 8)
len135kernel/printk.cconsole_loglevel = len;
len34kernel/resource.cint len = 0;
len36kernel/resource.cfor (p = iolist.next; (p) && (len < 4000); p = p->next)
len37kernel/resource.clen += sprintf(buf+len, "%04lx-%04lx : %s\n",
len40kernel/resource.clen += sprintf(buf+len, "4K limit reached!\n");
len41kernel/resource.creturn len;
len655kernel/sys.casmlinkage int sys_sethostname(char *name, int len)
len661kernel/sys.cif (len < 0 || len > __NEW_UTS_LEN)
len663kernel/sys.cerror = verify_area(VERIFY_READ, name, len);
len666kernel/sys.cmemcpy_fromfs(system_utsname.nodename, name, len);
len667kernel/sys.csystem_utsname.nodename[len] = 0;
len671kernel/sys.casmlinkage int sys_gethostname(char *name, int len)
len675kernel/sys.cif (len < 0)
len677kernel/sys.ci = verify_area(VERIFY_WRITE, name, len);
len681kernel/sys.cif (i > len)
len682kernel/sys.ci = len;
len691kernel/sys.casmlinkage int sys_setdomainname(char *name, int len)
len697kernel/sys.cif (len > __NEW_UTS_LEN)
len699kernel/sys.cerror = verify_area(VERIFY_READ, name, len);
len702kernel/sys.cmemcpy_fromfs(system_utsname.domainname, name, len);
len703kernel/sys.csystem_utsname.domainname[len] = 0;
len136lib/vsprintf.cint len;
len221lib/vsprintf.clen = strnlen(s, precision);
len224lib/vsprintf.cwhile (len < field_width--)
len226lib/vsprintf.cfor (i = 0; i < len; ++i)
len228lib/vsprintf.cwhile (len < field_width--)
len221mm/filemap.cstatic void filemap_unmap(struct vm_area_struct *vma, unsigned long start, size_t len)
len223mm/filemap.cfilemap_sync(vma, start, len, MS_ASYNC);
len44mm/mmap.cunsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
len50mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len53mm/mmap.cif (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
len57mm/mmap.cif (off + len < off)
len93mm/mmap.cif (len > TASK_SIZE || addr > TASK_SIZE - len)
len96mm/mmap.caddr = get_unmapped_area(addr, len);
len116mm/mmap.cvma->vm_end = addr + len;
len146mm/mmap.cdo_munmap(addr, len);  /* Clear old maps */
len167mm/mmap.cunsigned long get_unmapped_area(unsigned long addr, unsigned long len)
len171mm/mmap.cif (len > TASK_SIZE)
len178mm/mmap.cif (TASK_SIZE - len < addr)
len184mm/mmap.cif (addr + len > vmm->vm_start) {
len636mm/mmap.cunsigned long addr, size_t len)
len639mm/mmap.cunsigned long end = addr + len;
len699mm/mmap.casmlinkage int sys_munmap(unsigned long addr, size_t len)
len701mm/mmap.creturn do_munmap(addr, len);
len710mm/mmap.cint do_munmap(unsigned long addr, size_t len)
len714mm/mmap.cif ((addr & ~PAGE_MASK) || addr > TASK_SIZE || len > TASK_SIZE-addr)
len717mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len735mm/mmap.cfor ( ; mpnt && mpnt->vm_start < addr+len; mpnt = *npp) {
len760mm/mmap.cend = addr+len;
len770mm/mmap.cunmap_page_range(addr, len);
len201mm/mprotect.casmlinkage int sys_mprotect(unsigned long start, size_t len, unsigned long prot)
len209mm/mprotect.clen = (len + ~PAGE_MASK) & PAGE_MASK;
len210mm/mprotect.cend = start + len;
len51net/802/p8022.cunsigned long  len = skb->len;
len55net/802/p8022.cdev->hard_header(skb, dev, len - hard_len,
len56net/802/p8022.cdest_node, NULL, len - hard_len);
len12net/802/p8023.cunsigned long  len = skb->len;
len15net/802/p8023.cdev->hard_header(skb, dev, len - hard_len,
len16net/802/p8023.cdest_node, NULL, len - hard_len);
len42net/802/tr.cvoid *daddr, void *saddr, unsigned len) 
len246net/802/tr.cint len=0;
len256net/802/tr.clen+=size;
len260net/802/tr.csize=sprintf(buffer+len,"%02X:%02X:%02X:%02X:%02X:%02X %04X %04X %04X %04X %04X %04X %04X %04X %04X %lu\n",
len264net/802/tr.clen+=size;
len265net/802/tr.cpos=begin+len;
len268net/802/tr.clen=0;
len279net/802/tr.clen-=(offset-begin);    /* Start slop */
len280net/802/tr.cif(len>length)
len281net/802/tr.clen=length;    /* Ending slop */
len282net/802/tr.creturn len;
len104net/appletalk/aarp.cint len=dev->hard_header_len+sizeof(struct elapaarp)+aarp_dl->header_length;
len105net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
len166net/appletalk/aarp.cint len=dev->hard_header_len+sizeof(struct elapaarp)+aarp_dl->header_length;
len167net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
len228net/appletalk/aarp.cint len=dev->hard_header_len+sizeof(struct elapaarp)+aarp_dl->header_length;
len229net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
len214net/appletalk/ddp.cint len=0;
len224net/appletalk/ddp.clen += sprintf (buffer,"Type local_addr  remote_addr tx_queue rx_queue st uid\n");
len227net/appletalk/ddp.clen += sprintf (buffer+len,"%02X   ", s->type);
len228net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X:%02X  ",
len230net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X:%02X  ",
len232net/appletalk/ddp.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
len233net/appletalk/ddp.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
len236net/appletalk/ddp.cpos=begin+len;
len240net/appletalk/ddp.clen=0;      /* Keep dumping into the buffer start */
len249net/appletalk/ddp.clen-=(offset-begin);    /* Remove unwanted header data from length */
len250net/appletalk/ddp.cif(len>length)
len251net/appletalk/ddp.clen=length;    /* Remove unwanted tail data from length */
len253net/appletalk/ddp.creturn len;
len813net/appletalk/ddp.cint len=0;
len817net/appletalk/ddp.clen += sprintf (buffer,"Interface    Address   Networks   Status\n");
len820net/appletalk/ddp.clen += sprintf (buffer+len,"%-16s %04X:%02X  %04X-%04X  %d\n",
len825net/appletalk/ddp.cpos=begin+len;
len828net/appletalk/ddp.clen=0;
len835net/appletalk/ddp.clen-=(offset-begin);
len836net/appletalk/ddp.cif(len>length)
len837net/appletalk/ddp.clen=length;
len838net/appletalk/ddp.creturn len;
len846net/appletalk/ddp.cint len=0;
len850net/appletalk/ddp.clen += sprintf (buffer,"Target        Router  Flags Dev\n");
len854net/appletalk/ddp.clen += sprintf (buffer+len,"Default     %5d:%-3d  %-4d  %s\n",
len860net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X     %5d:%-3d  %-4d  %s\n",
len864net/appletalk/ddp.cpos=begin+len;
len867net/appletalk/ddp.clen=0;
len874net/appletalk/ddp.clen-=(offset-begin);
len875net/appletalk/ddp.cif(len>length)
len876net/appletalk/ddp.clen=length;
len877net/appletalk/ddp.creturn len;
len891net/appletalk/ddp.cunsigned short atalk_checksum(struct ddpehdr *ddp, int len)
len896net/appletalk/ddp.clen-=4;    /* skip header 4 bytes */
len900net/appletalk/ddp.cwhile(len--)
len1028net/appletalk/ddp.cstatic void def_callback2(struct sock *sk, int len)
len1338net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
len1357net/appletalk/ddp.coriglen = skb->len;
len1359net/appletalk/ddp.cskb_trim(skb,min(skb->len,ddp->deh_len));
len1367net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
len1460net/appletalk/ddp.cstatic int atalk_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len1477net/appletalk/ddp.cif(len>587)
len1514net/appletalk/ddp.csize=sizeof(struct ddpehdr)+len+ddp_dl->header_length;  /* For headers */
len1557net/appletalk/ddp.cddp->deh_len=len+sizeof(*ddp);
len1573net/appletalk/ddp.cprintk("SK %p: Copy user data (%d bytes).\n", sk, len);
len1575net/appletalk/ddp.cmemcpy_fromfs(skb_put(skb,len),ubuf,len);
len1580net/appletalk/ddp.cddp->deh_sum=atalk_checksum(ddp, len+sizeof(*ddp));
len1633net/appletalk/ddp.cprintk("SK %p: Done write (%d).\n", sk, len);
len1634net/appletalk/ddp.creturn len;
len1752net/appletalk/ddp.cv=skb->len-sizeof(struct ddpehdr);
len354net/ax25/af_ax25.csk->data_ready(sk, skb->len);
len773net/ax25/af_ax25.cstatic void def_callback2(struct sock *sk, int len)
len1280net/ax25/af_ax25.cif (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type) == NULL) {
len1373net/ax25/af_ax25.csk->data_ready(sk, skb->len);
len1487net/ax25/af_ax25.csk->data_ready(sk, skb->len );
len1518net/ax25/af_ax25.cint len;
len1527net/ax25/af_ax25.clen = skb->data[14] + skb->data[15] * 256 - 5;
len1530net/ax25/af_ax25.cskb_trim(skb, len);      /* Set the length of the data */
len1535net/ax25/af_ax25.cstatic int ax25_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len1621net/ax25/af_ax25.csize = len + 2 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
len1630net/ax25/af_ax25.cskb_reserve(skb, size - len);
len1636net/ax25/af_ax25.cmemcpy_fromfs(skb_put(skb, len), ubuf, len);
len1654net/ax25/af_ax25.creturn len;
len1680net/ax25/af_ax25.creturn len;
len1726net/ax25/af_ax25.ccopied = (size < skb->len - bias) ? size : skb->len - bias;
len1736net/ax25/af_ax25.cax25_parse_addr(dp, skb->len, NULL, &dest, &digi, NULL);
len1806net/ax25/af_ax25.camount = skb->len;
len1871net/ax25/af_ax25.cint len = 0;
len1877net/ax25/af_ax25.clen += sprintf(buffer, "dest_addr src_addr  dev  st vs vr va    t1     t2     t3     n2  rtt wnd Snd-Q Rcv-Q\n");
len1885net/ax25/af_ax25.clen += sprintf(buffer + len, "%-9s ",
len1887net/ax25/af_ax25.clen += sprintf(buffer + len, "%-9s %-4s %2d %2d %2d %2d %3d/%03d %2d/%02d %3d/%03d %2d/%02d %3d %3d",
len1902net/ax25/af_ax25.clen += sprintf(buffer + len, " %5ld %5ld\n",
len1906net/ax25/af_ax25.clen += sprintf(buffer + len, "\n");
len1909net/ax25/af_ax25.cpos = begin + len;
len1912net/ax25/af_ax25.clen   = 0;
len1923net/ax25/af_ax25.clen   -= (offset - begin);
len1925net/ax25/af_ax25.cif (len > length) len = length;
len1927net/ax25/af_ax25.creturn(len);
len2010net/ax25/af_ax25.csize = skb->len;
len2041net/ax25/af_ax25.cvoid *saddr, unsigned len)
len142net/ax25/ax25_route.cint len     = 0;
len148net/ax25/ax25_route.clen += sprintf(buffer, "callsign  dev  count time      mode\n");
len151net/ax25/ax25_route.clen += sprintf(buffer + len, "%-9s %-4s %5d %9d",
len160net/ax25/ax25_route.clen += sprintf(buffer + len, "   vc\n");
len164net/ax25/ax25_route.clen += sprintf(buffer + len, "   dg\n");
len167net/ax25/ax25_route.clen += sprintf(buffer + len, "\n");
len171net/ax25/ax25_route.cpos = begin + len;
len174net/ax25/ax25_route.clen   = 0;
len185net/ax25/ax25_route.clen   -= (offset - begin);
len187net/ax25/ax25_route.cif (len > length) len = length;
len189net/ax25/ax25_route.creturn len;
len195net/ax25/ax25_route.cint len     = 0;
len201net/ax25/ax25_route.clen += sprintf(buffer, "Policy: %d\n", ax25_uid_policy);
len204net/ax25/ax25_route.clen += sprintf(buffer + len, "%6d %s\n", pt->uid, ax2asc(&pt->call));
len206net/ax25/ax25_route.cpos = begin + len;
len209net/ax25/ax25_route.clen = 0;
len220net/ax25/ax25_route.clen   -= offset - begin;
len222net/ax25/ax25_route.cif (len > length) len = length;
len224net/ax25/ax25_route.creturn len;
len253net/ax25/ax25_subr.cunsigned char *ax25_parse_addr(unsigned char *buf, int len, ax25_address *src, ax25_address *dest, ax25_digi *digi, int *flags)
len257net/ax25/ax25_subr.cif (len < 14) return NULL;
len274net/ax25/ax25_subr.clen -= 2 * AX25_ADDR_LEN;
len281net/ax25/ax25_subr.cif (len < 7) return NULL;  /* Short packet */
len295net/ax25/ax25_subr.clen -= AX25_ADDR_LEN;
len308net/ax25/ax25_subr.cint len = 0;
len321net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len336net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len348net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len354net/ax25/ax25_subr.creturn len;
len482net/core/dev.cint dev_rint(unsigned char *buff, long len, int flags, struct device *dev)
len490net/core/dev.cif (dev == NULL || buff == NULL || len <= 0) 
len507net/core/dev.cskb = alloc_skb(len, GFP_ATOMIC);
len521net/core/dev.cto = skb_put(skb,len);
len522net/core/dev.cleft = len;
len524net/core/dev.clen2 = len;
len803net/core/dev.cint len;
len814net/core/dev.clen = ifc.ifc_len;
len822net/core/dev.cerr=verify_area(VERIFY_WRITE,pos,len);
len843net/core/dev.cif (len < sizeof(struct ifreq)) 
len852net/core/dev.clen -= sizeof(struct ifreq);    
len906net/core/dev.cint len=0;
len918net/core/dev.clen+=size;
len923net/core/dev.csize = sprintf_stats(buffer+len, dev);
len924net/core/dev.clen+=size;
len925net/core/dev.cpos=begin+len;
len929net/core/dev.clen=0;
len937net/core/dev.clen-=(offset-begin);    /* Start slop */
len938net/core/dev.cif(len>length)
len939net/core/dev.clen=length;    /* Ending slop */
len940net/core/dev.creturn len;
len161net/core/skbuff.cif(skb->tail-skb->data!=skb->len)
len165net/core/skbuff.cskb,skb->data,skb->end,skb->len);
len359net/core/skbuff.cunsigned char *skb_put(struct sk_buff *skb, int len)
len363net/core/skbuff.cskb->tail+=len;
len364net/core/skbuff.cskb->len+=len;
len367net/core/skbuff.cpanic("skput:over: %p:%d", __builtin_return_address(0),len);
len371net/core/skbuff.cunsigned char *skb_push(struct sk_buff *skb, int len)
len374net/core/skbuff.cskb->data-=len;
len375net/core/skbuff.cskb->len+=len;
len378net/core/skbuff.cpanic("skpush:under: %p:%d", __builtin_return_address(0),len);
len382net/core/skbuff.cint skb_pull(struct sk_buff *skb, int len)
len385net/core/skbuff.cif(len>skb->len)
len386net/core/skbuff.clen=skb->len;
len387net/core/skbuff.cskb->data+=len;
len388net/core/skbuff.cskb->len-=len;
len389net/core/skbuff.creturn len;
len404net/core/skbuff.cvoid skb_reserve(struct sk_buff *skb, int len)
len407net/core/skbuff.cskb->data+=len;
len408net/core/skbuff.cskb->tail+=len;
len416net/core/skbuff.cvoid skb_trim(struct sk_buff *skb, int len)
len419net/core/skbuff.cif(skb->len>len)
len421net/core/skbuff.cskb->len=len;
len422net/core/skbuff.cskb->tail=skb->data+len;
len496net/core/skbuff.cint len=size;
len560net/core/skbuff.cskb->end=bptr+len;
len561net/core/skbuff.cskb->len=0;
len608net/core/skbuff.cskb_put(n,skb->len);
len528net/core/sock.cskb->saddr, skb->len, skb->daddr, 1,
len88net/ethernet/eth.cvoid *daddr, void *saddr, unsigned len)
len100net/ethernet/eth.ceth->h_proto = htons(len);
len12net/ethernet/pe2.cunsigned long  len = skb->len;
len16net/ethernet/pe2.cdest_node, NULL, len - hard_len);
len521net/ipv4/af_inet.cstatic void def_callback2(struct sock *sk,int len)
len346net/ipv4/arp.cdev->hard_header(skb,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len);
len1002net/ipv4/arp.cint len=0;
len1014net/ipv4/arp.clen+=size;
len1047net/ipv4/arp.csize = sprintf(buffer+len,
len1053net/ipv4/arp.csize += sprintf(buffer+len+size,
len1058net/ipv4/arp.clen+=size;
len1059net/ipv4/arp.cpos=begin+len;
len1063net/ipv4/arp.clen=0;
len1073net/ipv4/arp.clen-=(offset-begin);    /* Start slop */
len1074net/ipv4/arp.cif(len>length)
len1075net/ipv4/arp.clen=length;            /* Ending slop */
len1076net/ipv4/arp.creturn len;
len107net/ipv4/icmp.cint len;
len214net/ipv4/icmp.clen = dev->hard_header_len + sizeof(struct iphdr) + sizeof(struct icmphdr) +
len217net/ipv4/icmp.cskb = (struct sk_buff *) alloc_skb(len+15, GFP_ATOMIC);
len233net/ipv4/icmp.c&ndev, IPPROTO_ICMP, NULL, len,
len427net/ipv4/icmp.cunsigned long saddr, unsigned long daddr, int len,
len438net/ipv4/icmp.csize = dev->hard_header_len + 64 + len + 15;
len451net/ipv4/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len465net/ipv4/icmp.cskb_put(skb2,len);
len471net/ipv4/icmp.cmemcpy((char *) icmphr, (char *) icmph, len);
len475net/ipv4/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len494net/ipv4/icmp.cunsigned long saddr, unsigned long daddr, int len,
len503net/ipv4/icmp.cif (len < 12)
len507net/ipv4/icmp.clen);
len527net/ipv4/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev, IPPROTO_ICMP, opt, len, 
len579net/ipv4/icmp.cunsigned long saddr, unsigned long daddr, int len,
len592net/ipv4/icmp.cunsigned long saddr, unsigned long daddr, int len,
len603net/ipv4/icmp.csize = dev->hard_header_len + 64 + len + 15;
len618net/ipv4/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
len632net/ipv4/icmp.cskb_put(skb2,len);
len646net/ipv4/icmp.cicmphr->checksum = ip_compute_csum((unsigned char *)icmphr, len);
len661net/ipv4/icmp.cunsigned long daddr, unsigned short len,
len686net/ipv4/icmp.cif (ip_compute_csum((unsigned char *) icmph, len)) 
len730net/ipv4/icmp.cicmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
len738net/ipv4/icmp.cicmp_timestamp(icmph, skb1, dev, saddr, daddr, len, opt);
len746net/ipv4/icmp.cicmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
len754net/ipv4/icmp.cicmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
len200net/ipv4/igmp.cunsigned long daddr, unsigned short len, unsigned long saddr, int redo,
len208net/ipv4/igmp.cif(skb->len <sizeof(struct igmphdr) || skb->ip_hdr->ttl!=1 || ip_compute_csum((void *)skb->h.raw,sizeof(struct igmphdr)))
len181net/ipv4/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
len194net/ipv4/ip.cmac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
len214net/ipv4/ip.cstruct device **dev, int type, struct options *opt, int len, int tos, int ttl)
len287net/ipv4/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
len369net/ipv4/ip.cfp->len = end - offset;
len520net/ipv4/ip.cqp->len = 0;
len553net/ipv4/ip.cif (qp->len == 0)
len586net/ipv4/ip.cint count, len;
len591net/ipv4/ip.clen = qp->ihlen + qp->len;
len593net/ipv4/ip.cif ((skb = dev_alloc_skb(len)) == NULL)
len602net/ipv4/ip.cskb_put(skb,len);
len617net/ipv4/ip.cif(count+fp->len > skb->len)
len625net/ipv4/ip.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
len626net/ipv4/ip.ccount += fp->len;
len722net/ipv4/ip.cqp->len = end;
len762net/ipv4/ip.ctmp->len -= i;        /* so reduce size of  */
len769net/ipv4/ip.cif (tmp->len <= 0)
len848net/ipv4/ip.cint left, mtu, hlen, len;
len920net/ipv4/ip.clen = left;
len922net/ipv4/ip.cif (len > mtu)
len923net/ipv4/ip.clen = mtu;
len926net/ipv4/ip.cif (len < left)
len928net/ipv4/ip.clen/=8;
len929net/ipv4/ip.clen*=8;
len935net/ipv4/ip.cif ((skb2 = alloc_skb(len + hlen+15,GFP_ATOMIC)) == NULL)
len950net/ipv4/ip.cskb_put(skb2,len + hlen);
len976net/ipv4/ip.cmemcpy(skb2->h.raw + hlen, ptr, len);
len977net/ipv4/ip.cleft -= len;
len992net/ipv4/ip.cptr += len;
len993net/ipv4/ip.coffset += len;
len1174net/ipv4/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len + 15, GFP_ATOMIC);
len1192net/ipv4/ip.cip_send(skb2,raddr,skb->len,dev2,dev2->pa_addr);
len1199net/ipv4/ip.cptr = skb_put(skb2,skb->len);
len1206net/ipv4/ip.cmemcpy(ptr, skb->h.raw, skb->len);
len1220net/ipv4/ip.cif(dev2->hard_header(skb, dev2, ETH_P_IP, NULL, NULL, skb->len)<0)
len1231net/ipv4/ip.cif(skb2->len > dev2->mtu + dev2->hard_header_len)
len1317net/ipv4/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0
len1318net/ipv4/ip.c|| skb->len < ntohs(iph->tot_len))
len1694net/ipv4/ip.cint len=skb->len-old_dev->hard_header_len;
len1695net/ipv4/ip.cstruct sk_buff *newskb=dev_alloc_skb(len+dev->hard_header_len+15);
len1714net/ipv4/ip.cip_send(newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr);
len1718net/ipv4/ip.cnewskb->ip_hdr=(struct iphdr *)skb_put(newskb, len);
len1722net/ipv4/ip.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
len1775net/ipv4/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
len1804net/ipv4/ip.cif(skb->len > dev->mtu + dev->hard_header_len)
len1959net/ipv4/ip.cint len=0;
len1962net/ipv4/ip.clen=sprintf(buffer,"Device    : Count\tGroup    Users Timer\n");  
len1970net/ipv4/ip.clen+=sprintf(buffer+len,"%-10s: %5d\n",
len1974net/ipv4/ip.clen+=sprintf(buffer+len,
len1978net/ipv4/ip.cpos=begin+len;
len1981net/ipv4/ip.clen=0;
len1991net/ipv4/ip.clen-=(offset-begin);
len1992net/ipv4/ip.cif(len>length)
len1993net/ipv4/ip.clen=length;  
len1994net/ipv4/ip.creturn len;
len2279net/ipv4/ip.cint len;
len2304net/ipv4/ip.clen=strlen(sk->ip_mc_name);
len2305net/ipv4/ip.cerr=verify_area(VERIFY_WRITE, optval, len);
len2308net/ipv4/ip.cput_user(len,(int *) optlen);
len2309net/ipv4/ip.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
len540net/ipv4/ip_fw.cwhile (skb->len - ((unsigned char *)data - skb->h.raw) > 18)
len611net/ipv4/ip_fw.cprintk("MASQUERADE: resizing needed for %d bytes (%ld)\n",ftp->delta, skb->len);
len615net/ipv4/ip_fw.cskb2 = alloc_skb(skb->len+ftp->delta, GFP_ATOMIC);
len621net/ipv4/ip_fw.cskb_put(skb2,skb->len + ftp->delta);
len631net/ipv4/ip_fw.cskb->len - ((char *)skb->h.raw - data));
len645net/ipv4/ip_fw.cunsigned long daddr, int len)
len648net/ipv4/ip_fw.cuh->check=csum_tcpudp_magic(saddr,daddr,len,
len649net/ipv4/ip_fw.cIPPROTO_UDP, csum_partial((char *)uh,len,0));
len717net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
len809net/ipv4/ip_fw.cint size = skb_ptr->len - ((unsigned char *)portptr - skb_ptr->h.raw);
len1136net/ipv4/ip_fw.cstruct ip_fw *check_ipfw_struct(struct ip_fw *frwl, int len)
len1139net/ipv4/ip_fw.cif ( len != sizeof(struct ip_fw) )
len1142net/ipv4/ip_fw.cprintk("ip_fw_ctl: len=%d, want %d\n",len, sizeof(struct ip_fw));
len1199net/ipv4/ip_fw.cint ip_acct_ctl(int stage, void *m, int len)
len1217net/ipv4/ip_fw.cif (!(frwl=check_ipfw_struct(m,len)))
len1244net/ipv4/ip_fw.cint ip_fw_ctl(int stage, void *m, int len)
len1289net/ipv4/ip_fw.cif ( len < sizeof(struct ip_fwpkt) )
len1293net/ipv4/ip_fw.clen, sizeof(struct ip_fwpkt));
len1335net/ipv4/ip_fw.cfrwl=check_ipfw_struct(m,len);
len1375net/ipv4/ip_fw.cint len, p;
len1383net/ipv4/ip_fw.clen=sprintf(buffer, "IP firewall block rules, default %d\n",
len1388net/ipv4/ip_fw.clen=sprintf(buffer, "IP firewall forward rules, default %d\n",
len1395net/ipv4/ip_fw.clen=sprintf(buffer,"IP accounting rules\n");
len1401net/ipv4/ip_fw.clen=0;
len1410net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%08lX/%08lX->%08lX/%08lX %08lX %X ",
len1414net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%u %u %-9lu %-9lu",
len1417net/ipv4/ip_fw.clen+=sprintf(buffer+len, " %u", i->fw_pts[p]);
len1418net/ipv4/ip_fw.cbuffer[len++]='\n';
len1419net/ipv4/ip_fw.cbuffer[len]='\0';
len1420net/ipv4/ip_fw.cpos=begin+len;
len1423net/ipv4/ip_fw.clen=0;
len1438net/ipv4/ip_fw.clen-=(offset-begin);
len1439net/ipv4/ip_fw.cif(len>length)
len1440net/ipv4/ip_fw.clen=length;  
len1441net/ipv4/ip_fw.creturn len;
len1474net/ipv4/ip_fw.cint len=0;
len1476net/ipv4/ip_fw.clen=sprintf(buffer,"Prc FromIP   FPrt ToIP     TPrt Masq Init-seq Delta Expires\n"); 
len1486net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%s %08lX:%04X %08lX:%04X %04X %08X %5d %lu\n",
len1495net/ipv4/ip_fw.cpos=begin+len;
len1498net/ipv4/ip_fw.clen=0;
len1507net/ipv4/ip_fw.clen-=(offset-begin);
len1508net/ipv4/ip_fw.cif(len>length)
len1509net/ipv4/ip_fw.clen=length;
len1510net/ipv4/ip_fw.creturn len;
len51net/ipv4/ipip.cunsigned long daddr, unsigned short len, unsigned long saddr,
len127net/ipv4/packet.csk->data_ready(sk,skb->len);
len144net/ipv4/packet.cstatic int packet_sendto(struct sock *sk, unsigned char *from, int len,
len187net/ipv4/packet.cif(len>dev->mtu+dev->hard_header_len)
len190net/ipv4/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
len208net/ipv4/packet.cmemcpy_fromfs(skb_put(skb,len), from, len);
len219net/ipv4/packet.creturn(len);
len228net/ipv4/packet.cint len, int noblock,  unsigned flags)
len230net/ipv4/packet.creturn(packet_sendto(sk, buff, len, noblock, flags, NULL, 0));
len287net/ipv4/packet.cint packet_recvfrom(struct sock *sk, unsigned char *to, int len,
len331net/ipv4/packet.ccopied = min(len, skb->len);
len368net/ipv4/packet.cint len, int noblock, unsigned flags)
len370net/ipv4/packet.creturn(packet_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len69net/ipv4/proc.cint len=0;
len74net/ipv4/proc.clen+=sprintf(buffer, "sl  local_address rem_address   st tx_queue rx_queue tr tm->when uid\n");
len110net/ipv4/proc.clen+=sprintf(buffer+len, "%2d: %08lX:%04X %08lX:%04X %02X %08lX:%08lX %02X:%08lX %08X %d %d\n",
len125net/ipv4/proc.cpos=begin+len;
len128net/ipv4/proc.clen=0;
len140net/ipv4/proc.clen-=(offset-begin);
len141net/ipv4/proc.cif(len>length)
len142net/ipv4/proc.clen=length;
len143net/ipv4/proc.creturn len;
len174net/ipv4/proc.cint len  = socket_get_info(buffer,start,offset,length);
len176net/ipv4/proc.clen += sprintf(buffer+len,"SOCK_ARRAY_SIZE=%d\n",SOCK_ARRAY_SIZE);
len177net/ipv4/proc.clen += sprintf(buffer+len,"TCP: inuse %d highest %d\n",
len179net/ipv4/proc.clen += sprintf(buffer+len,"UDP: inuse %d highest %d\n",
len181net/ipv4/proc.clen += sprintf(buffer+len,"RAW: inuse %d highest %d\n",
len183net/ipv4/proc.clen += sprintf(buffer+len,"PAC: inuse %d highest %d\n",
len186net/ipv4/proc.clen -= offset;
len187net/ipv4/proc.cif (len > length)
len188net/ipv4/proc.clen = length;
len189net/ipv4/proc.creturn len;
len201net/ipv4/proc.cint len;
len206net/ipv4/proc.clen = sprintf (buffer,
len220net/ipv4/proc.clen += sprintf (buffer + len,
len237net/ipv4/proc.clen += sprintf (buffer + len,
len247net/ipv4/proc.clen += sprintf (buffer + len,
len257net/ipv4/proc.cif (offset >= len)
len263net/ipv4/proc.clen -= offset;
len264net/ipv4/proc.cif (len > length)
len265net/ipv4/proc.clen = length;
len266net/ipv4/proc.creturn len;
len429net/ipv4/rarp.cint len=0;
len440net/ipv4/rarp.clen+=size;
len447net/ipv4/rarp.clen+=size;
len459net/ipv4/rarp.csize = sprintf(buffer+len,
len470net/ipv4/rarp.clen+=size;
len471net/ipv4/rarp.cpos=begin+len;
len475net/ipv4/rarp.clen=0;
len485net/ipv4/rarp.clen-=(offset-begin);    /* Start slop */
len486net/ipv4/rarp.cif(len>length)
len487net/ipv4/rarp.clen=length;            /* Ending slop */
len488net/ipv4/rarp.creturn len;
len159net/ipv4/raw.cint len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)
len203net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getrawfrag, from, len, sin.sin_addr.s_addr, flags, sin.sin_port);
len205net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getfrag, from, len, sin.sin_addr.s_addr, flags, sin.sin_port);
len206net/ipv4/raw.creturn err<0?err:len;
len210net/ipv4/raw.cstatic int raw_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len213net/ipv4/raw.creturn(raw_sendto(sk, buff, len, noblock, flags, NULL, 0));
len234net/ipv4/raw.cint raw_recvfrom(struct sock *sk, unsigned char *to, int len,
len256net/ipv4/raw.ctruesize=skb->len;
len257net/ipv4/raw.ccopied = min(len, truesize);
len274net/ipv4/raw.cint raw_read (struct sock *sk, unsigned char *buff, int len, int noblock,unsigned flags)
len276net/ipv4/raw.creturn(raw_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len516net/ipv4/route.cint len=0;
len521net/ipv4/route.clen += sprintf(buffer,
len523net/ipv4/route.cpos=len;
len531net/ipv4/route.csize = sprintf(buffer+len, "%s\t%08lX\t%08lX\t%02X\t%d\t%lu\t%d\t%08lX\t%d\t%lu\t%u\n",
len535net/ipv4/route.clen+=size;
len539net/ipv4/route.clen=0;
len547net/ipv4/route.clen-=(offset-begin);
len548net/ipv4/route.cif(len>length)
len549net/ipv4/route.clen=length;
len550net/ipv4/route.creturn len;
len516net/ipv4/tcp.cif(dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, skb->len)<0)
len941net/ipv4/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
len1115net/ipv4/tcp.cunsigned short tcp_check(struct tcphdr *th, int len,
len1118net/ipv4/tcp.creturn csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
len1124net/ipv4/tcp.cunsigned long daddr, int len, struct sock *sk)
len1127net/ipv4/tcp.cth->check = tcp_check(th, len, saddr, daddr,
len1128net/ipv4/tcp.ccsum_partial((char *)th,len,0));
len1146net/ipv4/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
len1152net/ipv4/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
len1155net/ipv4/tcp.cskb, skb->data, th, skb->len);
len1460net/ipv4/tcp.cint len, int nonblock, unsigned flags)
len1472net/ipv4/tcp.cwhile(len > 0) 
len1588net/ipv4/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
len1599net/ipv4/tcp.clen -= copy;
len1602net/ipv4/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
len1625net/ipv4/tcp.cif (copy > len)
len1626net/ipv4/tcp.ccopy = len;
len1722net/ipv4/tcp.ctmp = tcp_build_header(skb->h.th, sk, len-copy);
len1742net/ipv4/tcp.clen -= copy;
len1781net/ipv4/tcp.cint len, int nonblock, unsigned flags,
len1796net/ipv4/tcp.creturn tcp_write(sk, from, len, nonblock, flags);
len1976net/ipv4/tcp.cunsigned char *to, int len, unsigned flags)
len2033net/ipv4/tcp.cint len, int nonblock, unsigned flags)
len2053net/ipv4/tcp.creturn tcp_read_urg(sk, nonblock, to, len, flags);
len2068net/ipv4/tcp.cwhile (len > 0) 
len2096net/ipv4/tcp.cif (offset < skb->len)
len2167net/ipv4/tcp.cused = skb->len - offset;
len2168net/ipv4/tcp.cif (len < used)
len2169net/ipv4/tcp.cused = len;
len2209net/ipv4/tcp.clen -= used;
len2222net/ipv4/tcp.cif (used + offset < skb->len)
len3087net/ipv4/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
len3116net/ipv4/tcp.cextern __inline__ int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
len3192net/ipv4/tcp.cif (len != th->doff*4) 
len3721net/ipv4/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
len3807net/ipv4/tcp.cunsigned long saddr, unsigned short len)
len3816net/ipv4/tcp.cskb_trim(skb,len-(th->doff*4));
len3823net/ipv4/tcp.csk->bytes_rcv += skb->len;
len3825net/ipv4/tcp.cif (skb->len == 0 && !th->fin) 
len3852net/ipv4/tcp.cif(skb->len)  /* We don't care if it's just an ack or
len3855net/ipv4/tcp.cnew_seq= th->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
len3931net/ipv4/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
len3966net/ipv4/tcp.cth->ack_seq = th->seq + skb->len;
len4166net/ipv4/tcp.cunsigned long saddr, unsigned long len)
len4189net/ipv4/tcp.cif (ptr >= len)
len4425net/ipv4/tcp.cextern __inline__ int tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
len4430net/ipv4/tcp.cnext_seq = len - 4*th->doff;
len4515net/ipv4/tcp.cunsigned long daddr, unsigned short len,
len4569net/ipv4/tcp.c(skb->ip_summed && tcp_check(th, len, saddr, daddr, skb->csum ))||
len4570net/ipv4/tcp.c(!skb->ip_summed && tcp_check(th, len, saddr, daddr, csum_partial((char *)th, len, 0)))
len4720net/ipv4/tcp.cif(!tcp_ack(sk,th,saddr,len))
len4839net/ipv4/tcp.cif(!tcp_sequence(sk,th,len,opt,saddr,dev))
len4864net/ipv4/tcp.cif(th->ack && !tcp_ack(sk,th,saddr,len))
len4885net/ipv4/tcp.cif(tcp_urg(sk, th, saddr, len))
len4897net/ipv4/tcp.cif(tcp_data(skb,sk, saddr, len))
len5048net/ipv4/tcp.cow_size = skb->len - win_size - 
len5052net/ipv4/tcp.cskb_trim(skb,skb->len-win_size);
len66net/ipv4/timer.cvoid reset_timer (struct sock *t, int timeout, unsigned long len)
len72net/ipv4/timer.cif ((int) len < 0)  /* prevent close to infinite timers. THEY _DO_ */
len73net/ipv4/timer.clen = 3;  /* happen (negative values ?) - don't ask me why ! -FB */
len75net/ipv4/timer.ct->timer.expires = len;
len110net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
len169net/ipv4/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
len171net/ipv4/udp.creturn(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
len193net/ipv4/udp.cunsigned int len;
len197net/ipv4/udp.clen = fraglen;
len203net/ipv4/udp.clen = fraglen-sizeof(struct udphdr);
len207net/ipv4/udp.cufh->wcheck = csum_partial_copy_fromuser(src, dst, len, ufh->wcheck);
len213net/ipv4/udp.cntohs(ufh->uh.len),
len232net/ipv4/udp.cunsigned int len;
len236net/ipv4/udp.clen = fraglen;
len242net/ipv4/udp.clen = fraglen-sizeof(struct udphdr);
len246net/ipv4/udp.cmemcpy_fromfs(dst,src,len);
len257net/ipv4/udp.cunsigned char *from, int len, int rt) 
len259net/ipv4/udp.cint ulen = len + sizeof(struct udphdr);
len265net/ipv4/udp.cufh.uh.len = htons(ulen);
len280net/ipv4/udp.creturn len;
len284net/ipv4/udp.cstatic int udp_sendto(struct sock *sk, unsigned char *from, int len, int noblock,
len332net/ipv4/udp.ctmp = udp_send(sk, usin, from, len, flags);
len343net/ipv4/udp.cstatic int udp_write(struct sock *sk, unsigned char *buff, int len, int noblock,
len346net/ipv4/udp.creturn(udp_sendto(sk, buff, len, noblock, flags, NULL, 0));
len387net/ipv4/udp.camount = skb->len;
len409net/ipv4/udp.cint udp_recvfrom(struct sock *sk, unsigned char *to, int len,
len434net/ipv4/udp.ctruesize = skb->len - sizeof(struct udphdr);
len435net/ipv4/udp.ccopied = min(len, truesize);
len461net/ipv4/udp.cint udp_read(struct sock *sk, unsigned char *buff, int len, int noblock,
len464net/ipv4/udp.creturn(udp_recvfrom(sk, buff, len, noblock, flags, NULL, NULL));
len515net/ipv4/udp.cunsigned long daddr, unsigned short len,
len538net/ipv4/udp.culen = ntohs(uh->len);
len540net/ipv4/udp.cif (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
len542net/ipv4/udp.cNETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
len549net/ipv4/udp.c( skb->ip_summed && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
len550net/ipv4/udp.c( !skb->ip_summed && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
len566net/ipv4/udp.clen=ulen;
len589net/ipv4/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
len626net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
len629net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
len633net/ipv4/udp.cskb_trim(skb,len);
len433net/ipx/af_ipx.cint  len;
len447net/ipx/af_ipx.cmemmove(skb->h.raw, oldraw, skb->len);
len448net/ipx/af_ipx.cskb->len += out_offset;
len455net/ipx/af_ipx.clen = skb->len + out_offset;
len456net/ipx/af_ipx.cskb2 = alloc_skb(len, GFP_ATOMIC);
len459net/ipx/af_ipx.cskb2->h.raw=skb_put(skb2,skb->len);
len462net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
len983net/ipx/af_ipx.cipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, void *ubuf, int len)
len1005net/ipx/af_ipx.csize=sizeof(ipx_packet)+len;
len1021net/ipx/af_ipx.cipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
len1033net/ipx/af_ipx.cmemcpy_fromfs(skb_put(skb,len),ubuf,len);
len1124net/ipx/af_ipx.cint len=0;
len1130net/ipx/af_ipx.clen += sprintf (buffer,"%-11s%-15s%-9s%-11s%s\n", "Network", 
len1133net/ipx/af_ipx.clen += sprintf(buffer+len, "%08lX   ", ntohl(i->if_netnum));
len1134net/ipx/af_ipx.clen += sprintf (buffer+len,"%02X%02X%02X%02X%02X%02X   ", 
len1137net/ipx/af_ipx.clen += sprintf(buffer+len, "%-9s", (i == ipx_primary_net) ?
len1139net/ipx/af_ipx.clen += sprintf (buffer+len, "%-11s", ipx_device_name(i));
len1140net/ipx/af_ipx.clen += sprintf (buffer+len, "%s\n", 
len1144net/ipx/af_ipx.cpos=begin+len;
len1147net/ipx/af_ipx.clen=0;      /* Keep dumping into the buffer start */
len1156net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
len1157net/ipx/af_ipx.cif(len>length)
len1158net/ipx/af_ipx.clen=length;    /* Remove unwanted tail data from length */
len1160net/ipx/af_ipx.creturn len;
len1168net/ipx/af_ipx.cint len=0;
len1174net/ipx/af_ipx.clen += sprintf (buffer,"%-15s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
len1179net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX:%04X  ", 
len1183net/ipx/af_ipx.clen += sprintf(buffer+len, "%-28s", "Not_Connected");
len1185net/ipx/af_ipx.clen += sprintf (buffer+len,
len1193net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX  %08lX  ", 
len1195net/ipx/af_ipx.clen += sprintf (buffer+len,"%02X     %03d\n", 
len1199net/ipx/af_ipx.cpos=begin+len;
len1203net/ipx/af_ipx.clen=0;      /* Keep dumping into the buffer start */
len1213net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
len1214net/ipx/af_ipx.cif(len>length)
len1215net/ipx/af_ipx.clen=length;    /* Remove unwanted tail data from length */
len1217net/ipx/af_ipx.creturn len;
len1223net/ipx/af_ipx.cint len=0;
len1227net/ipx/af_ipx.clen += sprintf (buffer,"%-11s%-13s%s\n", 
len1231net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX   ", ntohl(rt->ir_net));
len1233net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX     %02X%02X%02X%02X%02X%02X\n", 
len1239net/ipx/af_ipx.clen += sprintf (buffer+len, "%-13s%s\n",
len1242net/ipx/af_ipx.cpos=begin+len;
len1245net/ipx/af_ipx.clen=0;
len1252net/ipx/af_ipx.clen-=(offset-begin);
len1253net/ipx/af_ipx.cif(len>length)
len1254net/ipx/af_ipx.clen=length;
len1255net/ipx/af_ipx.creturn len;
len1358net/ipx/af_ipx.cstatic void def_callback2(struct sock *sk, int len)
len1671net/ipx/af_ipx.cstatic int ipx_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len1708net/ipx/af_ipx.cretval = ipxrtr_route_packet(sk, usipx, ubuf, len);
len1711net/ipx/af_ipx.creturn len;
len1819net/ipx/af_ipx.camount=skb->len;
len378net/netrom/af_netrom.cstatic void def_callback2(struct sock *sk, int len)
len906net/netrom/af_netrom.cif ((frametype & 0x0F) == NR_CONNACK && skb->len == 7)
len948net/netrom/af_netrom.cif (skb->len == 37) {
len975net/netrom/af_netrom.csk->data_ready(sk, skb->len);
len980net/netrom/af_netrom.cstatic int nr_sendto(struct socket *sock, void *ubuf, int len, int noblock,
len1025net/netrom/af_netrom.csize = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + 2 + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
len1034net/netrom/af_netrom.cskb_reserve(skb, size - len);
len1060net/netrom/af_netrom.cskb->h.raw = skb_put(skb, len);
len1068net/netrom/af_netrom.cmemcpy_fromfs(asmptr, ubuf, len);
len1080net/netrom/af_netrom.creturn len;
len1119net/netrom/af_netrom.ccopied = (size < skb->len - NR_TRANSPORT_LEN) ? size : skb->len - NR_TRANSPORT_LEN;
len1188net/netrom/af_netrom.camount = skb->len - 20;
len1257net/netrom/af_netrom.cint len = 0;
len1263net/netrom/af_netrom.clen += sprintf(buffer, "user_addr dest_node src_node    my  your  st vs vr va    t1     t2    n2  rtt wnd Snd-Q Rcv-Q\n");
len1266net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s ",
len1268net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s ",
len1270net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s %02X/%02X %02X/%02X %2d %2d %2d %2d %3d/%03d %2d/%02d %2d/%02d %3d %3d %5ld %5ld\n",
len1285net/netrom/af_netrom.cpos = begin + len;
len1288net/netrom/af_netrom.clen   = 0;
len1299net/netrom/af_netrom.clen   -= (offset - begin);
len1301net/netrom/af_netrom.cif (len > length) len = length;
len1303net/netrom/af_netrom.creturn(len);
len75net/netrom/nr_dev.cvoid *daddr, void *saddr, unsigned len)
len687net/netrom/nr_route.cint len     = 0;
len694net/netrom/nr_route.clen += sprintf(buffer, "callsign  mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
len697net/netrom/nr_route.clen += sprintf(buffer + len, "%-9s %-7s  %d %d",
len704net/netrom/nr_route.clen += sprintf(buffer + len, "  %3d   %d %05d",
len710net/netrom/nr_route.clen += sprintf(buffer + len, "\n");
len712net/netrom/nr_route.cpos = begin + len;
len715net/netrom/nr_route.clen   = 0;
len726net/netrom/nr_route.clen   -= (offset - begin);
len728net/netrom/nr_route.cif (len > length) len = length;
len730net/netrom/nr_route.creturn(len);
len736net/netrom/nr_route.cint len     = 0;
len742net/netrom/nr_route.clen += sprintf(buffer, "addr  callsign  dev  qual lock count\n");
len745net/netrom/nr_route.clen += sprintf(buffer + len, "%05d %-9s %-4s  %3d    %d   %3d\n",
len753net/netrom/nr_route.cpos = begin + len;
len756net/netrom/nr_route.clen   = 0;
len767net/netrom/nr_route.clen   -= (offset - begin);
len769net/netrom/nr_route.cif (len > length) len = length;
len771net/netrom/nr_route.creturn(len);
len154net/netrom/nr_subr.cint len, timeout;
len156net/netrom/nr_subr.clen = AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + 2 + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
len160net/netrom/nr_subr.clen += 17;
len163net/netrom/nr_subr.clen += (sk->nr->bpqext) ? 2 : 1;
len174net/netrom/nr_subr.cif ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
len249net/netrom/nr_subr.cint len;
len251net/netrom/nr_subr.clen = AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + 2 + NR_NETWORK_LEN + NR_TRANSPORT_LEN + 1;
len253net/netrom/nr_subr.cif ((skbn = alloc_skb(len, GFP_ATOMIC)) == NULL)
len134net/socket.cint len;
len139net/socket.clen=get_user(ulen);
len140net/socket.cif(len>klen)
len141net/socket.clen=klen;
len142net/socket.cif(len<0 || len> MAX_SOCK_ADDR)
len144net/socket.cif(len)
len146net/socket.cif((err=verify_area(VERIFY_WRITE,uaddr,len))<0)
len148net/socket.cmemcpy_tofs(uaddr,kaddr,len);
len150net/socket.cput_user(len,ulen);
len758net/socket.cint len;
len802net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
len803net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
len869net/socket.cint len;
len877net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
len880net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len894net/socket.cint len;
len902net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
len905net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len915net/socket.casmlinkage int sys_send(int fd, void * buff, int len, unsigned flags)
len926net/socket.cif(len<0)
len928net/socket.cerr=verify_area(VERIFY_READ, buff, len);
len931net/socket.creturn(sock->ops->send(sock, buff, len, (file->f_flags & O_NONBLOCK), flags));
len940net/socket.casmlinkage int sys_sendto(int fd, void * buff, int len, unsigned flags,
len953net/socket.cif(len<0)
len955net/socket.cerr=verify_area(VERIFY_READ,buff,len);
len962net/socket.creturn(sock->ops->sendto(sock, buff, len, (file->f_flags & O_NONBLOCK),
len975net/socket.casmlinkage int sys_recv(int fd, void * buff, int len, unsigned flags)
len987net/socket.cif(len<0)
len989net/socket.cif(len==0)
len991net/socket.cerr=verify_area(VERIFY_WRITE, buff, len);
len995net/socket.creturn(sock->ops->recv(sock, buff, len,(file->f_flags & O_NONBLOCK), flags));
len1004net/socket.casmlinkage int sys_recvfrom(int fd, void * buff, int len, unsigned flags,
len1016net/socket.cif(len<0)
len1018net/socket.cif(len==0)
len1021net/socket.cerr=verify_area(VERIFY_WRITE,buff,len);
len1025net/socket.clen=sock->ops->recvfrom(sock, buff, len, (file->f_flags & O_NONBLOCK),
len1028net/socket.cif(len<0)
len1029net/socket.creturn len;
len1033net/socket.creturn len;
len1307net/socket.cint len = sprintf(buffer, "sockets: used %d\n", sockets_in_use);
len1308net/socket.cif (offset >= len)
len1314net/socket.clen -= offset;
len1315net/socket.cif (len > length)
len1316net/socket.clen = length;
len1317net/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;