taglinefilesource code
len130arch/alpha/kernel/irq.cint i, len = 0;
len136arch/alpha/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len141arch/alpha/kernel/irq.creturn len;
len14arch/alpha/kernel/ksyms.cextern void bcopy (const char *src, char *dst, int len);
len168arch/alpha/kernel/osf_sys.casmlinkage unsigned long osf_mmap(unsigned long addr, unsigned long len,
len180arch/alpha/kernel/osf_sys.creturn do_mmap(file, addr, len, prot, flags, off);
len479arch/alpha/kernel/osf_sys.cunsigned len;
len486arch/alpha/kernel/osf_sys.clen = namelen;
len488arch/alpha/kernel/osf_sys.clen = 32;
len490arch/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));
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));
len181arch/i386/kernel/irq.cint i, len = 0;
len187arch/i386/kernel/irq.clen += sprintf(buf+len, "%3d: %8d %c %s\n",
len196arch/i386/kernel/irq.clen+=sprintf(buf+len, "IPI: %8lu received\n",
len199arch/i386/kernel/irq.creturn len;
len205arch/i386/kernel/irq.cint i,j, len = 0;
len219arch/i386/kernel/irq.clen += sprintf(buf+len,"CPUS: %10i \n", 
len221arch/i386/kernel/irq.clen += sprintf(buf+len,"            SUM ");
len223arch/i386/kernel/irq.clen += sprintf(buf+len,"        P%1d ",i);
len224arch/i386/kernel/irq.clen += sprintf(buf+len,"\n");
len228arch/i386/kernel/irq.clen += sprintf(buf+len, "%3d: %10d ",
len231arch/i386/kernel/irq.clen+=sprintf(buf+len, "%10d ",int_count[j][i]);
len232arch/i386/kernel/irq.clen += sprintf(buf+len, "%c %s\n",
len236arch/i386/kernel/irq.clen+=sprintf(buf+len, "LCK: %10lu",
len239arch/i386/kernel/irq.clen+=sprintf(buf+len," %10lu",smp_spins[i]);
len240arch/i386/kernel/irq.clen +=sprintf(buf+len,"   spins from int\n");
len242arch/i386/kernel/irq.clen+=sprintf(buf+len, "LCK: %10lu",
len245arch/i386/kernel/irq.clen+=sprintf(buf+len," %10lu",smp_spins_syscall[i]);
len246arch/i386/kernel/irq.clen +=sprintf(buf+len,"   spins from syscall\n");
len248arch/i386/kernel/irq.clen+=sprintf(buf+len, "LCK: %10lu",
len251arch/i386/kernel/irq.clen+=sprintf(buf+len," %10lu",smp_spins_sys_idle[i]);
len252arch/i386/kernel/irq.clen +=sprintf(buf+len,"   spins from sysidle\n");
len253arch/i386/kernel/irq.clen+=sprintf(buf+len,"IDLE %10lu",sum_smp_idle_count);
len255arch/i386/kernel/irq.clen+=sprintf(buf+len," %10lu",smp_idle_count[i]);
len256arch/i386/kernel/irq.clen +=sprintf(buf+len,"   idle ticks\n");
len258arch/i386/kernel/irq.clen+=sprintf(buf+len, "IPI: %10lu   received\n",
len261arch/i386/kernel/irq.creturn len;
len106arch/i386/kernel/setup.cint len = 0;
len169arch/i386/kernel/setup.cif (COMMAND_LINE_SIZE <= ++len)
len93arch/i386/kernel/smp.cstatic int mpf_checksum(unsigned char *mp, int len)
len96arch/i386/kernel/smp.cwhile(len--)
len26arch/i386/lib/checksum.cunsigned int csum_partial(const 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)
len121arch/mips/kernel/irq.cint i, len = 0;
len127arch/mips/kernel/irq.clen += sprintf(buf+len, "%3d: %8d %c %s\n",
len132arch/mips/kernel/irq.creturn len;
len39arch/mips/kernel/syscall.casmlinkage unsigned long sys_mmap(unsigned long addr, size_t len, int prot,
len50arch/mips/kernel/syscall.creturn do_mmap(file, addr, len, prot, flags, offset);
len55arch/mips/kernel/sysmips.cint  flags, len, retval = -EINVAL;
len63arch/mips/kernel/sysmips.clen = get_max_hostname((unsigned long)name);
len65arch/mips/kernel/sysmips.creturn len;
len66arch/mips/kernel/sysmips.clen = strnlen_user(name, retval);
len67arch/mips/kernel/sysmips.cif (len == 0 || len > __NEW_UTS_LEN)
len69arch/mips/kernel/sysmips.cmemcpy_fromfs(system_utsname.nodename, name, len);
len70arch/mips/kernel/sysmips.csystem_utsname.nodename[len] = '\0';
len24arch/mips/lib/checksum.cunsigned int csum_partial(const unsigned char *buff, int len, unsigned int sum)
len128arch/mips/lib/checksum.c: "0"(sum), "r"(len), "r"(buff)
len138arch/mips/lib/checksum.cint len, int sum)
len144arch/mips/lib/checksum.csum = csum_partial(src, len, sum);
len145arch/mips/lib/checksum.cmemcpy(dst, src, len);
len96arch/ppc/kernel/irq.cint i, len = 0;
len102arch/ppc/kernel/irq.clen += sprintf(buf+len, "%2d: %8d %c %s\n",
len107arch/ppc/kernel/irq.creturn len;
len27arch/ppc/kernel/port_io.cvoid insl(int port, long *ptr, int len)
len30arch/ppc/kernel/port_io.cwhile (len-- > 0)
len61arch/ppc/kernel/port_io.cvoid outsl(int port, long *ptr, int len)
len64arch/ppc/kernel/port_io.cwhile (len-- > 0)
len38arch/ppc/kernel/stubs.cextern unsigned short _ip_fast_csum(unsigned char *buf, int len);
len41arch/ppc/kernel/stubs.cip_fast_csum(unsigned char *buf, int len)
len44arch/ppc/kernel/stubs.c_val = _ip_fast_csum(buf, len);
len46arch/ppc/kernel/stubs.cprintk("IP CKSUM(%x, %d) = %x\n", buf, len, _val);
len51arch/ppc/kernel/stubs.cextern unsigned short _ip_compute_csum(unsigned char *buf, int len);
len54arch/ppc/kernel/stubs.cip_compute_csum(unsigned char *buf, int len)
len57arch/ppc/kernel/stubs.c_val = _ip_compute_csum(buf, len);
len59arch/ppc/kernel/stubs.cprintk("Compute IP CKSUM(%x, %d) = %x\n", buf, len, _val);
len65arch/ppc/kernel/stubs.c_udp_check(unsigned char *buf, int len, int saddr, int daddr, int hdr);
len68arch/ppc/kernel/stubs.cudp_check(unsigned char *buf, int len, int saddr, int daddr)
len72arch/ppc/kernel/stubs.chdr = (len << 16) + IPPROTO_UDP;
len73arch/ppc/kernel/stubs.c_val = _udp_check(buf, len, saddr, daddr, hdr);
len75arch/ppc/kernel/stubs.cprintk("UDP CSUM(%x,%d,%x,%x) = %x\n", buf, len, saddr, daddr, _val);
len76arch/ppc/kernel/stubs.cdump_buf(buf, len);
len82arch/ppc/kernel/stubs.c_tcp_check(unsigned char *buf, int len, int saddr, int daddr, int hdr);
len85arch/ppc/kernel/stubs.ctcp_check(unsigned char *buf, int len, int saddr, int daddr)
len89arch/ppc/kernel/stubs.chdr = (len << 16) + IPPROTO_TCP;
len91arch/ppc/kernel/stubs.c_val = _tcp_check(buf, len, saddr, daddr, hdr);
len93arch/ppc/kernel/stubs.cprintk("TCP CSUM(%x,%d,%x,%x) = %x\n", buf, len, saddr, daddr, _val);
len94arch/ppc/kernel/stubs.cdump_buf(buf, len);
len107arch/ppc/kernel/stubs.cunsigned int csum_partial(unsigned char * buff, int len, unsigned int sum)
len113arch/ppc/kernel/stubs.cunsigned int csum_partial_copy(char *src, char *dst, int len, int sum)
len154arch/sparc/kernel/idprom.cregister int len;
len160arch/sparc/kernel/idprom.clen = prom_getproperty(prom_root_node, "vac_hwflush",
len162arch/sparc/kernel/idprom.cif(len != 4) tmp1=0;
len164arch/sparc/kernel/idprom.clen = prom_getproperty(prom_root_node, "vac-hwflush",
len166arch/sparc/kernel/idprom.cif(len != 4) tmp2=0;
len50arch/sparc/kernel/ioport.cvoid *sparc_alloc_io (void *address, void *virtual, int len, char *name,
len63arch/sparc/kernel/ioport.clen += offset;
len64arch/sparc/kernel/ioport.cif (((unsigned long) virtual + len) > (IOBASE_VADDR + IOBASE_LEN)){
len68arch/sparc/kernel/ioport.cif (check_region ((vaddr | offset), len)){
len74arch/sparc/kernel/ioport.crequest_region ((vaddr | offset), len, name);
len78arch/sparc/kernel/ioport.cfor (; len > 0; len -= PAGE_SIZE){
len97arch/sparc/kernel/ioport.cvoid *sparc_dvma_malloc (int len, char *name)
len102arch/sparc/kernel/ioport.cif (check_region (vaddr, len)){
len106arch/sparc/kernel/ioport.cif (vaddr + len > (DVMA_VADDR + DVMA_LEN)){
len117arch/sparc/kernel/ioport.cdvma_next_free = PAGE_ALIGN(dvma_next_free+len);
len119arch/sparc/kernel/ioport.crequest_region(base_address, len, name);
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;
len40arch/sparc/kernel/sys_sunos.cstatic unsigned long get_sparc_unmapped_area(unsigned long len)
len45arch/sparc/kernel/sys_sunos.cif (len > TASK_SIZE)
len49arch/sparc/kernel/sys_sunos.cif (TASK_SIZE - len < addr)
len55arch/sparc/kernel/sys_sunos.cif (addr + len > vmm->vm_start) {
len64arch/sparc/kernel/sys_sunos.casmlinkage unsigned long sunos_mmap(unsigned long addr, unsigned long len,
len80arch/sparc/kernel/sys_sunos.caddr = get_sparc_unmapped_area(len);
len95arch/sparc/kernel/sys_sunos.cretval = do_mmap(file, addr, len, prot, flags, off);
len103arch/sparc/kernel/sys_sunos.casmlinkage int sunos_mctl(unsigned long addr, unsigned long len, int function, char *arg)
len106arch/sparc/kernel/sys_sunos.c"is unsupported\n", current->comm, addr, len, function, arg);
len113arch/sparc/kernel/sys_sunos.casmlinkage int sunos_msync(unsigned long addr, unsigned long len, unsigned long flags)
len116arch/sparc/kernel/sys_sunos.c"is unsupported\n", current->comm, addr, len, flags);
len249arch/sparc/kernel/sys_sunos.casmlinkage void sunos_madvise(unsigned long address, unsigned long len,
len256arch/sparc/kernel/sys_sunos.caddress, len);
len270arch/sparc/kernel/sys_sunos.casmlinkage int sunos_mincore(unsigned long addr, unsigned long len, char *array)
len281arch/sparc/kernel/sys_sunos.cnum_pages = (len / PAGE_SIZE);
len284arch/sparc/kernel/sys_sunos.cif((addr >= KERNBASE) || ((addr + len) > KERNBASE))
len289arch/sparc/kernel/sys_sunos.cfor(limit = addr + len; addr < limit; addr += PAGE_SIZE, pnum++) {
len402arch/sparc/kernel/sys_sunos.casmlinkage int sunos_getdomainname(char *name, int len)
len406arch/sparc/kernel/sys_sunos.cif(len > __NEW_UTS_LEN)
len408arch/sparc/kernel/sys_sunos.cerror = verify_area(VERIFY_WRITE, name, len);
len411arch/sparc/kernel/sys_sunos.cmemcpy_tofs(name, system_utsname.domainname, len);
len432arch/sparc/mm/srmmu.cchar *srmmu_lockarea(char *vaddr, unsigned long len)
len437arch/sparc/mm/srmmu.cvoid srmmu_unlockarea(char *vaddr, unsigned long len)
len441arch/sparc/mm/srmmu.cchar *srmmu_get_scsi_buffer(char *vaddr, unsigned long len)
len446arch/sparc/mm/srmmu.cvoid srmmu_release_scsi_buffer(char *vaddr, unsigned long len)
len574arch/sparc/mm/sun4c.cchar *sun4c_get_scsi_buffer(char *bufptr, unsigned long len)
len577arch/sparc/mm/sun4c.cunsigned long last_page = (((unsigned long) bufptr) + len) & PAGE_MASK;
len580arch/sparc/mm/sun4c.cbufptr = sun4c_lockarea(bufptr, len);
len590arch/sparc/mm/sun4c.cvoid sun4c_release_scsi_buffer(char *bufptr, unsigned long len)
len593arch/sparc/mm/sun4c.cunsigned long last_page = (((unsigned long) bufptr) + len) & PAGE_MASK;
len600arch/sparc/mm/sun4c.csun4c_unlockarea(bufptr, len);
len71arch/sparc/prom/misc.cint len;
len73arch/sparc/prom/misc.clen = prom_getproplen(prom_root_node, "idprom");
len74arch/sparc/prom/misc.cif((len>num_bytes) || (len==-1)) return 0xff;
len116arch/sparc/prom/tree.cint len;
len118arch/sparc/prom/tree.clen = prom_getproperty(node, prop, user_buf, ubuf_size);
len119arch/sparc/prom/tree.cif(len != -1) return;
len548drivers/block/ide-cd.cint len;
len564drivers/block/ide-cd.clen = sizeof (*reqbuf) / 4;
len565drivers/block/ide-cd.clen *= 4;
len568drivers/block/ide-cd.cpc->c[4] = len;
len570drivers/block/ide-cd.cpc->buflen = len;
len908drivers/block/ide-cd.cint cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
len922drivers/block/ide-cd.cwhile (len > 0)
len926drivers/block/ide-cd.clen -= sizeof (dum);
len948drivers/block/ide-cd.cint ireason, len, sectors_to_transfer, nskip;
len957drivers/block/ide-cd.clen = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
len977drivers/block/ide-cd.cif (cdrom_read_check_ireason (drive, len, ireason)) return;
len981drivers/block/ide-cd.cif ((len % SECTOR_SIZE) != 0)
len984drivers/block/ide-cd.cdrive->name, len);
len991drivers/block/ide-cd.csectors_to_transfer = len / SECTOR_SIZE;
len1229drivers/block/ide-cd.cint ireason, len, stat, thislen;
len1238drivers/block/ide-cd.clen = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
len1268drivers/block/ide-cd.cif (thislen > len) thislen = len;
len1287drivers/block/ide-cd.cwhile (len > thislen)
len1291drivers/block/ide-cd.clen -= sizeof (dum);
len1316drivers/block/ide-cd.cwhile (len > thislen)
len1320drivers/block/ide-cd.clen -= sizeof (dum);
len1352drivers/block/ide-cd.cint len;
len1356drivers/block/ide-cd.clen = pc->buflen;
len1357drivers/block/ide-cd.cif (len < 0) len = -len;
len1362drivers/block/ide-cd.ccdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
len2533drivers/block/ide-cd.cint len, lena;
len2542drivers/block/ide-cd.cstat = verify_area (VERIFY_READ, (void *) arg, sizeof (len));
len2544drivers/block/ide-cd.cmemcpy_fromfs (&len, (void *) arg , sizeof (len));
len2545drivers/block/ide-cd.carg += sizeof (len);
len2547drivers/block/ide-cd.cif (len > 0) {
len2548drivers/block/ide-cd.cstat = verify_area (VERIFY_WRITE, (void *) arg, len);
len2552drivers/block/ide-cd.clena = len;
len2557drivers/block/ide-cd.cif (len > 0) {
len2558drivers/block/ide-cd.cpc.buflen = len;
len2564drivers/block/ide-cd.cif (len > 0)
len2565drivers/block/ide-cd.cmemcpy_tofs ((void *)arg, buf, len);
len99drivers/block/rd.cint offset, len;
len112drivers/block/rd.clen = CURRENT->current_nr_sectors << 9;
len114drivers/block/rd.cif ((offset + len) > rd_length[minor]) {
len127drivers/block/rd.cmemset(CURRENT->buffer, 0, len); 
len259drivers/cdrom/sjcd.cstatic int sjcd_load_response( void *buf, int len ){
len262drivers/cdrom/sjcd.cfor( ; len; --len ){ 
len268drivers/cdrom/sjcd.creturn( len );
len653drivers/char/istallion.cstatic void  stli_delay(int len);
len664drivers/char/istallion.cstatic void  *stli_memalloc(int len);
len845drivers/char/istallion.cstatic void *stli_memalloc(int len)
len847drivers/char/istallion.creturn((void *) kmalloc(len, GFP_KERNEL));
len1344drivers/char/istallion.cstatic void stli_delay(int len)
len1347drivers/char/istallion.cprintk("stl_delay(len=%d)\n", len);
len1349drivers/char/istallion.cif (len > 0) {
len1351drivers/char/istallion.ccurrent->timeout = jiffies + len;
len1430drivers/char/istallion.cunsigned int    len, stlen, head, tail, size;
len1471drivers/char/istallion.clen = (head >= tail) ? (portp->txsize - (head - tail) - 1) : (tail - head - 1);
len1472drivers/char/istallion.ccount = MIN(len, count);
len1495drivers/char/istallion.clen = size - (head - tail) - 1;
len1498drivers/char/istallion.clen = tail - head - 1;
len1499drivers/char/istallion.cstlen = len;
len1502drivers/char/istallion.clen = MIN(len, count);
len1506drivers/char/istallion.cwhile (len > 0) {
len1507drivers/char/istallion.cstlen = MIN(len, stlen);
len1510drivers/char/istallion.clen -= stlen;
len1582drivers/char/istallion.cunsigned int    len, stlen, head, tail, size, count, cooksize;
len1625drivers/char/istallion.clen = size - (head - tail) - 1;
len1628drivers/char/istallion.clen = tail - head - 1;
len1629drivers/char/istallion.cstlen = len;
len1632drivers/char/istallion.clen = MIN(len, cooksize);
len1637drivers/char/istallion.cwhile (len > 0) {
len1638drivers/char/istallion.cstlen = MIN(len, stlen);
len1641drivers/char/istallion.clen -= stlen;
len1674drivers/char/istallion.cunsigned int    head, tail, len;
len1685drivers/char/istallion.clen = stli_txcookrealsize - stli_txcooksize;
len1686drivers/char/istallion.creturn(len);
len1707drivers/char/istallion.clen = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
len1708drivers/char/istallion.clen--;
len1713drivers/char/istallion.cstli_txcookrealsize = len;
len1714drivers/char/istallion.clen -= stli_txcooksize;
len1716drivers/char/istallion.creturn(len);
len1734drivers/char/istallion.cunsigned int    head, tail, len;
len1762drivers/char/istallion.clen = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
len1763drivers/char/istallion.cif ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
len1764drivers/char/istallion.clen = 1;
len1768drivers/char/istallion.creturn(len);
len2329drivers/char/istallion.cunsigned int    len, stlen;
len2348drivers/char/istallion.clen = head - tail;
len2349drivers/char/istallion.cstlen = len;
len2351drivers/char/istallion.clen = size - (tail - head);
len2355drivers/char/istallion.clen = MIN(len, (TTY_FLIPBUF_SIZE - tty->flip.count));
len2358drivers/char/istallion.cwhile (len > 0) {
len2359drivers/char/istallion.cstlen = MIN(len, stlen);
len2366drivers/char/istallion.clen -= stlen;
len75drivers/char/softdog.cstatic int softdog_write(struct inode *inode, struct file *file, const char *data, int len)
len489drivers/char/stallion.cstatic void  stl_sendbreak(stlport_t *portp, long len);
len491drivers/char/stallion.cstatic void  stl_delay(int len);
len494drivers/char/stallion.cstatic void  *stl_memalloc(int len);
len610drivers/char/stallion.cstatic void *stl_memalloc(int len)
len612drivers/char/stallion.creturn((void *) kmalloc(len, GFP_KERNEL));
len871drivers/char/stallion.cstatic void stl_delay(int len)
len874drivers/char/stallion.cprintk("stl_delay(len=%d)\n", len);
len876drivers/char/stallion.cif (len > 0) {
len878drivers/char/stallion.ccurrent->timeout = jiffies + len;
len893drivers/char/stallion.cunsigned int  len, stlen;
len920drivers/char/stallion.clen = (head >= tail) ? (STL_TXBUFSIZE - (head - tail) - 1) :
len922drivers/char/stallion.ccount = MIN(len, count);
len936drivers/char/stallion.clen = STL_TXBUFSIZE - (head - tail) - 1;
len939drivers/char/stallion.clen = tail - head - 1;
len940drivers/char/stallion.cstlen = len;
len943drivers/char/stallion.clen = MIN(len, count);
len945drivers/char/stallion.cwhile (len > 0) {
len946drivers/char/stallion.cstlen = MIN(len, stlen);
len948drivers/char/stallion.clen -= stlen;
len970drivers/char/stallion.cunsigned int  len;
len988drivers/char/stallion.clen = (head >= tail) ? (STL_TXBUFSIZE - (head - tail)) : (tail - head);
len989drivers/char/stallion.clen--;
len991drivers/char/stallion.cif (len > 0) {
len1532drivers/char/stallion.cint    len, stlen;
len1573drivers/char/stallion.clen = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
len1574drivers/char/stallion.cif ((len == 0) || ((len < STL_TXBUFLOW) && (test_bit(ASYI_TXLOW, &portp->istate) == 0))) {
len1579drivers/char/stallion.cif (len == 0) {
len1590drivers/char/stallion.clen = MIN(len, CD1400_TXFIFOSIZE);
len1591drivers/char/stallion.cstlen = MIN(len, ((portp->tx.buf + STL_TXBUFSIZE) - tail));
len1594drivers/char/stallion.clen -= stlen;
len1598drivers/char/stallion.cif (len > 0) {
len1599drivers/char/stallion.coutsb((ioaddr + EREG_DATA), tail, len);
len1600drivers/char/stallion.ctail += len;
len1626drivers/char/stallion.cunsigned int    ioack, len, buflen;
len1645drivers/char/stallion.clen = inb(ioaddr + EREG_DATA);
len1649drivers/char/stallion.cinsb((ioaddr + EREG_DATA), &unwanted[0], len);
len1651drivers/char/stallion.clen = MIN(len, buflen);
len1652drivers/char/stallion.cif (len > 0) {
len1654drivers/char/stallion.cinsb((ioaddr + EREG_DATA), tty->flip.char_buf_ptr, len);
len1655drivers/char/stallion.cmemset(tty->flip.flag_buf_ptr, 0, len);
len1656drivers/char/stallion.ctty->flip.flag_buf_ptr += len;
len1657drivers/char/stallion.ctty->flip.char_buf_ptr += len;
len1658drivers/char/stallion.ctty->flip.count += len;
len2325drivers/char/stallion.cstatic void stl_sendbreak(stlport_t *portp, long len)
len2330drivers/char/stallion.cprintk("stl_sendbreak(portp=%x,len=%d)\n", (int) portp, (int) len);
len2340drivers/char/stallion.clen = len / 5;
len2341drivers/char/stallion.cportp->brklen = (len > 255) ? 255 : len;
len433drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len462drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
len74drivers/net/3c505.c#define INVALID_PCB_MSG(len) \
len75drivers/net/3c505.cprintk(invalid_pcb_msg, (len),filename,__FUNCTION__,__LINE__)
len551drivers/net/3c505.creceive_packet (struct device * dev, int len)
len563drivers/net/3c505.cif (len <= 0 || ((len & ~1) != len))
len566drivers/net/3c505.cprintk("*** bad packet len %d at %s(%d)\n",len,filename,__LINE__);
len570drivers/net/3c505.crlen = (len+1) & ~1;
len605drivers/net/3c505.cptr = (unsigned short *)skb_put(skb,len);
len640drivers/net/3c505.cint len;
len693drivers/net/3c505.clen = adapter->irx_pcb.data.rcv_resp.pkt_len;
len701drivers/net/3c505.cprintk("%s: interrupt - packet received of length %i (%i)\n", dev->name, len, dlen);
len942drivers/net/3c505.csend_packet (struct device * dev, unsigned char * ptr, int len)
len951drivers/net/3c505.cunsigned int nlen = (((len < 60) ? 60 : len) + 1) & (~1);
len958drivers/net/3c505.cif (nlen < len)
len959drivers/net/3c505.cprintk("Warning, bad length nlen=%d len=%d %s(%d)\n",nlen,len,filename,__LINE__);
len1020drivers/net/3c505.cif (skb->len <= 0)
len1024drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
len1045drivers/net/3c505.cif (!send_packet(dev, skb->data, skb->len)) {
len1051drivers/net/3c505.cprintk("%s: packet of length %d sent\n", dev->name, (int)skb->len);
len495drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len406drivers/net/3c509.cif (skb->len <= 0)
len411drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
len435drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
len438drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
len663drivers/net/3c59x.cif (skb == NULL || skb->len <= 0) {
len679drivers/net/3c59x.coutl(skb->len, ioaddr + TX_FIFO);
len684drivers/net/3c59x.coutw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
len689drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
len699drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
len187drivers/net/8390.clength = skb->len;
len188drivers/net/8390.cif (skb->len <= 0)
len613drivers/net/apricot.cif (skb->len <= 0) return 0;
len623drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len603drivers/net/arcnet.cunsigned short type,void *daddr,void *saddr,unsigned len);
len623drivers/net/arcnet.cunsigned short type,void *daddr,void *saddr,unsigned len);
len1502drivers/net/arcnet.cout->length = 1 < skb->len ? skb->len : 1;
len1509drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len2260drivers/net/arcnet.cskb->len = length;
len2309drivers/net/arcnet.cfor(i=0; i< skb->len; i++)
len2400drivers/net/arcnet.cskb->len=sizeof(struct ClientData);
len2454drivers/net/arcnet.cmemcpy(skb->data+skb->len,
len2458drivers/net/arcnet.cskb->len+=length-sizeof(struct ClientData);
len2479drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len2546drivers/net/arcnet.cunsigned short type,void *daddr,void *saddr,unsigned len)
len2555drivers/net/arcnet.ctype,type,len);
len2739drivers/net/arcnet.cshort offset,length=skb->len+1;
len2806drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
len2870drivers/net/arcnet.cskb->len = length;
len2879drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len2947drivers/net/arcnet.clength = 1 < skb->len ? skb->len : 1;
len2952drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len3028drivers/net/arcnet.cskb->len = length;
len3043drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
len3064drivers/net/arcnet.cunsigned short type,void *daddr,void *saddr,unsigned len)
len408drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len450drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len415drivers/net/de4x5.cstatic void    create_packet(struct device *dev, char *frame, int len);
len978drivers/net/de4x5.cif (lp->skb[i]->len != FAKE_FRAME_LEN) {
len990drivers/net/de4x5.cif (skb->len != FAKE_FRAME_LEN) {
len1025drivers/net/de4x5.c} else if (skb->len == FAKE_FRAME_LEN) {     /* Don't TX a fake frame! */
len1027drivers/net/de4x5.c} else if (skb->len > 0) {
len1035drivers/net/de4x5.cload_packet(dev, skb->data, TD_IC | TD_LS | TD_FS | skb->len, skb);
len1154drivers/net/de4x5.cshort len = (lp->rxRingSize - lp->rx_old) * RX_BUFF_SZ;
len1155drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
len1156drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
len2125drivers/net/de4x5.cstatic void create_packet(struct device *dev, char *frame, int len)
len2481drivers/net/de4x5.cskb->len= FAKE_FRAME_LEN;
len2509drivers/net/de4x5.cioc->len = ETH_ALEN;
len2510drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
len2516drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len2571drivers/net/de4x5.cioc->len = (HASH_TABLE_LEN >> 3);
len2572drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, ioc->data, ioc->len);
len2575drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
len2580drivers/net/de4x5.cif (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
len2581drivers/net/de4x5.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN * ioc->len))) {
len2582drivers/net/de4x5.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len2612drivers/net/de4x5.cioc->len = sizeof(lp->pktStats);
len2613drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
len2618drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
len2660drivers/net/de4x5.cioc->len = j;
len2661drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len2662drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len2723drivers/net/de4x5.cioc->len = j;
len2724drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len2725drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len625drivers/net/de4x5.hunsigned short len;                /* Length of the data buffer */
len400drivers/net/de600.cint  len;
len434drivers/net/de600.cPRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
len436drivers/net/de600.cif ((len = skb->len) < RUNT)
len437drivers/net/de600.clen = RUNT;
len441drivers/net/de600.ctx_fifo[tx_fifo_in] = transmit_from = tx_page_adr(tx_fifo_in) - len;
len457drivers/net/de600.cfor ( ; len > 0; --len, ++buffer)
len514drivers/net/de620.cint len;
len550drivers/net/de620.cif ((len = skb->len) < RUNT)
len551drivers/net/de620.clen = RUNT;
len552drivers/net/de620.cif (len & 1) /* send an even number of bytes */
len553drivers/net/de620.c++len;
len560drivers/net/de620.c(int)skb->len, using_txbuf));
len581drivers/net/de620.cde620_write_block(dev, buffer, len);
len806drivers/net/depca.c} else if (skb->len > 0) {
len911drivers/net/depca.cshort len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
len921drivers/net/depca.clen = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
len922drivers/net/depca.cmemcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
len923drivers/net/depca.cmemcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
len1532drivers/net/depca.cint i, entry, end, len, status = 0;
len1535drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
len1542drivers/net/depca.clen = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
len1543drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
len1544drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
len1546drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
len1550drivers/net/depca.clen = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
len1556drivers/net/depca.clen -= TX_BUFF_SZ;
len1561drivers/net/depca.cwritew(-len, &lp->tx_ring[end].length);    /* packet length in last buff */
len1713drivers/net/depca.cioc->len = ETH_ALEN;
len1714drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len1715drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1782drivers/net/depca.cioc->len = (HASH_TABLE_LEN >> 3);
len1783drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1784drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
len1790drivers/net/depca.cif (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
len1791drivers/net/depca.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len1817drivers/net/depca.cioc->len = sizeof(lp->pktStats);
len1818drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1819drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
len1840drivers/net/depca.cioc->len = i+sizeof(struct depca_init);
len1841drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1842drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len164drivers/net/depca.hunsigned short len;                /* Length of the data buffer */
len642drivers/net/eepro.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len494drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len154drivers/net/eql.cunsigned len); /*  */
len380drivers/net/eql.cdev->name, eql_number_slaves (eql->queue), skb->len,
len385drivers/net/eql.cslave->bytes_queued += skb->len; 
len410drivers/net/eql.cunsigned len)
len932drivers/net/eth16i.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len758drivers/net/ewrk3.c} else if (skb->len > 0) {
len809drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
len810drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
len812drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
len819drivers/net/ewrk3.cwriteb((char)(skb->len & 0xff), (char *)buf);/* length (16 bit xfer)*/
len822drivers/net/ewrk3.cwriteb((char)(((skb->len >> 8) & 0xff) | XCT), (char *)buf);
len826drivers/net/ewrk3.cwriteb(0x00, (char *)(buf + skb->len));    /* Write the XCT flag */
len829drivers/net/ewrk3.cmemcpy_toio(buf+PRELOAD, skb->data+PRELOAD, skb->len-PRELOAD);
len830drivers/net/ewrk3.cwriteb(0xff, (char *)(buf + skb->len));    /* Write the XCT flag */
len832drivers/net/ewrk3.cwriteb((char)((skb->len >> 8) & 0xff), (char *)buf);
len836drivers/net/ewrk3.cmemcpy_toio((char *)buf, skb->data, skb->len);/* Write data bytes */
len1687drivers/net/ewrk3.cioc->len = ETH_ALEN;
len1688drivers/net/ewrk3.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
len1689drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1740drivers/net/ewrk3.cif (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1752drivers/net/ewrk3.cioc->len = (HASH_TABLE_LEN >> 3);
len1753drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len); 
len1760drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
len1761drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
len1790drivers/net/ewrk3.cioc->len = sizeof(lp->pktStats);
len1791drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1792drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
len1809drivers/net/ewrk3.cioc->len = 1;
len1810drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1811drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1836drivers/net/ewrk3.cioc->len = EEPROM_MAX + 1 + ETH_ALEN;
len1837drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1838drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len1860drivers/net/ewrk3.cioc->len = 1;
len1861drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
len1862drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
len298drivers/net/ewrk3.hunsigned short len;                /* Length of the data buffer */
len595drivers/net/hp100.cif ( ( i = ( hp100_inl( TX_MEM_FREE ) & ~0x7fffffff ) ) < skb -> len + 16 )
len645drivers/net/hp100.cif ( skb -> len <= 0 ) return 0;
len658drivers/net/hp100.cprintk( "hp100_start_xmit: irq_status = 0x%x, len = %d\n", val, (int)skb -> len );
len660drivers/net/hp100.cok_flag = skb -> len >= HP100_MIN_PACKET_SIZE;
len661drivers/net/hp100.ci = ok_flag ? skb -> len : HP100_MIN_PACKET_SIZE;
len668drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
len670drivers/net/hp100.cmemset( lp -> mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb -> len );
len674drivers/net/hp100.cmemcpy_toio( lp -> mem_ptr_phys, skb -> data, skb -> len );
len676drivers/net/hp100.cmemset_io( lp -> mem_ptr_phys, 0, HP100_MIN_PACKET_SIZE - skb -> len );
len681drivers/net/hp100.coutsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
len683drivers/net/hp100.cfor ( i = ( skb -> len + 3 ) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4 )
len1094drivers/net/ibmtr.cti->current_skb->len-18));
len1104drivers/net/ibmtr.cti->current_skb->len-18+hdr_len);
len1114drivers/net/ibmtr.cxmit_resp->frame_length=htons(ti->current_skb->len
len1119drivers/net/ibmtr.cti->current_skb->len-sizeof(struct trh_hdr));
len752drivers/net/lance.cif (skb->len <= 0)
len787drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
len789drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
len795drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
len799drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
len612drivers/net/ni52.cint len = ((char *) p->iscp - (char *) ptr - 8) / 6;
len613drivers/net/ni52.cif(len <= 0)
len619drivers/net/ni52.cif(len < num_addrs)
len622drivers/net/ni52.cnum_addrs = len;
len942drivers/net/ni52.cint len,i;
len990drivers/net/ni52.cif (skb->len <= 0)
len992drivers/net/ni52.cif(skb->len > XMIT_BUFF_SIZE)
len994drivers/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);
len1002drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
len1003drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
len1007drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1028drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
len1040drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
len502drivers/net/ni65.cint rmdstat,len;
len531drivers/net/ni65.clen = (rmdp->mlen & 0x0fff) - 4; /* -4: ignore FCS */
len536drivers/net/ni65.cmemcpy(skb_put(skb,len),p->recv_skb[p->rmdnum]->data,len);
len542drivers/net/ni65.crmdp->u.buffer = (unsigned long) skb_put(skb1,len);
len590drivers/net/ni65.cif (skb->len <= 0)
len605drivers/net/ni65.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len613drivers/net/ni65.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff),(char *)skb->data,skb->len);
len616drivers/net/ni65.ctmdp->blen = -len;
len443drivers/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);
len901drivers/net/plip.cif (skb->len > dev->mtu + dev->hard_header_len) {
len902drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
len913drivers/net/plip.csnd->length.h = skb->len;
len157drivers/net/ppp.cstatic void ppp_proto_ccp (struct ppp *ppp, u_char *dp, int len, int rcvd);
len204drivers/net/ppp.cunsigned len, struct sk_buff *skb);
len1270drivers/net/ppp.cskb->len = count;
len1360drivers/net/ppp.cu_char *data, int len)
len1386drivers/net/ppp.ctotlen = len + 2;
len1412drivers/net/ppp.clen + 2, ppp->flags);
len1442drivers/net/ppp.cstatic void ppp_proto_ccp (struct ppp *ppp, u_char *dp, int len, int rcvd)
len1448drivers/net/ppp.cif (slen > len)
len1530drivers/net/ppp.crcv_proto_ccp (struct ppp *ppp, unsigned short proto, u_char *dp, int len)
len1532drivers/net/ppp.cppp_proto_ccp (ppp, dp, len, 1);
len1533drivers/net/ppp.creturn rcv_proto_unknown (ppp, proto, dp, len);
len1545drivers/net/ppp.crcv_proto_lqr (struct ppp *ppp, unsigned short proto, u_char * data, int len)
len1549drivers/net/ppp.cif (len > 8) {
len1550drivers/net/ppp.cif (len < 48)
len1551drivers/net/ppp.cmemset (&data [len], '\0', 48 - len);
len1560drivers/net/ppp.cp = store_long (p, ppp->stats.ppp_ioctects + len);
len1562drivers/net/ppp.clen = 68;
len1568drivers/net/ppp.creturn rcv_proto_unknown (ppp, proto, data, len);
len1778drivers/net/ppp.cint len, indx;
len1833drivers/net/ppp.clen = 0;
len1836drivers/net/ppp.clen = c << 8;
len1838drivers/net/ppp.clen += c;
len1843drivers/net/ppp.cif (len == 0) {
len1868drivers/net/ppp.cprintk (KERN_DEBUG "ppp_tty_read: len = %d\n", len);
len1873drivers/net/ppp.cif (len + 2 > nr) {
len1879drivers/net/ppp.c"frame\n", nr, len + 2);
len1880drivers/net/ppp.cppp->ubuf->tail += len;
len1890drivers/net/ppp.cindx = verify_area (VERIFY_WRITE, buf, len + 2);
len1892drivers/net/ppp.cppp->ubuf->tail += len;
len1904drivers/net/ppp.cindx = len;
len1917drivers/net/ppp.clen += 2; /* Account for ADDRESS and CONTROL bytes */
len1920drivers/net/ppp.c"ppp_tty_read: passing %d bytes up\n", len);
len1921drivers/net/ppp.creturn len;
len2123drivers/net/ppp.csend_revise_frame (register struct ppp *ppp, u_char *data, int len)
len2133drivers/net/ppp.clen = 48;      /* total size of this frame */
len2136drivers/net/ppp.cp   = store_long (p, ppp->stats.ppp_ooctects + len);
len2144drivers/net/ppp.clen  - PPP_HARD_HDR_LEN,
len2154drivers/net/ppp.creturn len;
len2753drivers/net/ppp.cint len;
len2759drivers/net/ppp.clen    = strlen (szVersion) + 1;
len2760drivers/net/ppp.cerror  = verify_area (VERIFY_WRITE, result, len);
len2765drivers/net/ppp.cmemcpy_tofs (result, szVersion, len);
len2893drivers/net/ppp.cint   len;
len2899drivers/net/ppp.clen = ((struct iphdr *)data) -> tot_len;
len2900drivers/net/ppp.clen = ntohs (len);
len2942drivers/net/ppp.cppp_print_buffer ("ppp outpkt", data, len);
len2949drivers/net/ppp.clen = slhc_compress (ppp->slcomp, data, len,
len2966drivers/net/ppp.clen  += PPP_HARD_HDR_LEN;
len2974drivers/net/ppp.creturn ppp_dev_xmit_frame (ppp, ppp->wbuf, (u_char *) hdr, len);
len2990drivers/net/ppp.cint     len;
len2993drivers/net/ppp.clen = ((struct iphdr *)data) -> tot_len;
len2994drivers/net/ppp.clen = ntohs (len);
len2996drivers/net/ppp.chdr = (struct ppp_hdr *) kmalloc (len + sizeof (struct ppp_hdr),
len3002drivers/net/ppp.cmemcpy (&hdr[1], data, len);
len3020drivers/net/ppp.cu_char *data, int len, int proto)
len3065drivers/net/ppp.cppp_print_buffer ("ppp outpkt", data, len);
len3069drivers/net/ppp.clen  += PPP_HARD_HDR_LEN;
len3077drivers/net/ppp.creturn ppp_dev_xmit_frame (ppp, ppp->wbuf, (u_char *) hdr, len);
len3091drivers/net/ppp.cu_char *data, int len, int proto)
len3096drivers/net/ppp.chdr = (struct ppp_hdr *) kmalloc (len + sizeof (struct ppp_hdr),
len3101drivers/net/ppp.cmemcpy (&hdr[1], data, len);
len3103drivers/net/ppp.clen, proto);
len3118drivers/net/ppp.cint answer, len;
len3158drivers/net/ppp.clen   = skb->len;
len3168drivers/net/ppp.canswer = ppp_dev_xmit_ipx (dev, ppp, data, len, PPP_IPX);
len3285drivers/net/ppp.cunsigned len, struct sk_buff *skb)
len3289drivers/net/ppp.cvoid *saddr, unsigned len)
len186drivers/net/pt.cif (ptr[0] != 0 && skb->len >= 2)
len188drivers/net/pt.cprintk("Rx KISS... Control = %d, value = %d.\n", ptr[0], (skb->len > 1? ptr[1] : -1));
len340drivers/net/pt.cvoid *daddr, void *saddr, unsigned len)
len342drivers/net/pt.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
len1183drivers/net/pt.clp->txcnt = (int) lp->sndbuf->len - 1;
len1624drivers/net/pt.clp->txcnt = (int) lp->sndbuf->len - 1;
len1637drivers/net/pt.clength = lp->sndbuf->len - 1;
len405drivers/net/seeq8005.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
len1249drivers/net/sk_g16.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 
len1258drivers/net/sk_g16.cskb->len);
len1260drivers/net/sk_g16.ctmdp->blen = -len;            /* set length to transmit */
len1569drivers/net/sk_g16.cint len = (rmdp->mlen & 0x0fff);  /* extract message length from receive buffer */
len1572drivers/net/sk_g16.cskb = dev_alloc_skb(len+2); /* allocate socket buffer */ 
len1602drivers/net/sk_g16.cmemcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
len1603drivers/net/sk_g16.clen);
len380drivers/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);
len636drivers/net/slhc.creturn len;
len104drivers/net/slip.cstatic int slip_esc(unsigned char *p, unsigned char *d, int len);
len107drivers/net/slip.cstatic int slip_esc6(unsigned char *p, unsigned char *d, int len);
len230drivers/net/slip.cint len;
len233drivers/net/slip.clen = dev->mtu * 2;
len239drivers/net/slip.cif (len < 576 * 2)  {
len240drivers/net/slip.clen = 576 * 2;
len243drivers/net/slip.cxbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len244drivers/net/slip.crbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len246drivers/net/slip.ccbuff = (unsigned char *) kmalloc (len + 4, GFP_ATOMIC);
len282drivers/net/slip.cif (sl->xleft <= len)  {
len292drivers/net/slip.cif (sl->rcount <= len) {
len305drivers/net/slip.csl->buffsize = len;
len402drivers/net/slip.csl_encaps(struct slip *sl, unsigned char *icp, int len)
len416drivers/net/slip.cif (len > sl->mtu) {    /* Sigh, shouldn't occur BUT ... */
len417drivers/net/slip.clen = sl->mtu;
len427drivers/net/slip.clen = slhc_compress(sl->slcomp, p, len, sl->cbuff, &p, 1);
len432drivers/net/slip.ccount = slip_esc6(p, (unsigned char *) sl->xbuff, len);
len435drivers/net/slip.ccount = slip_esc(p, (unsigned char *) sl->xbuff, len);
len528drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
len540drivers/net/slip.cvoid *daddr, void *saddr, unsigned len)
len547drivers/net/slip.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
len578drivers/net/slip.cunsigned long len;
len591drivers/net/slip.clen = dev->mtu * 2;
len597drivers/net/slip.cif (len < 576 * 2)  {
len598drivers/net/slip.clen = 576 * 2;
len600drivers/net/slip.csl->rbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len604drivers/net/slip.csl->xbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len609drivers/net/slip.csl->cbuff = (unsigned char *) kmalloc(len + 4, GFP_KERNEL);
len624drivers/net/slip.csl->buffsize = len;
len851drivers/net/slip.cslip_esc(unsigned char *s, unsigned char *d, int len)
len869drivers/net/slip.cwhile (len-- > 0) {
len936drivers/net/slip.cslip_esc6(unsigned char *s, unsigned char *d, int len)
len956drivers/net/slip.cfor (i = 0; i < len; ++i) {
len607drivers/net/sunlance.cint entry, skblen, len;
len631drivers/net/sunlance.cif (skb->len <= 0){
len632drivers/net/sunlance.cprintk ("skb len is %ld\n", skb->len);
len644drivers/net/sunlance.cskblen = skb->len;
len657drivers/net/sunlance.clen = (skblen < ETH_ZLEN) ? ETH_ZLEN : skblen;
len659drivers/net/sunlance.cib->btx_ring [entry].length = (-len) | 0xf000;
len665drivers/net/sunlance.cif (len != skblen){
len666drivers/net/sunlance.cmemset ((char *) &ib->tx_buf [entry][skblen], 0, len - skblen);
len406drivers/net/tulip.cif (skb == NULL || skb->len <= 0) {
len429drivers/net/tulip.ctp->tx_ring[entry].length = skb->len |
len209drivers/net/tunnel.cnewlen = (skb->len + ip_header_len);
len225drivers/net/tunnel.cmemcpy(skb2->data + ip_header_len, skb->data, skb->len);
len235drivers/net/tunnel.ciph->tot_len = htons(skb2->len);
len1444drivers/net/wavelan.clength = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
len2117drivers/net/wavelan.cint    len;
len2123drivers/net/wavelan.clen = 0;
len2130drivers/net/wavelan.clen += size;
len2141drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
len2143drivers/net/wavelan.clen += size;
len2144drivers/net/wavelan.cpos = begin + len;
len2148drivers/net/wavelan.clen = 0;
len2161drivers/net/wavelan.clen -= (offset - begin);    /* Start slop */
len2162drivers/net/wavelan.cif (len > length)
len2163drivers/net/wavelan.clen = length;      /* Ending slop */
len2165drivers/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);
len549drivers/pci/pci.cint reg, len = 0;
len563drivers/pci/pci.cif (len + 80 > size) {
len566drivers/pci/pci.clen += sprintf(buf + len, "  Bus %2d, device %3d, function %2d:\n",
len569drivers/pci/pci.cif (len + 80 > size) {
len572drivers/pci/pci.clen += sprintf(buf + len, "    %s: %s %s (rev %d).\n      ",
len577drivers/pci/pci.clen += sprintf(buf + len,
len588drivers/pci/pci.cif (len + strlen(str) > size) {
len591drivers/pci/pci.clen += sprintf(buf + len, str);
len595drivers/pci/pci.cif (len + strlen(fast_b2b_capable) > size) {
len598drivers/pci/pci.clen += sprintf(buf + len, fast_b2b_capable);
len604drivers/pci/pci.cif (len + strlen(BIST_capable) > size) {
len607drivers/pci/pci.clen += sprintf(buf + len, BIST_capable);
len612drivers/pci/pci.cif (len + 40 > size) {
len615drivers/pci/pci.clen += sprintf(buf + len, "IRQ %d.  ", dev->irq);
len619drivers/pci/pci.cif (len + 80 > size) {
len622drivers/pci/pci.clen += sprintf(buf + len, "Master Capable.  ");
len624drivers/pci/pci.clen += sprintf(buf + len, "Latency=%d.  ", latency);
len626drivers/pci/pci.clen += sprintf(buf + len, "No bursts.  ");
len628drivers/pci/pci.clen += sprintf(buf + len, "Min Gnt=%d.", min_gnt);
len630drivers/pci/pci.clen += sprintf(buf + len, "Max Lat=%d.", max_lat);
len634drivers/pci/pci.cif (len + 40 > size) {
len644drivers/pci/pci.clen += sprintf(buf + len,
len668drivers/pci/pci.clen += sprintf(buf + len,
len675drivers/pci/pci.clen += sprintf(buf + len, "\n");
len676drivers/pci/pci.creturn len;
len686drivers/pci/pci.cint nprinted, len, size;
len692drivers/pci/pci.clen   = sprintf(buf, "PCI devices found:\n");
len695drivers/pci/pci.cnprinted = sprint_dev_config(dev, buf + len, size - len);
len697drivers/pci/pci.creturn len + sprintf(buf + len, MSG);
len699drivers/pci/pci.clen += nprinted;
len701drivers/pci/pci.creturn len;
len899drivers/pci/pci.cint len = get_pci_list((char*)mem_start);
len900drivers/pci/pci.cif (len) {
len901drivers/pci/pci.c((char *) mem_start)[len] = '\0';
len3099drivers/scsi/53c7,8xx.csize_t len;
len3117drivers/scsi/53c7,8xx.clen = strlen(buf);
len3120drivers/scsi/53c7,8xx.csprintf(buf + len, "%08x\n", * (u32 *) bp->addr);
len3122drivers/scsi/53c7,8xx.csprintf(buf + len, "\n");
len3124drivers/scsi/53c7,8xx.clen = strlen(buf);
len3125drivers/scsi/53c7,8xx.cdebugger_kernel_write (host, buf, len);
len3138drivers/scsi/53c7,8xx.csize_t len;
len3200drivers/scsi/53c7,8xx.cint i, j, error, len;
len3221drivers/scsi/53c7,8xx.clen = strlen (debugger_tokens[i].name);
len3222drivers/scsi/53c7,8xx.cif (!strncmp(input_buf, debugger_tokens[i].name, len)) 
len3229drivers/scsi/53c7,8xx.cfor (ptr = input_buf + len, j = 0; j < debugger_tokens[i].nargs && *ptr;) {
len5377drivers/scsi/53c7,8xx.csize_t len = strlen(buf);
len5378drivers/scsi/53c7,8xx.cdebugger_kernel_write(host, buf, len);
len5782drivers/scsi/53c7,8xx.cint i, len;
len5810drivers/scsi/53c7,8xx.cptr += len, i -= len) {
len5812drivers/scsi/53c7,8xx.clen = print_msg (ptr);
len5814drivers/scsi/53c7,8xx.cif (!len)
len1393drivers/scsi/AM53C974.cint                      ret, i, len, residual=-1;
len1471drivers/scsi/AM53C974.clen = 1;
len1481drivers/scsi/AM53C974.clen = hostdata->msgout[1] + 2; }
len1483drivers/scsi/AM53C974.clen = 2;
len1485drivers/scsi/AM53C974.cfor (i = 0; i < len; i++) AM53C974_write_8(FFREG, hostdata->msgout[i]);
len1550drivers/scsi/AM53C974.cint                      len, ret = 0;
len1724drivers/scsi/AM53C974.cextended_msg[1] = len = AM53C974_read_8(FFREG); /* get length */
len1727drivers/scsi/AM53C974.cwhile (len) {
len1730drivers/scsi/AM53C974.cif (len > 1) {
len1734drivers/scsi/AM53C974.cp++; len--; }
len1791drivers/scsi/AM53C974.cunsigned int             i, len, cmd_size = COMMAND_SIZE(cmd->cmnd[0]);
len1814drivers/scsi/AM53C974.clen = 3;
len1822drivers/scsi/AM53C974.clen = 1;
len1836drivers/scsi/AM53C974.clen += 5; }
len1840drivers/scsi/AM53C974.cswitch (len) {
len1265drivers/scsi/NCR5380.cint len;
len1536drivers/scsi/NCR5380.clen = 3;
len1540drivers/scsi/NCR5380.clen = 1;
len1547drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len1740drivers/scsi/NCR5380.cint len;
len1770drivers/scsi/NCR5380.clen = 1;
len1772drivers/scsi/NCR5380.cNCR5380_transfer_pio (host, &phase, &len, &msgptr);
len1779drivers/scsi/NCR5380.creturn len ? -1 : 0;
len2154drivers/scsi/NCR5380.cint len;
len2251drivers/scsi/NCR5380.clen = transfersize;
len2253drivers/scsi/NCR5380.c&len, (unsigned char **) &cmd->SCp.ptr)) {
len2269drivers/scsi/NCR5380.ccmd->SCp.this_residual -= transfersize - len;
len2277drivers/scsi/NCR5380.clen = 1;
len2279drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2485drivers/scsi/NCR5380.clen = 2;
len2488drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2496drivers/scsi/NCR5380.cif (!len && extended_msg[1] <= 
len2500drivers/scsi/NCR5380.clen = extended_msg[1] - 1;
len2504drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2508drivers/scsi/NCR5380.cinstance->host_no, len);
len2518drivers/scsi/NCR5380.c} else if (len) {
len2552drivers/scsi/NCR5380.clen = 1;
len2555drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2567drivers/scsi/NCR5380.clen = cmd->cmd_len;
len2574drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, 
len2589drivers/scsi/NCR5380.clen = 1;
len2591drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len2636drivers/scsi/NCR5380.cint len;
len2680drivers/scsi/NCR5380.clen = 1;
len2683drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
len358drivers/scsi/NCR53c406a.cint  len;  /* current scsi fifo size */
len371drivers/scsi/NCR53c406a.clen=0; break;
len373drivers/scsi/NCR53c406a.clen=1; break;
len375drivers/scsi/NCR53c406a.clen=42; break;
len377drivers/scsi/NCR53c406a.clen=84; break;
len379drivers/scsi/NCR53c406a.clen=128; break;
len382drivers/scsi/NCR53c406a.cif ((i & 0x40) && len == 0) { /* fifo empty and interrupt occured */
len386drivers/scsi/NCR53c406a.cif (len) {
len387drivers/scsi/NCR53c406a.cif( len > reqlen ) 
len388drivers/scsi/NCR53c406a.clen = reqlen;
len392drivers/scsi/NCR53c406a.cif( fast_pio && len > 3 ) { 
len393drivers/scsi/NCR53c406a.cinsl(PIO_FIFO,request,len>>2); 
len394drivers/scsi/NCR53c406a.crequest += len & 0xfc; 
len395drivers/scsi/NCR53c406a.creqlen -= len & 0xfc; 
len398drivers/scsi/NCR53c406a.cwhile(len--) {
len413drivers/scsi/NCR53c406a.cint  len;  /* current scsi fifo size */
len425drivers/scsi/NCR53c406a.clen=128; break;
len427drivers/scsi/NCR53c406a.clen=84; break;
len429drivers/scsi/NCR53c406a.clen=42; break;
len431drivers/scsi/NCR53c406a.clen=1; break;
len434drivers/scsi/NCR53c406a.clen=0; break;
len437drivers/scsi/NCR53c406a.cif (len) {
len438drivers/scsi/NCR53c406a.cif( len > reqlen ) 
len439drivers/scsi/NCR53c406a.clen = reqlen;
len443drivers/scsi/NCR53c406a.cif( fast_pio && len > 3 ) { 
len444drivers/scsi/NCR53c406a.coutsl(PIO_FIFO,request,len>>2); 
len445drivers/scsi/NCR53c406a.crequest += len & 0xfc; 
len446drivers/scsi/NCR53c406a.creqlen -= len & 0xfc; 
len449drivers/scsi/NCR53c406a.cwhile(len--) {
len2254drivers/scsi/advansys.c#define  ASC_DBG_PRT_CDB(lvl, cdb, len)
len2255drivers/scsi/advansys.c#define  ASC_DBG_PRT_SENSE(lvl, sense, len)
len2256drivers/scsi/advansys.c#define ASC_DBG_PRT_INQUIRY(lvl, inq, len)
len2345drivers/scsi/advansys.c#define  ASC_DBG_PRT_CDB(lvl, cdb, len) \
len2346drivers/scsi/advansys.cASC_DBG_PRT_HEX((lvl), "CDB", (uchar *) (cdb), (len));
len2348drivers/scsi/advansys.c#define  ASC_DBG_PRT_SENSE(lvl, sense, len) \
len2349drivers/scsi/advansys.cASC_DBG_PRT_HEX((lvl), "SENSE", (uchar *) (sense), (len));
len2351drivers/scsi/advansys.c#define ASC_DBG_PRT_INQUIRY(lvl, inq, len) \
len2352drivers/scsi/advansys.cASC_DBG_PRT_HEX((lvl), "INQUIRY", (uchar *) (inq), (len));
len4630drivers/scsi/advansys.ctotlen += len; \
len4631drivers/scsi/advansys.cleftlen -= len; \
len4635drivers/scsi/advansys.ccp += len; \
len4653drivers/scsi/advansys.cint          len;
len4657drivers/scsi/advansys.ctotlen = len = 0;
len4659drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len4663drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len4668drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len4673drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len4679drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len4686drivers/scsi/advansys.clen = asc_prt_stats_line(cp, leftlen,
len159drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
len164drivers/scsi/aha1542.cif(len == 1) {
len175drivers/scsi/aha1542.cwhile (len--)
len185drivers/scsi/aha1542.cprintk("aha1542_out failed(%d): ", len+1); aha1542_stat();
len191drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
len197drivers/scsi/aha1542.cwhile (len--)
len206drivers/scsi/aha1542.cprintk("aha1542_in failed(%d): ", len+1); aha1542_stat();
len213drivers/scsi/aha1542.cstatic int aha1542_in1(unsigned int base, unchar *cmdp, int len)
len219drivers/scsi/aha1542.cwhile (len--)
len293drivers/scsi/aha1542.cint len;
len326drivers/scsi/aha1542.clen = 4;
len329drivers/scsi/aha1542.cwhile (len--)
len991drivers/scsi/aic7xxx.cregister int len = ep - bp;
len993drivers/scsi/aic7xxx.cstrncpy(buf, bp, len);
len994drivers/scsi/aic7xxx.cbuf[len] = '\0';
len2656drivers/scsi/aic7xxx.cunsigned char len;
len2686drivers/scsi/aic7xxx.cfor (i = 0; i < seeprom_read.len; i++)
len2830drivers/scsi/aic7xxx.cunsigned char len;
len2878drivers/scsi/aic7xxx.cfor (i = 0; i < seeprom_read.len; i++)
len30drivers/scsi/aic7xxx_proc.c#define BLS buffer + len + size
len82drivers/scsi/aic7xxx_proc.cint   len = 0;
len113drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
len133drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
len160drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
len189drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
len237drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
len242drivers/scsi/aic7xxx_proc.cproc_debug("2pos: %ld offset: %ld len: %d\n", pos, offset, len);
len244drivers/scsi/aic7xxx_proc.clen -= (offset - begin);      /* Start slop */
len245drivers/scsi/aic7xxx_proc.cif (len > length)
len247drivers/scsi/aic7xxx_proc.clen = length;               /* Ending slop */
len249drivers/scsi/aic7xxx_proc.cproc_debug("3pos: %ld offset: %ld len: %d\n", pos, offset, len);
len251drivers/scsi/aic7xxx_proc.creturn (len);     
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;
len245drivers/scsi/eata.cushort len;          /* Number of bytes following this field */
len469drivers/scsi/eata.cconfig.len = (ushort) htons((ushort)510);
len484drivers/scsi/eata_dma.ccp->sg_list[i].len = htonl((u32) sl->length);
len831drivers/scsi/eata_dma.c(u32) ntohl(gc->len), gc->version,
len865drivers/scsi/eata_dma.cif(gc->HAA_valid == FALSE || ntohl(gc->len) < 0x22) 
len989drivers/scsi/eata_dma.cswitch (ntohl(gc->len)) {
len1005drivers/scsi/eata_dma.cif(ntohl(gc->len) >= 0x22) {
len1022drivers/scsi/eata_dma.cif(ntohl(gc->len) >= 0x22) {
len90drivers/scsi/eata_dma_proc.cint    size, len = 0;
len120drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) driver version: "
len122drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
len123drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
len125drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
len127drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
len129drivers/scsi/eata_dma_proc.clen += size; 
len130drivers/scsi/eata_dma_proc.cpos = begin + len;
len131drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
len133drivers/scsi/eata_dma_proc.clen += size;
len134drivers/scsi/eata_dma_proc.cpos = begin + len;
len135drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Hardware Configuration:\n");
len136drivers/scsi/eata_dma_proc.clen += size; 
len137drivers/scsi/eata_dma_proc.cpos = begin + len;
len141drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
len143drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
len144drivers/scsi/eata_dma_proc.clen += size; 
len145drivers/scsi/eata_dma_proc.cpos = begin + len;
len147drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len148drivers/scsi/eata_dma_proc.clen += size; 
len149drivers/scsi/eata_dma_proc.cpos = begin + len;
len151drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: EISA\n"); 
len152drivers/scsi/eata_dma_proc.clen += size; 
len153drivers/scsi/eata_dma_proc.cpos = begin + len;
len196drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "IRQ: %2d, %s triggered\n", cc->interrupt,
len198drivers/scsi/eata_dma_proc.clen += size; 
len199drivers/scsi/eata_dma_proc.cpos = begin + len;
len201drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
len203drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
len204drivers/scsi/eata_dma_proc.clen += size; 
len205drivers/scsi/eata_dma_proc.cpos = begin + len;
len206drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "CPU: MC680%02d %dMHz\n", bt->cpu_type,
len208drivers/scsi/eata_dma_proc.clen += size; 
len209drivers/scsi/eata_dma_proc.cpos = begin + len;
len210drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len211drivers/scsi/eata_dma_proc.clen += size; 
len212drivers/scsi/eata_dma_proc.cpos = begin + len;
len213drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
len217drivers/scsi/eata_dma_proc.clen += size; 
len218drivers/scsi/eata_dma_proc.cpos = begin + len;
len219drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI Bus:%s%s Speed: %sMB/sec. %s\n",
len224drivers/scsi/eata_dma_proc.clen += size; 
len225drivers/scsi/eata_dma_proc.cpos = begin + len;
len226drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI channel expansion Module: %s present\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, "SmartRAID hardware: %spresent.\n",
len233drivers/scsi/eata_dma_proc.clen += size; 
len234drivers/scsi/eata_dma_proc.cpos = begin + len;
len235drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
len241drivers/scsi/eata_dma_proc.clen += size; 
len242drivers/scsi/eata_dma_proc.cpos = begin + len;
len244drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max array groups:              %d\n",
len246drivers/scsi/eata_dma_proc.clen += size; 
len247drivers/scsi/eata_dma_proc.cpos = begin + len;
len248drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 0 array:   %d\n",
len250drivers/scsi/eata_dma_proc.clen += size; 
len251drivers/scsi/eata_dma_proc.cpos = begin + len;
len252drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 3/5 array: %d\n",
len254drivers/scsi/eata_dma_proc.clen += size; 
len255drivers/scsi/eata_dma_proc.cpos = begin + len;
len256drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Cache Module: %spresent.\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, "    Type: %s\n",
len266drivers/scsi/eata_dma_proc.clen += size; 
len267drivers/scsi/eata_dma_proc.cpos = begin + len;
len269drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Bank%d: %dMB with%s ECC\n",x,
len272drivers/scsi/eata_dma_proc.clen += size; 
len273drivers/scsi/eata_dma_proc.cpos = begin + len;      
len275drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Timer Mod.: %spresent\n",
len277drivers/scsi/eata_dma_proc.clen += size; 
len278drivers/scsi/eata_dma_proc.cpos = begin + len;
len279drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "NVRAM     : %spresent\n",
len281drivers/scsi/eata_dma_proc.clen += size; 
len282drivers/scsi/eata_dma_proc.cpos = begin + len;
len283drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartROM  : %sabled\n",
len285drivers/scsi/eata_dma_proc.clen += size; 
len286drivers/scsi/eata_dma_proc.cpos = begin + len;
len287drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Alarm     : %s\n",
len289drivers/scsi/eata_dma_proc.clen += size; 
len290drivers/scsi/eata_dma_proc.cpos = begin + len;
len293drivers/scsi/eata_dma_proc.clen = 0;
len334drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host<->Disk command statistics:\n"
len336drivers/scsi/eata_dma_proc.clen += size; 
len337drivers/scsi/eata_dma_proc.cpos = begin + len;
len339drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u\n", 1 << x,
len342drivers/scsi/eata_dma_proc.clen += size; 
len343drivers/scsi/eata_dma_proc.cpos = begin + len;
len345drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u\n",
len348drivers/scsi/eata_dma_proc.clen += size; 
len349drivers/scsi/eata_dma_proc.cpos = begin + len;
len350drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Sum   :%12u %12u\n",
len353drivers/scsi/eata_dma_proc.clen += size; 
len354drivers/scsi/eata_dma_proc.cpos = begin + len;
len358drivers/scsi/eata_dma_proc.clen = 0;
len365drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Latency Command Statistics:\n"
len368drivers/scsi/eata_dma_proc.clen += size; 
len369drivers/scsi/eata_dma_proc.cpos = begin + len;
len371drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
len380drivers/scsi/eata_dma_proc.clen += size; 
len381drivers/scsi/eata_dma_proc.cpos = begin + len;
len383drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
len391drivers/scsi/eata_dma_proc.clen += size; 
len392drivers/scsi/eata_dma_proc.cpos = begin + len;
len395drivers/scsi/eata_dma_proc.clen = 0;
len401drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len,
len403drivers/scsi/eata_dma_proc.clen += size; 
len404drivers/scsi/eata_dma_proc.cpos = begin + len;
len406drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
len415drivers/scsi/eata_dma_proc.clen += size; 
len416drivers/scsi/eata_dma_proc.cpos = begin + len;
len418drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
len426drivers/scsi/eata_dma_proc.clen += size; 
len427drivers/scsi/eata_dma_proc.cpos = begin + len;
len430drivers/scsi/eata_dma_proc.clen = 0;
len440drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len441drivers/scsi/eata_dma_proc.clen += size; 
len442drivers/scsi/eata_dma_proc.cpos = begin + len;
len446drivers/scsi/eata_dma_proc.cproc_print_scsidevice(scd, buffer, &size, len);
len447drivers/scsi/eata_dma_proc.clen += size; 
len448drivers/scsi/eata_dma_proc.cpos = begin + len;
len451drivers/scsi/eata_dma_proc.clen = 0;
len462drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
len464drivers/scsi/eata_dma_proc.clen-=(offset-begin);      /* Start slop */
len465drivers/scsi/eata_dma_proc.cif(len>length)
len466drivers/scsi/eata_dma_proc.clen = length;        /* Ending slop */
len467drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
len469drivers/scsi/eata_dma_proc.creturn (len);     
len215drivers/scsi/eata_generic.h__u32  len;          /* Should return 0x22, 0x24, etc    */
len266drivers/scsi/eata_generic.h__u32 len;
len638drivers/scsi/eata_pio.c(uint) ntohl(gc->len), gc->version,
len748drivers/scsi/eata_pio.cswitch (ntohl(gc->len)) {
len764drivers/scsi/eata_pio.cif(ntohl(gc->len) >= 0x22) {
len48drivers/scsi/eata_pio_proc.cint   size, len = 0;
len65drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) PIO driver version: "
len67drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
len68drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
len70drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
len72drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\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, "Firmware revision: v%s\n", 
len78drivers/scsi/eata_pio_proc.clen += size;
len79drivers/scsi/eata_pio_proc.cpos = begin + len;
len80drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "IO: PIO\n");
len81drivers/scsi/eata_pio_proc.clen += size; 
len82drivers/scsi/eata_pio_proc.cpos = begin + len;
len83drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
len84drivers/scsi/eata_pio_proc.clen += size; 
len85drivers/scsi/eata_pio_proc.cpos = begin + len;
len86drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
len90drivers/scsi/eata_pio_proc.clen += size; 
len91drivers/scsi/eata_pio_proc.cpos = begin + len;
len94drivers/scsi/eata_pio_proc.clen = 0;
len102drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len103drivers/scsi/eata_pio_proc.clen += size; 
len104drivers/scsi/eata_pio_proc.cpos = begin + len;
len108drivers/scsi/eata_pio_proc.cproc_print_scsidevice(scd, buffer, &size, len);
len109drivers/scsi/eata_pio_proc.clen += size; 
len110drivers/scsi/eata_pio_proc.cpos = begin + len;
len113drivers/scsi/eata_pio_proc.clen = 0;
len123drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
len125drivers/scsi/eata_pio_proc.clen-=(offset-begin);            /* Start slop */
len126drivers/scsi/eata_pio_proc.cif(len>length)
len127drivers/scsi/eata_pio_proc.clen = length;               /* Ending slop */
len128drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
len130drivers/scsi/eata_pio_proc.creturn (len);     
len1098drivers/scsi/fdomain.cint        len;
len1108drivers/scsi/fdomain.cpos = len = strlen( buffer );
len1111drivers/scsi/fdomain.clen = 0;
len1116drivers/scsi/fdomain.clen -= (offset - begin);
len1117drivers/scsi/fdomain.cif(len > length) len = length;
len1119drivers/scsi/fdomain.creturn(len);
len290drivers/scsi/g_NCR5380.cint len = 0;
len297drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "SCSI host number %d : %s\n", scsi_ptr->host_no,  scsi_ptr->hostt->name);
len298drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "Generic NCR5380 driver version %d\n", GENERIC_NCR5380_PUBLIC_RELEASE);
len299drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "NCR5380 driver core version %d\n", NCR5380_PUBLIC_RELEASE);
len301drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "NCR53C400 driver extension version %d\n", NCR53C400_PUBLIC_RELEASE);
len302drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "NCR53C400 card%s detected\n",  (((struct NCR5380_hostdata *)scsi_ptr->hostdata)->flags & FLAG_NCR53C400)?"":" not");
len304drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "NCR53C400 pseudo DMA being used\n");
len307drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "NO NCR53C400 driver extensions\n");
len309drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "Using %s mapping at %s 0x%x, ", STRVAL(NCR5380_map_config), STRVAL(NCR5380_map_name), scsi_ptr->NCR5380_instance_name);
len311drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "interrupts disabled\n");
len313drivers/scsi/g_NCR5380.clen += sprintf(buffer+len, "on interrupt %d\n", scsi_ptr->irq);
len316drivers/scsi/g_NCR5380.clen -= offset;
len317drivers/scsi/g_NCR5380.cif (len > length)
len318drivers/scsi/g_NCR5380.clen = length;
len319drivers/scsi/g_NCR5380.creturn len;
len323drivers/scsi/g_NCR5380.cstatic inline int NCR5380_pread (struct Scsi_Host *instance, unsigned char *dst,    int len)
len325drivers/scsi/g_NCR5380.cint blocks = len / 128;
len334drivers/scsi/g_NCR5380.cprintk("53C400r: About to read %d blocks for %d bytes\n", blocks, len);
len431drivers/scsi/g_NCR5380.cstatic inline int NCR5380_pwrite (struct Scsi_Host *instance, unsigned char *src,    int len)
len433drivers/scsi/g_NCR5380.cint blocks = len / 128;
len442drivers/scsi/g_NCR5380.cprintk("53C400w: About to write %d blocks for %d bytes\n", blocks, len);
len490drivers/scsi/pas16.cint len) {
len494drivers/scsi/pas16.cregister i = len;
len523drivers/scsi/pas16.cint len) {
len526drivers/scsi/pas16.cregister i = len;
len2172drivers/scsi/scsi.cvoid *scsi_malloc(unsigned int len)
len2177drivers/scsi/scsi.cif(len % SECTOR_SIZE != 0 || len > PAGE_SIZE)
len2182drivers/scsi/scsi.cnbits = len >> 9;
len2192drivers/scsi/scsi.cprintk("SMalloc: %d %p\n",len, dma_malloc_pages[i] + (j << 9));
len2201drivers/scsi/scsi.cint scsi_free(void *obj, unsigned int len)
len2207drivers/scsi/scsi.cprintk("scsi_free %p %d\n",obj, len);
len2217drivers/scsi/scsi.cnbits = len >> 9;
len2442drivers/scsi/scsi.cint    i,size, len = 0;
len2450drivers/scsi/scsi.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
len2451drivers/scsi/scsi.clen += size; 
len2452drivers/scsi/scsi.cpos = begin + len;
len2455drivers/scsi/scsi.csize += sprintf(buffer+len,"scsi%2d: %s\n", (int) HBA_ptr->host_no, 
len2457drivers/scsi/scsi.clen += size; 
len2458drivers/scsi/scsi.cpos = begin + len;
len2463drivers/scsi/scsi.cproc_print_scsidevice(scd, buffer, &size, len);
len2464drivers/scsi/scsi.clen += size; 
len2465drivers/scsi/scsi.cpos = begin + len;
len2468drivers/scsi/scsi.clen = 0;
len2481drivers/scsi/scsi.clen-=(offset-begin);          /* Start slop */
len2482drivers/scsi/scsi.cif(len>length)
len2483drivers/scsi/scsi.clen = length;    /* Ending slop */
len2484drivers/scsi/scsi.creturn (len);     
len633drivers/scsi/scsi_debug.cint len, pos, begin;
len668drivers/scsi/scsi_debug.cpos = len = sprintf(buffer, 
len674drivers/scsi/scsi_debug.clen = 0;
len679drivers/scsi/scsi_debug.clen -= (offset - begin);
len680drivers/scsi/scsi_debug.cif(len > length)
len681drivers/scsi/scsi_debug.clen = length;
len683drivers/scsi/scsi_debug.creturn(len);
len40drivers/scsi/scsi_ioctl.cunsigned int len,slen;
len47drivers/scsi/scsi_ioctl.clen = get_user ((unsigned int *) buffer);
len54drivers/scsi/scsi_ioctl.cif (len > slen)
len55drivers/scsi/scsi_ioctl.clen = slen + 1;
len56drivers/scsi/scsi_ioctl.cresult = verify_area(VERIFY_WRITE, buffer, len);
len59drivers/scsi/scsi_ioctl.cmemcpy_tofs (buffer, string, len);
len53drivers/scsi/scsi_proc.cint len, pos, begin;
len59drivers/scsi/scsi_proc.cpos = len = sprintf(buffer, 
len62drivers/scsi/scsi_proc.clen = 0;
len67drivers/scsi/scsi_proc.clen -= (offset - begin);
len68drivers/scsi/scsi_proc.cif(len > length)
len69drivers/scsi/scsi_proc.clen = length;
len71drivers/scsi/scsi_proc.creturn(len);
len257drivers/scsi/scsi_proc.cvoid proc_print_scsidevice(Scsi_Device *scd, char *buffer, int *size, int len)
len261drivers/scsi/scsi_proc.cy = sprintf(buffer + len, 
len266drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "%c", scd->vendor[x]);
len268drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y," ");
len270drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " Model: ");
len273drivers/scsi/scsi_proc.cy +=  sprintf(buffer + len + y, "%c", scd->model[x]);
len275drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " ");
len277drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " Rev: ");
len280drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "%c", scd->rev[x]);
len282drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " ");
len284drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "\n");
len286drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "  Type:   %s ",
len289drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "               ANSI"
len292drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, " CCS\n");
len294drivers/scsi/scsi_proc.cy += sprintf(buffer + len + y, "\n");
len413drivers/scsi/seagate.cint len;
len423drivers/scsi/seagate.cpos = len = strlen(buffer);
len426drivers/scsi/seagate.clen = 0;
len431drivers/scsi/seagate.clen -= (offset - begin);
len432drivers/scsi/seagate.cif ( len > length ) len = length;
len433drivers/scsi/seagate.creturn(len);
len621drivers/scsi/seagate.cint len = 0;
len750drivers/scsi/seagate.clen=current_bufflen;    /* WDE add */
len948drivers/scsi/seagate.clen = buffer->length;
len955drivers/scsi/seagate.clen = SCint->request_bufflen;
len960drivers/scsi/seagate.cprintk("scsi%d : len = %d\n", hostno, len);
len1073drivers/scsi/seagate.cif (!len) {
len1083drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1091drivers/scsi/seagate.cSCint->transfersize, len, data);
len1113drivers/scsi/seagate.clen -= transfersize;
len1118drivers/scsi/seagate.chostno, len, data);
len1174drivers/scsi/seagate.c"=S" (data), "=c" (len) :
len1176drivers/scsi/seagate.c"0" (data), "1" (len) :
len1181drivers/scsi/seagate.cif (!len && nobuffs) {
len1184drivers/scsi/seagate.clen = buffer->length;
len1188drivers/scsi/seagate.chostno, len, data);
len1197drivers/scsi/seagate.ctransfered += len;
len1199drivers/scsi/seagate.cfor (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN |
len1200drivers/scsi/seagate.cSTAT_REQ); --len) {
len1205drivers/scsi/seagate.ctransfered -= len;
len1210drivers/scsi/seagate.cif (fast && transfersize && !(len % transfersize) && (len >= transfersize)
len1218drivers/scsi/seagate.cSCint->transfersize, len, data);
len1240drivers/scsi/seagate.clen -= transfersize;
len1250drivers/scsi/seagate.chostno, len, data);
len1258drivers/scsi/seagate.cprintk("scsi%d: transfered += %d\n", hostno, len);
len1259drivers/scsi/seagate.ctransfered += len;  /* Assume we'll transfer it all, then
len1314drivers/scsi/seagate.c"=D" (data), "=c" (len) :
len1316drivers/scsi/seagate.c"0" (data), "1" (len) :
len1321drivers/scsi/seagate.cprintk("scsi%d: transfered -= %d\n", hostno, len);
len1322drivers/scsi/seagate.ctransfered -= len;    /* Since we assumed all of Len got 
len1327drivers/scsi/seagate.cif (!len && nobuffs) {
len1330drivers/scsi/seagate.clen = buffer->length;
len1334drivers/scsi/seagate.chostno, len, data);
len1401drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1433drivers/scsi/seagate.ccurrent_bufflen = len;  /* WDE add */
len1444drivers/scsi/seagate.clen=current_bufflen;
len167drivers/scsi/sr_ioctl.csr_cmd[7] = blk.len >> 8;
len168drivers/scsi/sr_ioctl.csr_cmd[8] = blk.len;
len323drivers/scsi/t128.cint len) {
len326drivers/scsi/t128.cregister i = len;
len367drivers/scsi/t128.cint len) {
len370drivers/scsi/t128.cregister i = len;
len216drivers/scsi/wd7000.cunsigned    len;           /* length of string */
len332drivers/scsi/wd7000.cunchar len[3];
len388drivers/scsi/wd7000.cunchar len[3];                /* command buffer length */
len430drivers/scsi/wd7000.cunchar len[3];                /* buffer length */
len446drivers/scsi/wd7000.cunchar len[3];                /* parms buffer length */
len578drivers/scsi/wd7000.cstatic inline int command_out(Adapter *host, unchar *cmd, int len)
len581drivers/scsi/wd7000.cwhile (len--)  {
len591drivers/scsi/wd7000.cprintk("wd7000 command_out: WAIT failed(%d)\n", len+1);
len938drivers/scsi/wd7000.cany2scsi(sgb[i].len, sg[i].length);
len968drivers/scsi/wd7000.cany2scsi(icb.len, sizeof(buf));
len1123drivers/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);
len247drivers/sound/configure.cint             len;
len249drivers/sound/configure.cif ((len = read (0, answ, sizeof (answ))) < 1)
len258drivers/sound/configure.cif (len < 2)      /*
len263drivers/sound/configure.cansw[len - 1] = 0;
len275drivers/sound/configure.cint             len, num;
len279drivers/sound/configure.cif ((len = read (0, answ, sizeof (answ))) < 1)
len288drivers/sound/configure.cif (len < 2)      /*
len293drivers/sound/configure.cansw[len - 1] = 0;
len166drivers/sound/dev_table.hconst char *userbuf, int useroffs, int len);
len209drivers/sound/dev_table.hint (*send_sysex)(int dev, unsigned char *bytes, int len);
len505drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
len581drivers/sound/dmabuf.c*len = dmap->fragment_size - dmap->counts[dmap->qhead];
len959drivers/sound/dmabuf.cint             len, max, tmp;
len971drivers/sound/dmabuf.clen = dmap->qlen;
len976drivers/sound/dmabuf.cif (tmp && len)
len980drivers/sound/dmabuf.clen += tmp;
len983drivers/sound/dmabuf.cif (len >= max)
len1648drivers/sound/dmabuf.cDMAbuf_getrdbuffer (int dev, char **buf, int *len, int dontblock)
len486drivers/sound/gus_wave.cif (position < samples[sample_no].len)
len1313drivers/sound/gus_wave.c((sample_ptrs[sample] + samples[sample].len) >> 18))
len1344drivers/sound/gus_wave.cgus_write_addr (0x0a, sample_ptrs[sample] + samples[sample].len -
len1377drivers/sound/gus_wave.cgus_write_addr (0x04, sample_ptrs[sample] + samples[sample].len - 1,
len1556drivers/sound/gus_wave.cif (count < patch.len)
len1559drivers/sound/gus_wave.ccount, (int) patch.len);
len1560drivers/sound/gus_wave.cpatch.len = count;
len1563drivers/sound/gus_wave.cif (patch.len <= 0 || patch.len > gus_mem_size)
len1565drivers/sound/gus_wave.cprintk ("GUS: Invalid sample length %d\n", (int) patch.len);
len1571drivers/sound/gus_wave.cif (patch.loop_start < 0 || patch.loop_start >= patch.len)
len1577drivers/sound/gus_wave.cif (patch.loop_end < patch.loop_start || patch.loop_end > patch.len)
len1593drivers/sound/gus_wave.cif (patch.len >= GUS_BANK_SIZE)
len1595drivers/sound/gus_wave.cprintk ("GUS: Sample (16 bit) too long %d\n", (int) patch.len);
len1600drivers/sound/gus_wave.c((free_mem_ptr + patch.len) / GUS_BANK_SIZE))
len1605drivers/sound/gus_wave.cif ((tmp_mem + patch.len) > gus_mem_size)
len1612drivers/sound/gus_wave.cif ((free_mem_ptr + patch.len) > gus_mem_size)
len1637drivers/sound/gus_wave.cleft = patch.len;
len1767drivers/sound/gus_wave.cfree_mem_ptr += patch.len;
len2431drivers/sound/gus_wave.cconst char *userbuf, int useroffs, int len)
len2435drivers/sound/gus_wave.cmemcpy_fromfs (&localbuf[localoffs], &((userbuf)[useroffs]), len);
len2444drivers/sound/gus_wave.clen /= 2;
len2449drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2464drivers/sound/gus_wave.clen /= 4;
len2470drivers/sound/gus_wave.cfor (i = 0; i < len; i++)
len2615drivers/sound/gus_wave.cif (pat->len > samples[ptr].len)  /* Cannot expand sample */
len2638drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2641drivers/sound/gus_wave.cn = samples[sample].len - offs;    /* Num of bytes left */
len2679drivers/sound/gus_wave.cif (offs < 0 || offs >= samples[sample].len)
len2684drivers/sound/gus_wave.cn = samples[sample].len - offs;    /*
len135drivers/sound/maui.cif (count < header.len)
len138drivers/sound/maui.ccount, (int) header.len);
len139drivers/sound/maui.cheader.len = count;
len142drivers/sound/maui.cleft = header.len;
len57drivers/sound/midi_synth.cint len; \
len60drivers/sound/midi_synth.cseq_input_event(obuf, len); \
len66drivers/sound/midi_synth.c#define _SEQ_ADVBUF(x) len=x
len540drivers/sound/midi_synth.cif (count < sysex.len)
len543drivers/sound/midi_synth.ccount, (int) sysex.len);
len544drivers/sound/midi_synth.csysex.len = count;
len547drivers/sound/midi_synth.cleft = sysex.len;
len712drivers/sound/midi_synth.cmidi_synth_send_sysex (int dev, unsigned char *bytes, int len)
len717drivers/sound/midi_synth.cfor (i = 0; i < len; i++)
len18drivers/sound/midi_synth.hint midi_synth_send_sysex(int dev, unsigned char *bytes,int len);
len55drivers/sound/midibuf.cint             len, head, tail;
len79drivers/sound/midibuf.c#define DATA_AVAIL(q) (q->len)
len80drivers/sound/midibuf.c#define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)
len88drivers/sound/midibuf.cq->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
len98drivers/sound/midibuf.cq->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
len183drivers/sound/midibuf.cmidi_out_buf[dev]->len--;
len244drivers/sound/midibuf.cmidi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;
len256drivers/sound/midibuf.cmidi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
len174drivers/sound/mpu401.cint len; \
len177drivers/sound/mpu401.cseq_input_event(obuf, len); \
len183drivers/sound/mpu401.c#define _SEQ_ADVBUF(x) len=x
len480drivers/sound/pss.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
len483drivers/sound/pss.cif (!pss_download_boot (devc, buf->data, buf->len, buf->flags))
len179drivers/sound/sequencer.cseq_copy_to_input (unsigned char *event_rec, int len)
len187drivers/sound/sequencer.cif (len != 4 && len != 8)
len189drivers/sound/sequencer.cif ((seq_mode == SEQ_1) != (len == 4))
len197drivers/sound/sequencer.cmemcpy (&iqueue[iqtail * IEV_SZ], event_rec, len);
len238drivers/sound/sequencer.cseq_input_event (unsigned char *event_rec, int len)
len261drivers/sound/sequencer.cseq_copy_to_input (event_rec, len);
len9drivers/sound/sound_calls.hint DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock);
len54drivers/sound/sound_calls.hvoid seq_input_event(unsigned char *event, int len);
len55drivers/sound/sound_calls.hvoid seq_copy_to_input (unsigned char *event, int len);
len169drivers/sound/soundcard.cint             len;
len171drivers/sound/soundcard.clen = _IOC_SIZE (cmd);
len175drivers/sound/soundcard.cif ((err = verify_area (VERIFY_READ, (void *) arg, len)) < 0)
len181drivers/sound/soundcard.cif ((err = verify_area (VERIFY_WRITE, (void *) arg, len)) < 0)
len638drivers/sound/sscape.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
len641drivers/sound/sscape.cif (!sscape_download_boot (devc, buf->data, buf->len, buf->flags))
len366fs/binfmt_aout.cunsigned int len;
len416fs/binfmt_aout.clen = PAGE_ALIGN(ex.a_text + ex.a_data);
len418fs/binfmt_aout.cif (bss > len)
len419fs/binfmt_aout.cdo_mmap(NULL, start_addr + len, bss-len,
len176fs/binfmt_elf.cunsigned int len;
len285fs/binfmt_elf.clen = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
len288fs/binfmt_elf.cif (last_bss > len)
len289fs/binfmt_elf.cdo_mmap(NULL, len, last_bss-len,
len719fs/binfmt_elf.cunsigned int len;
len726fs/binfmt_elf.clen = 0;
len799fs/binfmt_elf.clen = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
len801fs/binfmt_elf.cif (bss > len)
len802fs/binfmt_elf.cdo_mmap(NULL, len, bss-len,
len1095fs/binfmt_elf.cint i, len;
len1099fs/binfmt_elf.clen = current->mm->arg_end - current->mm->arg_start;
len1100fs/binfmt_elf.clen = len >= ELF_PRARGSZ ? ELF_PRARGSZ : len;
len1102fs/binfmt_elf.c(const char *)current->mm->arg_start, len);
len1103fs/binfmt_elf.cfor(i = 0; i < len; i++)
len1106fs/binfmt_elf.cpsinfo.pr_psargs[len] = 0;
len1194fs/binfmt_elf.cunsigned long len = vma->vm_end - vma->vm_start;
len1200fs/binfmt_elf.cprintk("elf_core_dump: writing %08lx %lx\n", addr, len);
len1202fs/binfmt_elf.cDUMP_WRITE((void *)addr, len);
len105fs/dcache.cstatic inline unsigned long namehash(const char * name, int len)
len107fs/dcache.creturn len * *(const unsigned char *) name;
len133fs/dcache.cstatic inline 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);
len40fs/devices.cint len;
len42fs/devices.clen = sprintf(page, "Character devices:\n");
len45fs/devices.clen += sprintf(page+len, "%2d %s\n", i, chrdevs[i].name);
len48fs/devices.clen += sprintf(page+len, "\nBlock devices:\n");
len51fs/devices.clen += sprintf(page+len, "%2d %s\n", i, blkdevs[i].name);
len54fs/devices.creturn len;
len294fs/exec.cint len, offset = 0;
len310fs/exec.clen=0;    /* remember zero-padding */
len312fs/exec.clen++;
len314fs/exec.cif (p < len) {  /* this shouldn't happen - 128kB */
len318fs/exec.cwhile (len) {
len319fs/exec.c--p; --tmp; --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);
len151fs/ext/namei.cint ext_lookup(struct inode * dir,const char * name, int len,
len165fs/ext/namei.cif (!(bh = ext_find_entry(dir,name,len,&de,NULL,NULL))) {
len307fs/ext/namei.cint ext_create(struct inode * dir,const char * name, int len, int mode,
len325fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len341fs/ext/namei.cint ext_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len349fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len384fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len400fs/ext/namei.cint ext_mkdir(struct inode * dir, const char * name, int len, int mode)
len406fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len451fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len532fs/ext/namei.cint ext_rmdir(struct inode * dir, const char * name, int len)
len540fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len586fs/ext/namei.cint ext_unlink(struct inode * dir, const char * name, int len)
len595fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,&pde,&nde);
len630fs/ext/namei.cint ext_symlink(struct inode * dir, const char * name, int len, const char * symname)
len660fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len669fs/ext/namei.cbh = ext_add_entry(dir,name,len,&de);
len685fs/ext/namei.cint ext_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len700fs/ext/namei.cbh = ext_find_entry(dir,name,len,&de,NULL,NULL);
len707fs/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);
len690fs/ext2/namei.cint ext2_unlink (struct inode * dir, const char * name, int len)
len702fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len753fs/ext2/namei.cint ext2_symlink (struct inode * dir, const char * name, int len,
len803fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len812fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len835fs/ext2/namei.cconst char * name, int len)
len856fs/ext2/namei.cbh = ext2_find_entry (dir, name, len, &de);
len863fs/ext2/namei.cbh = ext2_add_entry (dir, name, len, &de, &err);
len293fs/fat/dir.cint len, slen;
len303fs/fat/dir.clen = name_len;
len306fs/fat/dir.clen = strlen(name);
len308fs/fat/dir.cif (len != name_len) {
len309fs/fat/dir.cmemcpy_tofs(d2->d_name, name, len);
len310fs/fat/dir.cput_user(0, d2->d_name + len);
len311fs/fat/dir.cput_user(len, &d2->d_reclen);
len314fs/fat/dir.cslen = name_len - len;
len315fs/fat/dir.cmemcpy_tofs(d1->d_name, name+len+1, slen);
len321fs/fat/dir.cmemcpy_tofs(d1->d_name, name, len);
len322fs/fat/dir.cput_user(0, d1->d_name+len);
len323fs/fat/dir.cput_user(len, &d1->d_reclen);
len326fs/fat/dir.cd1, d2, len, name_len));
len363fs/hpfs/hpfs.hunsigned char len, name[15];    /* true length, truncated name */
len242fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len);
len250fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len258fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len);
len260fs/hpfs/hpfs_fs.cunsigned len);
len542fs/hpfs/hpfs_fs.cstatic int zerop(void *addr, unsigned len)
len545fs/hpfs/hpfs_fs.creturn p[0] == 0 && memcmp(p, p + 1, len - 1) == 0;
len962fs/hpfs/hpfs_fs.cstatic unsigned choose_conv(unsigned char *p, unsigned len)
len969fs/hpfs/hpfs_fs.cwhile (len--) {
len972fs/hpfs/hpfs_fs.cif (c == '\r' && len && *p == '\n')
len994fs/hpfs/hpfs_fs.cunsigned len)
len998fs/hpfs/hpfs_fs.cwhile (len--) {
len1000fs/hpfs/hpfs_fs.cif (c == '\r' && (len == 0 || *in == '\n'));
len1119fs/hpfs/hpfs_fs.cstatic int hpfs_lookup(struct inode *dir, const char *name, int len,
len1140fs/hpfs/hpfs_fs.cif (name[0] == '.' && len == 1)
len1142fs/hpfs/hpfs_fs.celse if (name[0] == '.' && name[1] == '.' && len == 2)
len1147fs/hpfs/hpfs_fs.cde = map_dirent(dir, dir->i_hpfs_dno, name, len, &qbh);
len1242fs/hpfs/hpfs_fs.cconst unsigned char *name, unsigned len,
len1271fs/hpfs/hpfs_fs.cl = len < de->namelen ? len : de->namelen;
len1278fs/hpfs/hpfs_fs.ct = len - de->namelen;
len1295fs/hpfs/hpfs_fs.cname, len, qbh);
len1352fs/hpfs/hpfs_fs.cstatic void translate_hpfs_name(const unsigned char * from, int len, char * to, int lowercase)
len1354fs/hpfs/hpfs_fs.cwhile (len > 0) {
len1356fs/hpfs/hpfs_fs.clen--;
len77fs/isofs/dir.cstatic int isofs_name_translate(char * old, int len, char * new)
len81fs/isofs/dir.cfor (i = 0; i < len; i++) {
len89fs/isofs/dir.cif (c == '.' && i == len - 3 && old[i + 1] == ';' && old[i + 2] == '1')
len93fs/isofs/dir.cif (c == ';' && i == len - 2 && old[i + 1] == '1')
len117fs/isofs/dir.cint len, rrflag;
len224fs/isofs/dir.clen = de->name_len[0];
len226fs/isofs/dir.crrflag = get_rock_ridge_filename(de, &name, &len, inode);
len230fs/isofs/dir.crrflag = filldir(dirent, name, len, filp->f_pos, inode_number);
len231fs/isofs/dir.cdcache_add(inode, name, len, inode_number);
len241fs/isofs/dir.clen = isofs_name_translate(name, len, tmpname);
len242fs/isofs/dir.cif (filldir(dirent, tmpname, len, filp->f_pos, inode_number) < 0)
len244fs/isofs/dir.cdcache_add(inode, tmpname, len, inode_number);
len249fs/isofs/dir.cif (filldir(dirent, name, len, filp->f_pos, inode_number) < 0)
len252fs/isofs/dir.cdcache_add(inode, name, len, inode_number);
len27fs/isofs/namei.cstatic int isofs_match(int len,const char * name, const char * compare, int dlen)
len36fs/isofs/namei.cif (!len)
len45fs/isofs/namei.cif (len <= 2) printk("Match: %d %d %s %d %d \n",len,dlen,compare,de->name[0], dlen);
len48fs/isofs/namei.cif (dlen != len)
len50fs/isofs/namei.creturn !memcmp(name, compare, len);
len218fs/isofs/namei.cint isofs_lookup(struct inode * dir,const char * name, int len,
len225fs/isofs/namei.cprintk("lookup: %x %d\n",dir->i_ino, len);
len238fs/isofs/namei.cif (dcache_lookup(dir, name, len, &ino)) ino_back = dir->i_ino;
len246fs/isofs/namei.c&& (lcname = kmalloc(len, GFP_KERNEL)) != NULL) {
len250fs/isofs/namei.cfor (i=0; i<len; i++) {
len255fs/isofs/namei.cbh = isofs_find_entry(dir,lcname,len, &ino, &ino_back);
len258fs/isofs/namei.cbh = isofs_find_entry(dir,name,len, &ino, &ino_back);
len265fs/isofs/namei.cdcache_add(dir, name, len, ino);
len84fs/isofs/rock.clen = cont_size; \
len100fs/isofs/rock.cint len;
len115fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len121fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len123fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len125fs/isofs/rock.cchr += rr->len; 
len126fs/isofs/rock.clen -= rr->len;
len173fs/isofs/rock.cint len;
len181fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len187fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len189fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len191fs/isofs/rock.cchr += rr->len; 
len192fs/isofs/rock.clen -= rr->len;
len222fs/isofs/rock.cif((strlen(retname) + rr->len - 5) >= 254) {
len226fs/isofs/rock.cstrncat(retname, rr->u.NM.name, rr->len - 5);
len227fs/isofs/rock.cretnamlen += rr->len - 5;
len256fs/isofs/rock.cint len;
len262fs/isofs/rock.cSETUP_ROCK_RIDGE(de, chr, len);
len270fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len272fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len274fs/isofs/rock.cchr += rr->len; 
len275fs/isofs/rock.clen -= rr->len;
len335fs/isofs/rock.cslen = rr->len - 5;
len342fs/isofs/rock.cinode->i_size += slp->len;
len357fs/isofs/rock.cslen -= slp->len + 2;
len358fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len415fs/isofs/rock.cint len;
len457fs/isofs/rock.cSETUP_ROCK_RIDGE(raw_inode, chr, len);
len460fs/isofs/rock.cwhile (len > 1){ /* There may be one byte for padding somewhere */
len463fs/isofs/rock.cif (rr->len == 0) goto out; /* Something got screwed up here */
len465fs/isofs/rock.cchr += rr->len; 
len466fs/isofs/rock.clen -= rr->len;
len478fs/isofs/rock.cslen = rr->len - 5;
len489fs/isofs/rock.cstrncat(rpnt,slp->text, slp->len);
len504fs/isofs/rock.cslen -= slp->len + 2;
len505fs/isofs/rock.cslp = (struct SL_component *) (((char *) slp) + slp->len + 2);
len44fs/isofs/rock.hunsigned char len;
len87fs/isofs/rock.hunsigned char len;
len23fs/minix/namei.cstatic inline int namecompare(int len, int maxlen,
len26fs/minix/namei.cif (len > maxlen)
len28fs/minix/namei.cif (len < maxlen && buffer[len])
len30fs/minix/namei.creturn !memcmp(name, buffer, len);
len40fs/minix/namei.cstatic int minix_match(int len, const char * name,
len48fs/minix/namei.cif (!de->inode || len > info->s_namelen)
len51fs/minix/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len53fs/minix/namei.creturn namecompare(len,info->s_namelen,name,de->name);
len107fs/minix/namei.cint minix_lookup(struct inode * dir,const char * name, int len,
len121fs/minix/namei.cif (!(bh = minix_find_entry(dir,name,len,&de))) {
len211fs/minix/namei.cint minix_create(struct inode * dir,const char * name, int len, int mode,
len230fs/minix/namei.cerror = minix_add_entry(dir,name,len, &bh ,&de);
len246fs/minix/namei.cint minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len255fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len287fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len303fs/minix/namei.cint minix_mkdir(struct inode * dir, const char * name, int len, int mode)
len316fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len354fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len430fs/minix/namei.cint minix_rmdir(struct inode * dir, const char * name, int len)
len438fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len487fs/minix/namei.cint minix_unlink(struct inode * dir, const char * name, int len)
len497fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len542fs/minix/namei.cint minix_symlink(struct inode * dir, const char * name, int len, const char * symname)
len572fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len581fs/minix/namei.ci = minix_add_entry(dir, name, len, &bh, &de);
len597fs/minix/namei.cint minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len613fs/minix/namei.cbh = minix_find_entry(dir,name,len,&de);
len620fs/minix/namei.cerror = minix_add_entry(dir, name, len, &bh, &de);
len76fs/msdos/namei.cstatic int msdos_format_name(char conv,const char *name,int len,
len88fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len91fs/msdos/namei.cwhile (len--) *res++ = '.';
len97fs/msdos/namei.cname++; len--;
len101fs/msdos/namei.cfor (walk = res; len && walk-res < 8; walk++) {
len103fs/msdos/namei.clen--;
len118fs/msdos/namei.cif (conv == 's' && len && c != '.') {
len120fs/msdos/namei.clen--;
len123fs/msdos/namei.cwhile (c != '.' && len--) c = *name++;
len126fs/msdos/namei.cwhile (len > 0 && walk-res < MSDOS_NAME) {
len128fs/msdos/namei.clen--;
len139fs/msdos/namei.cif (conv == 's' && len) return -EINVAL;
len149fs/msdos/namei.cstatic int msdos_find(struct inode *dir,const char *name,int len,
len159fs/msdos/namei.cname,len, msdos_name,1,dotsOK);
len163fs/msdos/namei.cswitch(len){
len176fs/msdos/namei.cint msdos_lookup(struct inode *dir,const char *name,int len,
len194fs/msdos/namei.cif (len == 1 && name[0] == '.') {
len198fs/msdos/namei.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len206fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
len286fs/msdos/namei.cint msdos_create(struct inode *dir,const char *name,int len,int mode,
len296fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len372fs/msdos/namei.cint msdos_rmdir(struct inode *dir,const char *name,int len)
len383fs/msdos/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len385fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) goto rmdir_done;
len411fs/msdos/namei.cint msdos_mkdir(struct inode *dir,const char *name,int len,int mode)
len420fs/msdos/namei.cif ((res = msdos_format_name(MSDOS_SB(dir->i_sb)->name_check,name,len,
len463fs/msdos/namei.cif (msdos_rmdir(dir,name,len) < 0)
len473fs/msdos/namei.cint len,
len484fs/msdos/namei.cif ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0)
len512fs/msdos/namei.cint msdos_unlink(struct inode *dir,const char *name,int len)
len514fs/msdos/namei.creturn msdos_unlinkx (dir,name,len,1);
len518fs/msdos/namei.cint msdos_unlink_umsdos(struct inode *dir,const char *name,int len)
len520fs/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;
len48fs/ncpfs/dir.cint len, struct inode **result);
len51fs/ncpfs/dir.cncp_create(struct inode *dir, const char *name, int len, int mode, 
len55fs/ncpfs/dir.cncp_mkdir(struct inode *dir, const char *name, int len, int mode);
len58fs/ncpfs/dir.cncp_rmdir(struct inode *dir, const char *name, int len);
len61fs/ncpfs/dir.cncp_unlink(struct inode *dir, const char *name, int len);
len626fs/ncpfs/dir.cncp_lookup(struct inode *dir, const char *__name, int len,
len633fs/ncpfs/dir.cchar name[len+1];
len644fs/ncpfs/dir.cDDPRINTK("ncp_lookup: %s, len %d\n", __name, len);
len649fs/ncpfs/dir.cif (len == 0 || (len == 1 && __name[0] == '.'))
len656fs/ncpfs/dir.cif (len == 2 && __name[0] == '.' && __name[1] == '.')
len677fs/ncpfs/dir.cmemcpy(name, __name, len);
len678fs/ncpfs/dir.cname[len] = 0;
len761fs/ncpfs/dir.cncp_create(struct inode *dir, const char *name, int len, int mode,
len765fs/ncpfs/dir.c__u8 _name[len+1];
len776fs/ncpfs/dir.cstrncpy(_name, name, len);
len777fs/ncpfs/dir.c_name[len] = '\0';
len807fs/ncpfs/dir.cncp_mkdir(struct inode *dir, const char *name, int len, int mode)
len811fs/ncpfs/dir.c__u8 _name[len+1];
len814fs/ncpfs/dir.c&& (   (len == 1)
len815fs/ncpfs/dir.c|| (   (len == 2)
len821fs/ncpfs/dir.cstrncpy(_name, name, len);
len822fs/ncpfs/dir.c_name[len] = '\0';
len850fs/ncpfs/dir.cncp_rmdir(struct inode *dir, const char *name, int len)
len853fs/ncpfs/dir.c__u8 _name[len+1];
len868fs/ncpfs/dir.cstrncpy(_name, name, len);
len869fs/ncpfs/dir.c_name[len] = '\0';
len888fs/ncpfs/dir.cncp_unlink(struct inode *dir, const char *name, int len)
len891fs/ncpfs/dir.c__u8 _name[len+1];
len905fs/ncpfs/dir.cstrncpy(_name, name, len);
len906fs/ncpfs/dir.c_name[len] = '\0';
len69fs/ncpfs/ncplib_kernel.cint len = strlen(s);
len71fs/ncpfs/ncplib_kernel.cif (len > 255)
len74fs/ncpfs/ncplib_kernel.clen = 255;
len76fs/ncpfs/ncplib_kernel.cncp_add_byte(server, len);
len77fs/ncpfs/ncplib_kernel.cncp_add_mem(server, s, len);
len151fs/ncpfs/ncplib_kernel.cint len;
len172fs/ncpfs/ncplib_kernel.clen = ncp_reply_byte(server, 29);
len173fs/ncpfs/ncplib_kernel.cif (len > NCP_VOLNAME_LEN)
len175fs/ncpfs/ncplib_kernel.cDPRINTK("ncpfs: volume name too long: %d\n", len);
len180fs/ncpfs/ncplib_kernel.cmemcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
len52fs/ncpfs/sock.cint len, int nonblock, unsigned flags,
len60fs/ncpfs/sock.ciov.iov_len  = len;
len68fs/ncpfs/sock.creturn sock->ops->sendmsg(sock, &msg, len, nonblock, flags);
len73fs/ncpfs/sock.cncp_wdog_data_ready(struct sock *sk, int len)
len24fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *name, int len,
len26fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len28fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode);
len29fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len);
len30fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len);
len31fs/nfs/dir.cstatic int nfs_symlink(struct inode *inode, const char *name, int len,
len34fs/nfs/dir.cconst char *name, int len);
len35fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len, int mode,
len329fs/nfs/dir.cstatic int nfs_lookup(struct inode *dir, const char *__name, int len,
len334fs/nfs/dir.cchar name[len > NFS_MAXNAMLEN? 1 : len+1];
len343fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len347fs/nfs/dir.cmemcpy(name,__name,len);
len348fs/nfs/dir.cname[len] = '\0';
len349fs/nfs/dir.cif (len == 1 && name[0] == '.') { /* cheat for "." */
len370fs/nfs/dir.cstatic int nfs_create(struct inode *dir, const char *name, int len, int mode,
len384fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len405fs/nfs/dir.cstatic int nfs_mknod(struct inode *dir, const char *name, int len,
len418fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len437fs/nfs/dir.cstatic int nfs_mkdir(struct inode *dir, const char *name, int len, int mode)
len449fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len464fs/nfs/dir.cstatic int nfs_rmdir(struct inode *dir, const char *name, int len)
len473fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len484fs/nfs/dir.cstatic int nfs_unlink(struct inode *dir, const char *name, int len)
len493fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len504fs/nfs/dir.cstatic int nfs_symlink(struct inode *dir, const char *name, int len,
len515fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len533fs/nfs/dir.cconst char *name, int len)
len549fs/nfs/dir.cif (len > NFS_MAXNAMLEN) {
len70fs/nfs/file.cint    len;    /* size of data */
len123fs/nfs/file.c&& (cache[i].file_pos + cache[i].len >= pos + count)
len181fs/nfs/file.ccache[tail].len = result;
len914fs/nfs/nfsroot.cint len, status, *p;
len923fs/nfs/nfsroot.clen = strlen(nfs_path);
len924fs/nfs/nfsroot.c*p++ = htonl(len);
len925fs/nfs/nfsroot.cmemcpy(p, nfs_path, len);
len926fs/nfs/nfsroot.clen = (len + 3) >> 2;
len927fs/nfs/nfsroot.cp[len] = 0;
len928fs/nfs/nfsroot.cp += len;
len97fs/nfs/proc.c#define QUADLEN(len) (((len) + 3) >> 2)
len113fs/nfs/proc.cint len = strlen(string);
len114fs/nfs/proc.cint quadlen = QUADLEN(len);
len117fs/nfs/proc.c*p++ = htonl(len);
len118fs/nfs/proc.cmemcpy(p, string, len);
len124fs/nfs/proc.cunsigned int len = ntohl(*p++);
len125fs/nfs/proc.cif (len > maxlen)
len127fs/nfs/proc.cmemcpy(string, p, len);
len128fs/nfs/proc.cstring[len] = '\0';
len129fs/nfs/proc.creturn p + QUADLEN(len);
len132fs/nfs/proc.cstatic inline int *xdr_decode_string2(int *p, char **string, unsigned int *len,
len135fs/nfs/proc.c*len = ntohl(*p++);
len136fs/nfs/proc.cif (*len > maxlen)
len139fs/nfs/proc.creturn p + QUADLEN(*len);
len143fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, const char *data, int len)
len145fs/nfs/proc.cint quadlen = QUADLEN(len);
len148fs/nfs/proc.c*p++ = htonl(len);
len149fs/nfs/proc.cmemcpy_fromfs(p, data, len);
len156fs/nfs/proc.cunsigned len = *lenp = ntohl(*p++);
len157fs/nfs/proc.cif (len > maxlen)
len160fs/nfs/proc.cmemcpy_tofs(data, p, len);
len162fs/nfs/proc.cmemcpy(data, p, len);
len163fs/nfs/proc.creturn p + QUADLEN(len);
len341fs/nfs/proc.cint **p0, char **string, unsigned int *len, unsigned int maxlen)
len357fs/nfs/proc.cif (!(p = xdr_decode_string2(p, string, len, maxlen))) {
len381fs/nfs/proc.cint len;
len400fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
len405fs/nfs/proc.cstatus = len;
len406fs/nfs/proc.cPRINTK("NFS reply read %d\n", len);
len85fs/nfs/rpcsock.crpc_sendmsg(struct rpc_sock *rsock, struct msghdr *msg, int len)
len91fs/nfs/rpcsock.cdprintk(("RPC: sending %d bytes (buf %p)\n", len, msg->msg_iov[0].iov_base));
len94fs/nfs/rpcsock.cresult = sock->ops->sendmsg(sock, msg, len, 0, 0);
len133fs/nfs/rpcsock.crpc_recvmsg(struct rpc_sock *rsock, struct msghdr *msg, int len,int flags)
len141fs/nfs/rpcsock.cdprintk(("RPC: receiving %d bytes max (buf %p)\n", len, msg->msg_iov[0].iov_base));
len144fs/nfs/rpcsock.cresult = sock->ops->recvmsg(sock, msg, len, 1, flags, &alen);
len253fs/nfs/rpcsock.ciov.iov_len=rovr->len;
len255fs/nfs/rpcsock.cresult = rpc_recvmsg(rsock, &msg, rovr->len, 0);
len313fs/nfs/rpcsock.cslot->len = rlen;
len52fs/nfs/symlink.cunsigned int len;
len75fs/nfs/symlink.c&res, &len, NFS_MAXPATHLEN);
len85fs/nfs/symlink.cmemcpy(res2, res, len);
len86fs/nfs/symlink.cres2[len] = '\0';
len99fs/nfs/symlink.cunsigned int len;
len109fs/nfs/symlink.c&res, &len, buflen);
len112fs/nfs/symlink.cmemcpy_tofs(buffer, res, len);
len113fs/nfs/symlink.cput_user('\0', buffer + len);
len114fs/nfs/symlink.cerror = len;
len195fs/proc/array.cint i, len;
len200fs/proc/array.clen = sprintf(buffer,
len230fs/proc/array.clen += sprintf(buffer + len, " %u", kstat.interrupts[i]);
len231fs/proc/array.clen += sprintf(buffer + len,
len236fs/proc/array.creturn len;
len714fs/proc/array.cint len;
len732fs/proc/array.clen = sprintf(line, MAPS_LINE_FORMAT,
len736fs/proc/array.cif (column >= len) {
len743fs/proc/array.ci = len-column;
len749fs/proc/array.cif (column >= len) {
len55fs/proc/fd.cstatic int proc_lookupfd(struct inode * dir, const char * name, int len,
len74fs/proc/fd.cif (!len || (name[0] == '.' && (len == 1 ||
len75fs/proc/fd.c(name[1] == '.' && len == 2)))) {
len76fs/proc/fd.cif (len < 2) {
len89fs/proc/fd.cwhile (len-- > 0) {
len225fs/proc/root.cint len;
len229fs/proc/root.clen = 1 + sprintf(tmp, "%d", current->pid);
len230fs/proc/root.cif (buflen < len)
len231fs/proc/root.clen = buflen;
len232fs/proc/root.cmemcpy_tofs(buffer, tmp, len);
len233fs/proc/root.creturn len;
len377fs/proc/root.cint proc_match(int len,const char * name,struct proc_dir_entry * de)
len382fs/proc/root.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len384fs/proc/root.cif (de->namelen != len)
len386fs/proc/root.creturn !memcmp(name, de->name, len);
len389fs/proc/root.cint proc_lookup(struct inode * dir,const char * name, int len,
len409fs/proc/root.cif (!len)
len412fs/proc/root.cif (len == 1)
len414fs/proc/root.cif (name[1] == '.' && len == 2) {
len427fs/proc/root.cif (proc_match(len, name, de))
len445fs/proc/root.cstatic int proc_root_lookup(struct inode * dir,const char * name, int len,
len452fs/proc/root.cretval = proc_lookup(dir, name, len, result);
len459fs/proc/root.cwhile (len-- > 0) {
len82fs/proc/scsi.cint len, pos, begin;
len85fs/proc/scsi.cpos = len = sprintf(buffer, 
len88fs/proc/scsi.clen = 0;
len93fs/proc/scsi.clen -= (offset - begin);
len94fs/proc/scsi.cif(len > length)
len95fs/proc/scsi.clen = length;
len97fs/proc/scsi.creturn(len);
len236fs/read_write.cint len, nr;
len239fs/read_write.clen = vector->iov_len;
len242fs/read_write.cnr = fn(inode, file, base, len);
len250fs/read_write.cif (nr != len)
len29fs/smbfs/dir.cget_pname(struct inode *dir, const char *name, int len,
len33fs/smbfs/dir.cget_pname_static(struct inode *dir, const char *name, int len,
len47fs/smbfs/dir.cint len, struct inode **result);
len50fs/smbfs/dir.csmb_create(struct inode *dir, const char *name, int len, int mode, 
len54fs/smbfs/dir.csmb_mkdir(struct inode *dir, const char *name, int len, int mode);
len57fs/smbfs/dir.csmb_rmdir(struct inode *dir, const char *name, int len);
len60fs/smbfs/dir.csmb_unlink(struct inode *dir, const char *name, int len);
len261fs/smbfs/dir.cint len;
len265fs/smbfs/dir.clen = strlen(entry->path);
len266fs/smbfs/dir.cif ((result = get_pname_static(inode, entry->path, len,
len283fs/smbfs/dir.cif (filldir(dirent, entry->path, len,
len343fs/smbfs/dir.cget_pname_static(struct inode *dir, const char *name, int len,
len347fs/smbfs/dir.cint   parentlen  = SMB_INOP(dir)->finfo.len;
len360fs/smbfs/dir.cif (len > SMB_MAXNAMELEN) {
len365fs/smbfs/dir.cif (len == 0 || (len == 1 && name[0] == '.')) {
len373fs/smbfs/dir.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len395fs/smbfs/dir.clen = pos - parentname;
len397fs/smbfs/dir.cmemcpy(path, parentname, len);
len398fs/smbfs/dir.cpath[len] = '\0';
len402fs/smbfs/dir.cif (len + parentlen + 2 > SMB_MAXPATHLEN) 
len407fs/smbfs/dir.cmemcpy(path + parentlen + 1, name, len);
len408fs/smbfs/dir.cpath[parentlen + 1 + len] = '\0';
len409fs/smbfs/dir.clen = parentlen + len + 1;
len424fs/smbfs/dir.c*res_len = len;
len432fs/smbfs/dir.cget_pname(struct inode *dir, const char *name, int len,
len439fs/smbfs/dir.cif ((res = get_pname_static(dir,name,len,result,&result_len) != 0)) {
len468fs/smbfs/dir.cint error, len;
len482fs/smbfs/dir.clen = strlen(path);
len486fs/smbfs/dir.cpath, len, &newent);
len511fs/smbfs/dir.cnew_inode_info->finfo.len    = len;
len549fs/smbfs/dir.csmb_kfree_s(i->finfo.path, i->finfo.len+1);
len565fs/smbfs/dir.croot->finfo.len  = strlen(root->finfo.path);
len581fs/smbfs/dir.cif (root->finfo.len == 0) {
len587fs/smbfs/dir.croot->finfo.path, root->finfo.len,
len658fs/smbfs/dir.csmb_lookup(struct inode *dir, const char *__name, int len,
len678fs/smbfs/dir.cif (len == 0 || (len == 1 && __name[0] == '.')) {
len684fs/smbfs/dir.cif ((error = get_pname(dir, __name, len, &name, &len)) < 0) {
len742fs/smbfs/dir.cerror = smb_proc_getattr(SMB_SERVER(dir), name, len, &finfo);
len762fs/smbfs/dir.csmb_create(struct inode *dir, const char *name, int len, int mode,
len778fs/smbfs/dir.cif ((error = get_pname(dir, name, len, &path, &len)) < 0) {
len789fs/smbfs/dir.cerror = smb_proc_create(SMB_SERVER(dir), path, len, &entry);
len808fs/smbfs/dir.csmb_mkdir(struct inode *dir, const char *name, int len, int mode)
len820fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len825fs/smbfs/dir.cif ((error = smb_proc_mkdir(SMB_SERVER(dir), path, len)) == 0) {
len834fs/smbfs/dir.csmb_rmdir(struct inode *dir, const char *name, int len)
len844fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len851fs/smbfs/dir.cif ((error = smb_proc_rmdir(SMB_SERVER(dir), path, len)) == 0)
len859fs/smbfs/dir.csmb_unlink(struct inode *dir, const char *name, int len)
len869fs/smbfs/dir.cif ((error = get_pname_static(dir, name, len, path, &len)) < 0) {
len876fs/smbfs/dir.cif ((error = smb_proc_unlink(SMB_SERVER(dir), path, len)) == 0)
len49fs/smbfs/file.cdirent->path, dirent->len,
len71fs/smbfs/proc.csmb_encode_smb_length(byte *p, dword len)
len74fs/smbfs/proc.cp[2] = (len & 0xFF00) >> 8;
len75fs/smbfs/proc.cp[3] = (len & 0xFF);
len76fs/smbfs/proc.cif (len > 0xFFFF)
len82fs/smbfs/proc.csmb_encode_dialect(byte *p, const byte *name, int len)
len86fs/smbfs/proc.creturn p + len + 1;
len90fs/smbfs/proc.csmb_encode_ascii(byte *p, const byte *name, int len)
len94fs/smbfs/proc.creturn p + len + 1;
len98fs/smbfs/proc.csmb_encode_vblock(byte *p, const byte *data, word len, int fs)
len101fs/smbfs/proc.cp = smb_encode_word(p, len);
len103fs/smbfs/proc.cmemcpy_fromfs(p, data, len);
len105fs/smbfs/proc.cmemcpy(p, data, len);
len106fs/smbfs/proc.creturn p + len;
len112fs/smbfs/proc.cword len;
len119fs/smbfs/proc.clen = WVAL(p, 1);
len123fs/smbfs/proc.cmemcpy_tofs(data, p, len);
len125fs/smbfs/proc.cmemcpy(data, p, len);
len127fs/smbfs/proc.c*data_len = len;
len129fs/smbfs/proc.creturn p + len;
len135fs/smbfs/proc.cint len, pad = 0;
len137fs/smbfs/proc.clen = strlen(name);
len139fs/smbfs/proc.cif (len < 16)
len140fs/smbfs/proc.cpad = 16 - len;
len142fs/smbfs/proc.c*p ++ = 2 * (len + pad);
len351fs/smbfs/proc.cint i, j, len;
len358fs/smbfs/proc.clen = smb_len(packet), smb_valid_packet(packet));
len368fs/smbfs/proc.cif (len > 100)
len369fs/smbfs/proc.clen = 100;
len371fs/smbfs/proc.cfor (i = 0; i < len; i += 10) {
len374fs/smbfs/proc.cif (j < len)
len380fs/smbfs/proc.cif (j < len)
len534fs/smbfs/proc.csmb_proc_open(struct smb_server *server, const char *pathname, int len,
len547fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
len550fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
len563fs/smbfs/proc.cp = smb_setup_header(server, SMBopen, 2, 2 + len);
len566fs/smbfs/proc.csmb_encode_ascii(p, pathname, len);
len760fs/smbfs/proc.csmb_proc_do_create(struct smb_server *server, const char *path, int len, 
len769fs/smbfs/proc.cp = smb_setup_header(server, command, 3, len + 2);
len772fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len792fs/smbfs/proc.csmb_proc_create(struct smb_server *server, const char *path, int len,
len795fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBcreate);
len799fs/smbfs/proc.csmb_proc_mknew(struct smb_server *server, const char *path, int len,
len802fs/smbfs/proc.creturn smb_proc_do_create(server, path, len, entry, SMBmknew);
len832fs/smbfs/proc.csmb_proc_mkdir(struct smb_server *server, const char *path, const int len)
len840fs/smbfs/proc.cp = smb_setup_header(server, SMBmkdir, 0, 2 + len);
len841fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len853fs/smbfs/proc.csmb_proc_rmdir(struct smb_server *server, const char *path, const int len)
len861fs/smbfs/proc.cp = smb_setup_header(server, SMBrmdir, 0, 2 + len);
len862fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len874fs/smbfs/proc.csmb_proc_unlink(struct smb_server *server, const char *path, const int len)
len883fs/smbfs/proc.cp = smb_setup_header(server, SMBunlink, 1, 2 + len);
len885fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len1081fs/smbfs/proc.cfinfo->len  = strlen(finfo->path);
len1096fs/smbfs/proc.cfinfo->len  = strlen(finfo->path);
len1132fs/smbfs/proc.cfinfo->len = namelen;
len1384fs/smbfs/proc.csmb_proc_getattr_core(struct smb_server *server, const char *path, int len, 
len1396fs/smbfs/proc.cp = smb_setup_header(server, SMBgetatr, 0, 2 + len);
len1397fs/smbfs/proc.csmb_encode_ascii(p, path, len);
len1443fs/smbfs/proc.csmb_proc_getattr(struct smb_server *server, const char *path, int len, 
len1451fs/smbfs/proc.cif ((result=smb_proc_open(server,path,len,
len1455fs/smbfs/proc.creturn smb_proc_getattr_core(server,path,len,entry);
len1470fs/smbfs/proc.creturn smb_proc_getattr_core(server, path, len, entry);
len1479fs/smbfs/proc.cconst char *path, int len,
len1489fs/smbfs/proc.cp = smb_setup_header(server, SMBsetatr, 8, 4 + len);
len1492fs/smbfs/proc.cp = smb_encode_ascii(p, path, len);
len1546fs/smbfs/proc.creturn smb_proc_setattr_core(server, finfo->path, finfo->len,
len47fs/smbfs/sock.cstatic int _send(struct socket *sock, const void *buff, int len, int nonblock, unsigned flags) {
len52fs/smbfs/sock.ciov.iov_len  = len;
len60fs/smbfs/sock.creturn sock->ops->sendmsg(sock, &msg, len, nonblock, flags);
len64fs/smbfs/sock.csmb_data_callback(struct sock *sk,int len)
len216fs/smbfs/sock.cint len, result;
len257fs/smbfs/sock.clen = smb_len(peek_buf); 
len258fs/smbfs/sock.cif (len > max_raw_length) { 
len260fs/smbfs/sock.clen, max_raw_length);
len271fs/smbfs/sock.cwhile (already_read < len) {
len275fs/smbfs/sock.clen - already_read, 0, 0,
len496fs/smbfs/sock.cint len, result, result2;
len515fs/smbfs/sock.clen = smb_len(buffer) + 4;
len517fs/smbfs/sock.cDDPRINTK("smb_request: len = %d cmd = 0x%X\n", len, buffer[8]);
len524fs/smbfs/sock.cresult = _send(sock, (void *)buffer, len, 0, 0);
len564fs/smbfs/sock.cint len, result, result2;
len583fs/smbfs/sock.clen = smb_len(buffer) + 4;
len590fs/smbfs/sock.cDDPRINTK("smb_request: len = %d cmd = 0x%X\n", len, buffer[8]);
len592fs/smbfs/sock.cresult = _send(sock, (void *)buffer, len, 0, 0);
len628fs/smbfs/sock.cint len, result, result2;
len649fs/smbfs/sock.clen = smb_len(buffer) + 4;
len657fs/smbfs/sock.clen, buffer[8]);
len663fs/smbfs/sock.cresult = _send(sock, (void *)buffer, len, 0, 0);
len209fs/super.cint err, len;
len218fs/super.clen = strlen(tmp->name) + 1;
len219fs/super.cerr = verify_area(VERIFY_WRITE, buf, len);
len222fs/super.cmemcpy_tofs(buf, tmp->name, len);
len268fs/super.cint len = 0;
len270fs/super.cwhile ( tmp && len < PAGE_SIZE - 80 )
len272fs/super.clen += sprintf( buf + len, "%s %s %s %s",
len275fs/super.clen += sprintf( buf + len, " 0 0\n" );
len279fs/super.creturn len;
len284fs/super.cint len = 0;
len288fs/super.cwhile (tmp && len < PAGE_SIZE - 80) {
len289fs/super.clen += sprintf(buf+len, "%s\t%s\n",
len294fs/super.creturn len;
len25fs/sysv/namei.cstatic inline int namecompare(int len, int maxlen,
len28fs/sysv/namei.cif (len > maxlen)
len30fs/sysv/namei.cif (len < maxlen && buffer[len])
len32fs/sysv/namei.creturn !memcmp(name, buffer, len);
len42fs/sysv/namei.cstatic int sysv_match(int len, const char * name, struct sysv_dir_entry * de)
len44fs/sysv/namei.cif (!de->inode || len > SYSV_NAMELEN)
len47fs/sysv/namei.cif (!len && (de->name[0]=='.') && (de->name[1]=='\0'))
len49fs/sysv/namei.creturn namecompare(len,SYSV_NAMELEN,name,de->name);
len103fs/sysv/namei.cint sysv_lookup(struct inode * dir,const char * name, int len,
len117fs/sysv/namei.cif (!(bh = sysv_find_entry(dir,name,len,&de))) {
len204fs/sysv/namei.cint sysv_create(struct inode * dir,const char * name, int len, int mode,
len223fs/sysv/namei.cerror = sysv_add_entry(dir,name,len, &bh ,&de);
len239fs/sysv/namei.cint sysv_mknod(struct inode * dir, const char * name, int len, int mode, int rdev)
len248fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len280fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len296fs/sysv/namei.cint sysv_mkdir(struct inode * dir, const char * name, int len, int mode)
len307fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len345fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len422fs/sysv/namei.cint sysv_rmdir(struct inode * dir, const char * name, int len)
len430fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len478fs/sysv/namei.cint sysv_unlink(struct inode * dir, const char * name, int len)
len488fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len532fs/sysv/namei.cint sysv_symlink(struct inode * dir, const char * name, int len, const char * symname)
len567fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len576fs/sysv/namei.ci = sysv_add_entry(dir, name, len, &bh, &de);
len592fs/sysv/namei.cint sysv_link(struct inode * oldinode, struct inode * dir, const char * name, int len)
len608fs/sysv/namei.cbh = sysv_find_entry(dir,name,len,&de);
len615fs/sysv/namei.cerror = sysv_add_entry(dir, name, len, &bh, &de);
len197fs/umsdos/dir.c,info.fake.len,&inode);
len602fs/umsdos/dir.cint len)
len612fs/umsdos/dir.c&& len == 3
len622fs/umsdos/dir.cint len,
len629fs/umsdos/dir.cif (len == 1 && name[0] == '.'){
len633fs/umsdos/dir.c}else if (len == 2 && name[0] == '.' && name[1] == '.'){
len665fs/umsdos/dir.c}else if (umsdos_is_pseudodos(dir,name,len)){
len675fs/umsdos/dir.cret = umsdos_parse (name,len,&info);
len678fs/umsdos/dir.c,info.fake.len));
len690fs/umsdos/dir.cret = umsdos_real_lookup (dir,info.fake.fname,info.fake.len,result);
len731fs/umsdos/dir.cint len,
len734fs/umsdos/dir.creturn umsdos_lookup_x(dir,name,len,result,0);
len763fs/umsdos/dir.cint len;
len765fs/umsdos/dir.clen = (int)(pt - start);
len769fs/umsdos/dir.cret = umsdos_rlookup_x(dir,start,len,result,1);
len771fs/umsdos/dir.cret = umsdos_lookup_x(dir,start,len,result,1);
len71fs/umsdos/inode.cint len,
len76fs/umsdos/inode.cret = msdos_lookup (dir,name,len,result);
len157fs/umsdos/ioctl.c,info.fake.fname,info.fake.len+1);
len74fs/umsdos/mangle.cchar *pt = info->fake.fname + info->fake.len;
len99fs/umsdos/mangle.cinfo->fake.len += 4;
len108fs/umsdos/mangle.cint umsdos_evalrecsize (int len)
len111fs/umsdos/mangle.cint nbrec = 1+((len-1+(dirent.name-(char*)&dirent))
len120fs/umsdos/mangle.cint umsdos_evalrecsize_old (int len)
len123fs/umsdos/mangle.cint size = len + (dirent.name-(char*)&dirent);
len136fs/umsdos/mangle.cint len,
len145fs/umsdos/mangle.cif (len > UMSDOS_MAXNAME) len = UMSDOS_MAXNAME;
len153fs/umsdos/mangle.cint msdos_len = len;
len192fs/umsdos/mangle.cif (len<=(8+1+3)){
len194fs/umsdos/mangle.cconst char *endpt = fname + len;
len255fs/umsdos/mangle.c|| (firstpt == NULL && len > 8)
len256fs/umsdos/mangle.c|| (len == UMSDOS_EMD_NAMELEN
len302fs/umsdos/mangle.cstrncpy (info->fake.fname,fname,len);
len304fs/umsdos/mangle.cbase_len = firstpt != NULL ? (int)(firstpt - fname) : len;
len373fs/umsdos/mangle.cinfo->fake.len = msdos_len;
len375fs/umsdos/mangle.cmemcpy (info->entry.name,fname,len);
len376fs/umsdos/mangle.cinfo->entry.name_len = len;
len382fs/umsdos/mangle.cinfo->recsize = umsdos_evalrecsize (len);
len161fs/umsdos/namei.cint len,
len165fs/umsdos/namei.cif (umsdos_is_pseudodos(dir,name,len)){
len176fs/umsdos/namei.c&& (len == 1 || (len == 2 && name[1] == '.'))){
len202fs/umsdos/namei.cint len,        /* Length of the name */
len210fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len213fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len229fs/umsdos/namei.cret = msdos_create (dir,info.fake.fname,info.fake.len
len348fs/umsdos/namei.cPRINTK (("ret %d %d ",ret,new_info.fake.len));
len354fs/umsdos/namei.c,old_info.fake.fname,old_info.fake.len
len356fs/umsdos/namei.c,new_info.fake.fname,new_info.fake.len);
len423fs/umsdos/namei.cint len,
len442fs/umsdos/namei.cret = umsdos_create_any (dir,name,len,mode,0,flags,&inode);
len445fs/umsdos/namei.cint len = strlen(symname);
len449fs/umsdos/namei.cret = umsdos_file_write_kmem (inode,&filp,symname,len);
len452fs/umsdos/namei.cif (ret != len){
len461fs/umsdos/namei.cUMSDOS_unlink (dir,name,len);
len476fs/umsdos/namei.cint len,
len479fs/umsdos/namei.creturn umsdos_symlink_x (dir,name,len,symname,S_IFLNK|0777,0);
len488fs/umsdos/namei.cint len)
len567fs/umsdos/namei.c}else if ((ret = umsdos_nevercreat(dir,name,len,-EPERM))==0){
len617fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len
len634fs/umsdos/namei.cret = umsdos_symlink_x (dir,name,len,path
len667fs/umsdos/namei.cint len,        /* Length of the name */
len672fs/umsdos/namei.creturn umsdos_create_any (dir,name,len,mode,0,0,result);
len680fs/umsdos/namei.cint len,
len683fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EEXIST);
len686fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len703fs/umsdos/namei.cret = msdos_mkdir (dir,info.fake.fname,info.fake.len,mode);
len719fs/umsdos/namei.c,info.fake.len,&subdir);
len746fs/umsdos/namei.cint len,
len765fs/umsdos/namei.cint ret = umsdos_create_any (dir,name,len,mode,rdev,0,&inode);
len776fs/umsdos/namei.cint len)
len865fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len869fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&sdir);
len895fs/umsdos/namei.cumsdos_parse (name,len,&info);
len900fs/umsdos/namei.c,info.fake.len);
len930fs/umsdos/namei.cint len)
len932fs/umsdos/namei.cint ret = umsdos_nevercreat(dir,name,len,-EPERM);
len935fs/umsdos/namei.cret = umsdos_parse (name,len,&info);
len960fs/umsdos/namei.cret = UMSDOS_lookup (dir,name,len,&inode);
len989fs/umsdos/namei.c,info.fake.len);
len86fs/umsdos/rdir.cint len,
len93fs/umsdos/rdir.c&& len == 2
len106fs/umsdos/rdir.cret = umsdos_real_lookup (dir,name,len,result);
len130fs/umsdos/rdir.cint len,
len133fs/umsdos/rdir.creturn umsdos_rlookup_x(dir,name,len,result,0);
len139fs/umsdos/rdir.cint len)
len156fs/umsdos/rdir.cif (umsdos_is_pseudodos(dir,name,len)){
len169fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
len173fs/umsdos/rdir.cret = UMSDOS_rlookup (dir,name,len,&sdir);
len192fs/umsdos/rdir.cret = msdos_rmdir (dir,name,len);
len124fs/vfat/namei.cstatic int vfat_find(struct inode *dir,const char *name,int len,
len132fs/vfat/namei.cstatic int vfat_valid_longname(const char *name, int len, int dot_dirs)
len139fs/vfat/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len144fs/vfat/namei.cif (len && name[len-1] == ' ') return -EINVAL;
len145fs/vfat/namei.cif (len >= 256) return -EINVAL;
len146fs/vfat/namei.cfor (i = 0; i < len; i++) {
len150fs/vfat/namei.cif (len == 3 || len == 4) {
len157fs/vfat/namei.cstatic int vfat_valid_shortname(char conv,const char *name,int len,
len165fs/vfat/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len172fs/vfat/namei.cfor (walk = name; len && walk-name < 8;) {
len174fs/vfat/namei.clen--;
len185fs/vfat/namei.cif ((conv == 's' || conv == 'x') && len && c != '.') {
len187fs/vfat/namei.clen--;
len190fs/vfat/namei.cwhile (c != '.' && len--) c = *walk++;
len192fs/vfat/namei.cif (len >= 4) return -EINVAL;
len193fs/vfat/namei.cwhile (len > 0 && walk-name < (MSDOS_NAME+1)) {
len195fs/vfat/namei.clen--;
len207fs/vfat/namei.cif ((conv == 's' || conv == 'x') && len) return -EINVAL;
len220fs/vfat/namei.cstatic int vfat_format_name(char conv,const char *name,int len,char *res,
len229fs/vfat/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.'))) {
len232fs/vfat/namei.cwhile (len--) *res++ = '.';
len238fs/vfat/namei.cfor (walk = res; len && walk-res < 8; walk++) {
len240fs/vfat/namei.clen--;
len251fs/vfat/namei.cif ((conv == 's' || conv == 'x') && len && c != '.') {
len253fs/vfat/namei.clen--;
len256fs/vfat/namei.cwhile (c != '.' && len--) c = *name++;
len259fs/vfat/namei.cwhile (len > 0 && walk-res < MSDOS_NAME) {
len261fs/vfat/namei.clen--;
len274fs/vfat/namei.cif ((conv == 's' || conv == 'x') && len) return -EINVAL;
len289fs/vfat/namei.cint len, char *name_res)
len306fs/vfat/namei.cPRINTK(("Entering vfat_create_shortname: name=%s, len=%d\n", name, len));
len309fs/vfat/namei.cif (len && name[len-1]==' ') return -EINVAL;
len310fs/vfat/namei.cif (len <= 12) {
len313fs/vfat/namei.cfor (i = 0, p = msdos_name, ip = name; i < len; i++, p++, ip++)
len321fs/vfat/namei.cres = vfat_format_name('x', msdos_name, len, name_res, 1);
len324fs/vfat/namei.cres = vfat_find(dir, msdos_name, len, 0, 0, 0, &sinfo);
len334fs/vfat/namei.cext_start = end = &name[len];
len338fs/vfat/namei.csz = len;
len345fs/vfat/namei.csz = len;
len363fs/vfat/namei.csz = len;
len491fs/vfat/namei.cstatic int vfat_build_slots(struct inode *dir,const char *name,int len,
len506fs/vfat/namei.cPRINTK(("Entering vfat_build_slots: name=%s, len=%d\n", name, len));
len513fs/vfat/namei.cif (len == 1 && name[0] == '.') {
len516fs/vfat/namei.c} else if (len == 2 && name[0] == '.' && name[1] == '.') {
len521fs/vfat/namei.cres = vfat_valid_shortname('x', name, len, 1);
len524fs/vfat/namei.cres = vfat_format_name('x', name, len, de->name, 1);
len529fs/vfat/namei.cPRINTK(("vfat_build_slots 5A: %s (len=%d) is an invalid shortname\n", name, len));
len534fs/vfat/namei.cres = vfat_create_shortname(dir, name, len, msdos_name);
len550fs/vfat/namei.cres = vfat_valid_longname(name, len, 1);
len554fs/vfat/namei.c*slots = (len + 12) / 13;
len576fs/vfat/namei.cif (!end && j == len) {
len603fs/vfat/namei.cif (!end && j == len) {
len628fs/vfat/namei.cif (!end && j == len) {
len711fs/vfat/namei.cstatic int vfat_find(struct inode *dir,const char *name,int len,
len728fs/vfat/namei.cPRINTK(("vfat_find 1: name=%s, len=%d\n",name,len));
len730fs/vfat/namei.cres = vfat_build_slots(dir, name, len, find_long, new_filename,
len904fs/vfat/namei.cint vfat_lookup(struct inode *dir,const char *name,int len,
len911fs/vfat/namei.cPRINTK (("vfat_lookup: name=%s, len=%d\n", name, len));
len920fs/vfat/namei.cif (len == 1 && name[0] == '.') {
len924fs/vfat/namei.cif (len == 2 && name[0] == '.' && name[1] == '.') {
len932fs/vfat/namei.cif ((res = vfat_find(dir,name,len,1,0,0,&sinfo)) < 0) {
len968fs/vfat/namei.cstatic int vfat_create_entry(struct inode *dir,const char *name,int len,
len979fs/vfat/namei.cres = vfat_find(dir, name, len, 1, 1, is_dir, &sinfo);
len1007fs/vfat/namei.cint vfat_create(struct inode *dir,const char *name,int len,int mode,
len1015fs/vfat/namei.cif ((res = vfat_create_entry(dir,name,len,0,result)) < 0) {
len1235fs/vfat/namei.cstatic int vfat_rmdirx(struct inode *dir,const char *name,int len)
len1245fs/vfat/namei.cif (name[0] == '.' && (len == 1 || (len == 2 && name[1] == '.')))
len1247fs/vfat/namei.cres = vfat_find(dir,name,len,1,0,0,&sinfo);
len1264fs/vfat/namei.cint vfat_rmdir(struct inode *dir,const char *name,int len)
len1268fs/vfat/namei.cres = vfat_rmdirx(dir, name, len);
len1276fs/vfat/namei.cint len,
len1286fs/vfat/namei.cif ((res = vfat_find(dir,name,len,1,0,0,&sinfo)) < 0)
len1304fs/vfat/namei.cint vfat_mkdir(struct inode *dir,const char *name,int len,int mode)
len1310fs/vfat/namei.cif ((res = vfat_create_entry(dir,name,len,1,&inode)) < 0) {
len1326fs/vfat/namei.cif (vfat_rmdir(dir,name,len) < 0)
len1333fs/vfat/namei.cint vfat_unlink(struct inode *dir,const char *name,int len)
len1337fs/vfat/namei.cres = vfat_unlinkx (dir,name,len,1);
len32fs/xiafs/namei.cstatic int xiafs_match(int len, const char * name, struct xiafs_direct * dep)
len36fs/xiafs/namei.cif (!dep || !dep->d_ino || len > _XIAFS_NAME_LEN)
len39fs/xiafs/namei.cif (!len && (dep->d_name[0]=='.') && (dep->d_name[1]=='\0'))
len41fs/xiafs/namei.cif (len != dep->d_name_len)
len43fs/xiafs/namei.cfor (i=0; i < len; i++)
len116fs/xiafs/namei.cint xiafs_lookup(struct inode * dir, const char * name, int len,
len130fs/xiafs/namei.cif (!(bh = xiafs_find_entry(dir, name, len, &dep, NULL))) {
len245fs/xiafs/namei.cint xiafs_create(struct inode * dir, const char * name, int len, int mode,
len263fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len279fs/xiafs/namei.cint xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
len287fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len320fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len336fs/xiafs/namei.cint xiafs_mkdir(struct inode * dir, const char * name, int len, int mode)
len342fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len,&de, NULL);
len386fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len486fs/xiafs/namei.cint xiafs_rmdir(struct inode * dir, const char * name, int len)
len494fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len538fs/xiafs/namei.cint xiafs_unlink(struct inode * dir, const char * name, int len)
len548fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, &de_pre);
len586fs/xiafs/namei.cint len, const char * symname)
len594fs/xiafs/namei.cbh = xiafs_find_entry(dir,name,len, &de, NULL);
len621fs/xiafs/namei.cbh = xiafs_add_entry(dir, name, len, &de, NULL);
len638fs/xiafs/namei.cconst char * name, int len)
len653fs/xiafs/namei.cbh = xiafs_find_entry(dir, name, len, &de, NULL);
len660fs/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(const unsigned char * buff, int len, unsigned int sum);
len42include/asm-alpha/checksum.hunsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
len56include/asm-alpha/checksum.hextern unsigned short ip_compute_csum(unsigned char * buff, int len);
len189include/asm-alpha/io.h#define memcpy_fromio(to,from,len)  _memcpy_fromio((to),(unsigned long)(from),(len))
len190include/asm-alpha/io.h#define memcpy_toio(to,from,len)  _memcpy_toio((unsigned long)(to),(from),(len))
len191include/asm-alpha/io.h#define memset_io(addr,c,len)    _memset_io((unsigned long)(addr),(c),(len))
len209include/asm-alpha/io.h#define eth_io_copy_and_sum(skb,src,len,unused)  memcpy_fromio((skb)->data,(src),(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(const unsigned char * buff, int len, unsigned int sum);
len26include/asm-i386/checksum.hunsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
len36include/asm-i386/checksum.hunsigned int csum_partial_copy_fromuser(const 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));
len123include/asm-i386/checksum.hstatic inline unsigned short ip_compute_csum(unsigned char * buff, int len) {
len135include/asm-i386/checksum.h: "0" (csum_partial(buff, len, 0)));
len25include/asm-mips/checksum.hunsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
len34include/asm-mips/checksum.hunsigned int csum_partial_copy(const char *src, char *dst, int len, int sum);
len108include/asm-mips/checksum.hunsigned short len,
len131include/asm-mips/checksum.h: "0" (daddr), "r"(saddr), "r"((ntohs(len)<<16)+proto*256), "r"(sum)
len161include/asm-mips/checksum.hstatic inline unsigned short ip_compute_csum(unsigned char * buff, int len) {
len173include/asm-mips/checksum.h: "r" (csum_partial(buff, len, 0))
len17include/asm-ppc/checksum.hunsigned short len,
len33include/asm-ppc/checksum.hextern unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum);
len42include/asm-ppc/checksum.hunsigned int csum_partial_copy( const char *src, char *dst, int len, int sum);
len56include/asm-ppc/checksum.hextern unsigned short ip_compute_csum(unsigned char * buff, int len);
len72include/asm-ppc/io.hvoid outsl(int port, long *ptr, int len);
len25include/asm-sparc/checksum.hdo_csum(unsigned char * buff, int len)
len30include/asm-sparc/checksum.hif (len <= 0)
len35include/asm-sparc/checksum.hlen--;
len38include/asm-sparc/checksum.hcount = len >> 1;    /* nr of 16-bit words.. */
len43include/asm-sparc/checksum.hlen -= 2;
len53include/asm-sparc/checksum.hlen -= 4;
len61include/asm-sparc/checksum.hif (len & 2) {
len66include/asm-sparc/checksum.hif (len & 1)
len92include/asm-sparc/checksum.hextern inline unsigned int csum_partial(unsigned char * buff, int len, unsigned int sum)
len94include/asm-sparc/checksum.hunsigned long result = do_csum(buff, len);
len110include/asm-sparc/checksum.hextern inline unsigned int csum_partial_copy(char *src, char *dst, int len, int sum)
len119include/asm-sparc/checksum.hsum = csum_partial(src, len, sum);
len120include/asm-sparc/checksum.hmemcpy(dst, src, len);
len128include/asm-sparc/checksum.hextern inline unsigned short ip_compute_csum(unsigned char * buff, int len)
len130include/asm-sparc/checksum.hreturn ~from32to16(do_csum(buff,len));
len153include/asm-sparc/checksum.hunsigned short len,
len159include/asm-sparc/checksum.h(sum & 0xffff) + proto + len));
len116include/asm-sparc/openprom.hvoid (*pv_putstr)(char *str, int len);
len128include/asm-sparc/openprom.hvoid (*v0_eval)(int len, char *str);
len179include/asm-sparc/openprom.hint (*no_setprop)(int node, char *name, char *val, int len);
len71include/linux/cdrom.hunsigned short len;
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,
len91include/linux/minix_fs.hextern int minix_lookup(struct inode * dir,const char * name, int len,
len93include/linux/minix_fs.hextern int minix_create(struct inode * dir,const char * name, int len, int mode,
len95include/linux/minix_fs.hextern int minix_mkdir(struct inode * dir, const char * name, int len, int mode);
len96include/linux/minix_fs.hextern int minix_rmdir(struct inode * dir, const char * name, int len);
len97include/linux/minix_fs.hextern int minix_unlink(struct inode * dir, const char * name, int len);
len98include/linux/minix_fs.hextern int minix_symlink(struct inode * inode, const char * name, int len,
len100include/linux/minix_fs.hextern int minix_link(struct inode * oldinode, struct inode * dir, const char * name, int len);
len101include/linux/minix_fs.hextern int minix_mknod(struct inode * dir, const char * name, int len, int mode, int rdev);
len213include/linux/mm.hextern unsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
len239include/linux/msdos_fs.hextern int msdos_lookup(struct inode *dir,const char *name,int len, 
len241include/linux/msdos_fs.hextern int msdos_create(struct inode *dir,const char *name,int len,int mode,
len243include/linux/msdos_fs.hextern int msdos_rmdir(struct inode *dir,const char *name,int len);
len244include/linux/msdos_fs.hextern int msdos_mkdir(struct inode *dir,const char *name,int len,int mode);
len245include/linux/msdos_fs.hextern int msdos_unlink(struct inode *dir,const char *name,int len);
len246include/linux/msdos_fs.hextern int msdos_unlink_umsdos(struct inode *dir,const char *name,int len);
len109include/linux/net.hint  (*listen)  (struct socket *sock, int len);
len87include/linux/net_alias.h(struct net_alias_type *this, struct net_alias *alias, char *buf, int len);
len172include/linux/netdevice.hunsigned len);
len59include/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)
len32include/linux/rpcsock.hint      len;
len78include/linux/skbuff.hunsigned long   len;      /* Length of actual data      */
len156include/linux/skbuff.hextern unsigned char *    skb_put(struct sk_buff *skb, int len);
len157include/linux/skbuff.hextern unsigned char *    skb_push(struct sk_buff *skb, int len);
len158include/linux/skbuff.hextern unsigned char *    skb_pull(struct sk_buff *skb, int len);
len161include/linux/skbuff.hextern void      skb_reserve(struct sk_buff *skb, int len);
len162include/linux/skbuff.hextern void       skb_trim(struct sk_buff *skb, int len);
len389include/linux/skbuff.hextern __inline__ unsigned char *skb_put(struct sk_buff *skb, int len)
len392include/linux/skbuff.hskb->tail+=len;
len393include/linux/skbuff.hskb->len+=len;
len395include/linux/skbuff.hpanic("skput:over: %p:%d", __builtin_return_address(0),len);
len399include/linux/skbuff.hextern __inline__ unsigned char *skb_push(struct sk_buff *skb, int len)
len401include/linux/skbuff.hskb->data-=len;
len402include/linux/skbuff.hskb->len+=len;
len404include/linux/skbuff.hpanic("skpush:under: %p:%d", __builtin_return_address(0),len);
len408include/linux/skbuff.hextern __inline__ unsigned char * skb_pull(struct sk_buff *skb, int len)
len410include/linux/skbuff.hif(len > skb->len)
len412include/linux/skbuff.hskb->data+=len;
len413include/linux/skbuff.hskb->len-=len;
len427include/linux/skbuff.hextern __inline__ void skb_reserve(struct sk_buff *skb, int len)
len429include/linux/skbuff.hskb->data+=len;
len430include/linux/skbuff.hskb->tail+=len;
len433include/linux/skbuff.hextern __inline__ void skb_trim(struct sk_buff *skb, int len)
len435include/linux/skbuff.hif(skb->len>len)
len437include/linux/skbuff.hskb->len=len;
len438include/linux/skbuff.hskb->tail=skb->data+len;
len102include/linux/smb.hint             len;  /* Namelength. */
len124include/linux/smb_fs.hbyte *smb_encode_smb_length(byte *p, dword len);
len126include/linux/smb_fs.hint len, struct smb_dirent *entry);
len137include/linux/smb_fs.hint len, struct smb_dirent *entry);
len138include/linux/smb_fs.hint smb_proc_mknew(struct smb_server *server, const char *path, int len,
len142include/linux/smb_fs.hint smb_proc_mkdir(struct smb_server *server, const char *path, const int len);
len143include/linux/smb_fs.hint smb_proc_rmdir(struct smb_server *server, const char *path, const int len);
len145include/linux/smb_fs.hconst int len);
len150include/linux/smb_fs.hint len, struct smb_dirent *entry);
len154include/linux/smb_fs.hint smb_proc_chkpath(struct smb_server *server, char *path, int len,
len120include/linux/socket.hextern void memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
len122include/linux/socket.hextern void memcpy_toiovec(struct iovec *v, unsigned char *kdata, int len);
len172include/linux/soundcard.hint len;  /* Size of the wave data in bytes */
len231include/linux/soundcard.hint len;  /* Size of the sysex data in bytes */
len661include/linux/soundcard.hint len;
len672include/linux/soundcard.hint len;  /* Length of data in bytes */
len676include/linux/soundcard.hint len;
len936include/linux/soundcard.h#define SEQ_DEFINEBUF(len)    unsigned char _seqbuf[len]; int _seqbuflen = len;int _seqbufptr = 0
len940include/linux/soundcard.h#define _SEQ_NEEDBUF(len)    if ((_seqbufptr+(len)) > _seqbuflen) seqbuf_dump()
len941include/linux/soundcard.h#define _SEQ_ADVBUF(len)    _seqbufptr += len
len958include/linux/soundcard.h#define _SEQ_NEEDBUF(len)  /* empty */
len1035include/linux/soundcard.h#define SEQ_SYSEX(dev, buf, len) \
len1036include/linux/soundcard.h{int i, l=(len); if (l>6)l=6;\
len1125include/linux/soundcard.h#define SEQ_WRPATCH(patchx, len)    {if (_seqbufptr) seqbuf_dump();\
len1126include/linux/soundcard.hif (write(seqfd, (char*)(patchx), len)==-1) \
len1128include/linux/soundcard.h#define SEQ_WRPATCH2(patchx, len)  (seqbuf_dump(), write(seqfd, (char*)(patchx), len))
len114include/linux/sysctl.hint rdwr, void *data, size_t 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;
len25include/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, 
len34include/net/icmp.hunsigned short len, __u32 saddr,
len57include/net/ip.hint    len;    /* length of this fragment    */
len72include/net/ip.hint    len;    /* total length of original datagram  */
len89include/net/ip.hextern int     ip_send(struct rtable *rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr);
len94include/net/ip.hstruct options *opt, int len,
len2include/net/ipip.h__u32 daddr, unsigned short len, __u32 saddr,
len33include/net/protocol.hunsigned short len, __u32 saddr,
len27include/net/raw.hint len, int noblock, unsigned flags,
len30include/net/raw.hint len, int noblock, unsigned flags);
len285include/net/sock.hstruct options *opt, int len,
len298include/net/sock.hunsigned short len, __u32 saddr,
len310include/net/sock.hint      (*sendmsg)(struct sock *sk, struct msghdr *msg, int len,
len312include/net/sock.hint      (*recvmsg)(struct sock *sk, struct msghdr *msg, int len,
len449include/net/sock.hsk->data_ready(sk,skb->len);
len124include/net/tcp.hunsigned short len, __u32 saddr, int redo,
len135include/net/tcp.hunsigned long daddr, int len, struct sk_buff *skb);
len280include/net/tcp.hstatic __inline__ u16 tcp_check(struct tcphdr *th, int len,
len283include/net/tcp.hreturn csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
len37include/net/udp.h__u32 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, __u32 saddr, int redo,
len439init/main.cint len = strlen(devnames[n]);
len440init/main.cif (!strncmp(line,devnames[n],len)) {
len442init/main.csimple_strtoul(line+len,NULL,0));
len59kernel/dma.cint i, len = 0;
len63kernel/dma.clen += sprintf(buf+len, "%2d: %s\n",
len68kernel/dma.creturn len;
len621kernel/module.cint len     = 0;  /* code from  net/ipv4/proc.c */
len633kernel/module.cp = buf + len;
len635kernel/module.clen += sprintf(p, "%08lx %s\t[%s]\n",
len639kernel/module.clen += sprintf(p, "%08lx %s\n",
len643kernel/module.cpos = begin + len;
len645kernel/module.clen   = 0;
len648kernel/module.cpos = begin + len;
len656kernel/module.clen -= (offset - begin);
len657kernel/module.cif (len > length)
len658kernel/module.clen = length;
len659kernel/module.creturn len;
len61kernel/printk.casmlinkage int sys_syslog(int type, char * buf, int len)
len76kernel/printk.cif (!buf || len < 0)
len78kernel/printk.cif (!len)
len80kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len92kernel/printk.cwhile (log_size && i < len) {
len109kernel/printk.cif (!buf || len < 0)
len111kernel/printk.cif (!len)
len113kernel/printk.cerror = verify_area(VERIFY_WRITE,buf,len);
len116kernel/printk.ccount = len;
len139kernel/printk.cif (len < 1 || len > 8)
len141kernel/printk.cif (len < MINIMUM_CONSOLE_LOGLEVEL)
len142kernel/printk.clen = MINIMUM_CONSOLE_LOGLEVEL;
len143kernel/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;
len718kernel/sys.casmlinkage int sys_sethostname(char *name, int len)
len724kernel/sys.cif (len < 0 || len > __NEW_UTS_LEN)
len726kernel/sys.cerror = verify_area(VERIFY_READ, name, len);
len729kernel/sys.cmemcpy_fromfs(system_utsname.nodename, name, len);
len730kernel/sys.csystem_utsname.nodename[len] = 0;
len734kernel/sys.casmlinkage int sys_gethostname(char *name, int len)
len738kernel/sys.cif (len < 0)
len740kernel/sys.ci = verify_area(VERIFY_WRITE, name, len);
len744kernel/sys.cif (i > len)
len745kernel/sys.ci = len;
len754kernel/sys.casmlinkage int sys_setdomainname(char *name, int len)
len760kernel/sys.cif (len < 0 || len > __NEW_UTS_LEN)
len762kernel/sys.cerror = verify_area(VERIFY_READ, name, len);
len765kernel/sys.cmemcpy_fromfs(system_utsname.domainname, name, len);
len766kernel/sys.csystem_utsname.domainname[len] = 0;
len265kernel/sysctl.cint op = 0, rc, len;
len287kernel/sysctl.clen = get_user(oldlenp);
len288kernel/sysctl.cif (len > table->maxlen)
len289kernel/sysctl.clen = table->maxlen;
len290kernel/sysctl.cmemcpy_tofs(oldval, table->data, len);
len291kernel/sysctl.cput_user(len, oldlenp);
len294kernel/sysctl.clen = newlen;
len295kernel/sysctl.cif (len > table->maxlen)
len296kernel/sysctl.clen = table->maxlen;
len297kernel/sysctl.cmemcpy_fromfs(table->data, newval, len);
len470kernel/sysctl.cint len;
len480kernel/sysctl.clen = 0;
len482kernel/sysctl.cwhile (len < *lenp && 
len484kernel/sysctl.clen++;
len485kernel/sysctl.cif (len >= table->maxlen)
len486kernel/sysctl.clen = table->maxlen-1;
len487kernel/sysctl.cmemcpy_fromfs(table->data, buffer, len);
len488kernel/sysctl.c((char *) table->data)[len] = 0;
len491kernel/sysctl.clen = strlen(table->data) + 1;
len492kernel/sysctl.cif (len > table->maxlen)
len493kernel/sysctl.clen = table->maxlen;
len494kernel/sysctl.cif (len > *lenp)
len495kernel/sysctl.clen = *lenp;
len496kernel/sysctl.cif (len) {      
len497kernel/sysctl.cmemcpy_tofs(buffer, table->data, len-1);
len498kernel/sysctl.cput_user(0, ((char *) buffer) + len - 1);
len500kernel/sysctl.cif (len < *lenp) {
len501kernel/sysctl.cput_user('\n', ((char *) buffer) + len);
len502kernel/sysctl.clen++;
len504kernel/sysctl.c*lenp = len;
len505kernel/sysctl.cfilp->f_pos += len;
len513kernel/sysctl.cint *i, vleft, first=1, len, left, neg, val;
len534kernel/sysctl.clen = left;
len535kernel/sysctl.cif (len > TMPBUFLEN-1)
len536kernel/sysctl.clen = TMPBUFLEN-1;
len537kernel/sysctl.cmemcpy_fromfs(buf, buffer, len);
len538kernel/sysctl.cbuf[len] = 0;
len547kernel/sysctl.clen = p-buf;
len548kernel/sysctl.cif ((len < left) && *p && !isspace(*p))
len552kernel/sysctl.cbuffer += len;
len553kernel/sysctl.cleft -= len;
len560kernel/sysctl.clen = strlen(buf);
len561kernel/sysctl.cif (len > left)
len562kernel/sysctl.clen = left;
len563kernel/sysctl.cmemcpy_tofs(buffer, buf, len);
len564kernel/sysctl.cleft -= len;
len565kernel/sysctl.cbuffer += len;
len611kernel/sysctl.cint l, len;
len617kernel/sysctl.clen = get_user(oldlenp);
len619kernel/sysctl.cif (len > l) len = l;
len620kernel/sysctl.cif (len >= table->maxlen)
len621kernel/sysctl.clen = table->maxlen;
len622kernel/sysctl.cmemcpy_tofs(oldval, table->data, len);
len623kernel/sysctl.cput_user(0, ((char *) oldval) + len);
len624kernel/sysctl.cput_user(len, oldlenp);
len627kernel/sysctl.clen = newlen;
len628kernel/sysctl.cif (len > table->maxlen)
len629kernel/sysctl.clen = table->maxlen;
len630kernel/sysctl.cmemcpy_fromfs(table->data, newval, len);
len631kernel/sysctl.cif (len == table->maxlen)
len632kernel/sysctl.clen--;
len633kernel/sysctl.c((char *) table->data)[len] = 0;
len681kernel/sysctl.cint rdwr, void *data, size_t len)
len685kernel/sysctl.cif (newval && newlen != len)
len688kernel/sysctl.cif (get_user(oldlenp) < len)
len690kernel/sysctl.cput_user(len, oldlenp);
len691kernel/sysctl.cmemcpy_tofs(oldval, data, len);
len694kernel/sysctl.cmemcpy_fromfs(data, newval, len);
len1105lib/inflate.cunsigned len = (unsigned)get_byte();
len1106lib/inflate.clen |= ((unsigned)get_byte())<<8;
len1107lib/inflate.cwhile (len--) (void)get_byte();
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--)
len655mm/filemap.cstatic void filemap_unmap(struct vm_area_struct *vma, unsigned long start, size_t len)
len657mm/filemap.cfilemap_sync(vma, start, len, MS_ASYNC);
len749mm/filemap.casmlinkage int sys_msync(unsigned long start, size_t len, int flags)
len757mm/filemap.clen = (len + ~PAGE_MASK) & PAGE_MASK;
len758mm/filemap.cend = start + len;
len810mm/memory.cunsigned long len = mpnt->vm_end - start;
len815mm/memory.czap_page_range(mpnt->vm_mm, start, len);
len820mm/memory.cif (diff >= len)
len824mm/memory.clen = (len - diff) & PAGE_MASK;
len829mm/memory.czap_page_range(mpnt->vm_mm, start, len);
len136mm/mlock.cstatic int do_mlock(unsigned long start, size_t len, int on)
len144mm/mlock.clen = (len + ~PAGE_MASK) & PAGE_MASK;
len145mm/mlock.cend = start + len;
len184mm/mlock.casmlinkage int sys_mlock(unsigned long start, size_t len)
len189mm/mlock.clen = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK;
len192mm/mlock.clocked = len >> PAGE_SHIFT;
len207mm/mlock.creturn do_mlock(start, len, 1);
len210mm/mlock.casmlinkage int sys_munlock(unsigned long start, size_t len)
len212mm/mlock.clen = (len + (start & ~PAGE_MASK) + ~PAGE_MASK) & PAGE_MASK;
len214mm/mlock.creturn do_mlock(start, len, 0);
len53mm/mmap.cunsigned long do_mmap(struct file * file, unsigned long addr, unsigned long len,
len59mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len62mm/mmap.cif (addr > TASK_SIZE || len > TASK_SIZE || addr > TASK_SIZE-len)
len66mm/mmap.cif (off + len < off)
len72mm/mmap.clocked += len;
len112mm/mmap.cif (len > TASK_SIZE || addr > TASK_SIZE - len)
len115mm/mmap.caddr = get_unmapped_area(addr, len);
len135mm/mmap.cvma->vm_end = addr + len;
len166mm/mmap.cdo_munmap(addr, len);  /* Clear old maps */
len179mm/mmap.ccurrent->mm->total_vm += len >> PAGE_SHIFT;
len183mm/mmap.ccurrent->mm->locked_vm += len >> PAGE_SHIFT;
len198mm/mmap.cunsigned long get_unmapped_area(unsigned long addr, unsigned long len)
len202mm/mmap.cif (len > TASK_SIZE)
len209mm/mmap.cif (TASK_SIZE - len < addr)
len215mm/mmap.cif (addr + len > vmm->vm_start) {
len614mm/mmap.cunsigned long addr, size_t len)
len617mm/mmap.cunsigned long end = addr + len;
len627mm/mmap.carea->vm_mm->total_vm -= len >> PAGE_SHIFT;
len629mm/mmap.carea->vm_mm->locked_vm -= len >> PAGE_SHIFT;
len680mm/mmap.casmlinkage int sys_munmap(unsigned long addr, size_t len)
len682mm/mmap.creturn do_munmap(addr, len);
len691mm/mmap.cint do_munmap(unsigned long addr, size_t len)
len695mm/mmap.cif ((addr & ~PAGE_MASK) || addr > TASK_SIZE || len > TASK_SIZE-addr)
len698mm/mmap.cif ((len = PAGE_ALIGN(len)) == 0)
len716mm/mmap.cfor ( ; mpnt && mpnt->vm_start < addr+len; mpnt = *npp) {
len741mm/mmap.cend = addr+len;
len751mm/mmap.czap_page_range(current->mm, addr, len);
len202mm/mprotect.casmlinkage int sys_mprotect(unsigned long start, size_t len, unsigned long prot)
len210mm/mprotect.clen = (len + ~PAGE_MASK) & PAGE_MASK;
len211mm/mprotect.cend = start + len;
len57net/802/p8022.cdev->hard_header(skb, dev, ETH_P_802_3, dest_node, NULL, skb->len);
len13net/802/p8023.cdev->hard_header(skb, dev, ETH_P_802_3, dest_node, NULL, skb->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;
len105net/appletalk/aarp.cint len=dev->hard_header_len+sizeof(struct elapaarp)+aarp_dl->header_length;
len106net/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);
len237net/appletalk/ddp.cint len=0;
len245net/appletalk/ddp.clen += sprintf (buffer,"Type local_addr  remote_addr tx_queue rx_queue st uid\n");
len248net/appletalk/ddp.clen += sprintf (buffer+len,"%02X   ", s->type);
len249net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X:%02X  ",
len251net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X:%02X  ",
len253net/appletalk/ddp.clen += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
len254net/appletalk/ddp.clen += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
len257net/appletalk/ddp.cpos=begin+len;
len261net/appletalk/ddp.clen=0;      /* Keep dumping into the buffer start */
len270net/appletalk/ddp.clen-=(offset-begin);    /* Remove unwanted header data from length */
len271net/appletalk/ddp.cif(len>length)
len272net/appletalk/ddp.clen=length;    /* Remove unwanted tail data from length */
len274net/appletalk/ddp.creturn len;
len844net/appletalk/ddp.cint len=0;
len848net/appletalk/ddp.clen += sprintf (buffer,"Interface    Address   Networks   Status\n");
len851net/appletalk/ddp.clen += sprintf (buffer+len,"%-16s %04X:%02X  %04X-%04X  %d\n",
len856net/appletalk/ddp.cpos=begin+len;
len859net/appletalk/ddp.clen=0;
len866net/appletalk/ddp.clen-=(offset-begin);
len867net/appletalk/ddp.cif(len>length)
len868net/appletalk/ddp.clen=length;
len869net/appletalk/ddp.creturn len;
len877net/appletalk/ddp.cint len=0;
len881net/appletalk/ddp.clen += sprintf (buffer,"Target        Router  Flags Dev\n");
len885net/appletalk/ddp.clen += sprintf (buffer+len,"Default     %5d:%-3d  %-4d  %s\n",
len891net/appletalk/ddp.clen += sprintf (buffer+len,"%04X:%02X     %5d:%-3d  %-4d  %s\n",
len895net/appletalk/ddp.cpos=begin+len;
len898net/appletalk/ddp.clen=0;
len905net/appletalk/ddp.clen-=(offset-begin);
len906net/appletalk/ddp.cif(len>length)
len907net/appletalk/ddp.clen=length;
len908net/appletalk/ddp.creturn len;
len922net/appletalk/ddp.cunsigned short atalk_checksum(struct ddpehdr *ddp, int len)
len927net/appletalk/ddp.clen-=4;    /* skip header 4 bytes */
len931net/appletalk/ddp.cwhile(len--)
len1061net/appletalk/ddp.cstatic void def_callback2(struct sock *sk, int len)
len1372net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
len1391net/appletalk/ddp.coriglen = skb->len;
len1393net/appletalk/ddp.cskb_trim(skb,min(skb->len,ddp->deh_len));
len1401net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
len1515net/appletalk/ddp.cstatic int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len, int nonblock, int flags)
len1531net/appletalk/ddp.cif(len>587)
len1568net/appletalk/ddp.csize=sizeof(struct ddpehdr)+len+ddp_dl->header_length;  /* For headers */
len1611net/appletalk/ddp.cddp->deh_len=len+sizeof(*ddp);
len1627net/appletalk/ddp.cprintk("SK %p: Copy user data (%d bytes).\n", sk, len);
len1629net/appletalk/ddp.cmemcpy_fromiovec(skb_put(skb,len),msg->msg_iov,len);
len1634net/appletalk/ddp.cddp->deh_sum=atalk_checksum(ddp, len+sizeof(*ddp));
len1697net/appletalk/ddp.cprintk("SK %p: Done write (%d).\n", sk, len);
len1698net/appletalk/ddp.creturn len;
len1785net/appletalk/ddp.camount=skb->len-sizeof(struct ddpehdr);
len377net/ax25/af_ax25.csk->data_ready(sk, skb->len);
len886net/ax25/af_ax25.cstatic void def_callback2(struct sock *sk, int len)
len1465net/ax25/af_ax25.cif (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type, &dama) == NULL) {
len1583net/ax25/af_ax25.csk->data_ready(sk, skb->len);
len1729net/ax25/af_ax25.csk->data_ready(sk, skb->len );
len1761net/ax25/af_ax25.cint len;
len1770net/ax25/af_ax25.clen = skb->data[0] + skb->data[1] * 256 - 5;
len1773net/ax25/af_ax25.cskb_trim(skb, len);  /* Set the length of the data */
len1779net/ax25/af_ax25.cstatic int ax25_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock, int flags)
len1855net/ax25/af_ax25.csize = len + 3 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
len1864net/ax25/af_ax25.cskb_reserve(skb, size - len);
len1870net/ax25/af_ax25.cmemcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
len1888net/ax25/af_ax25.creturn len;
len1914net/ax25/af_ax25.creturn len;
len1947net/ax25/af_ax25.clength = skb->len + (skb->data - skb->h.raw);
len1951net/ax25/af_ax25.clength     = skb->len;
len1967net/ax25/af_ax25.cax25_parse_addr(skb->data, skb->len, NULL, &dest, &digi, NULL, &dama);
len2030net/ax25/af_ax25.camount = skb->len;
len2112net/ax25/af_ax25.cint len = 0;
len2118net/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");
len2126net/ax25/af_ax25.clen += sprintf(buffer + len, "%-9s ",
len2128net/ax25/af_ax25.clen += sprintf(buffer + len, "%-9s %-4s %2d %3d %3d %3d %3d/%03d %2d/%02d %3d/%03d %2d/%02d %3d %3d",
len2143net/ax25/af_ax25.clen += sprintf(buffer + len, " %5ld %5ld\n",
len2147net/ax25/af_ax25.clen += sprintf(buffer + len, "\n");
len2150net/ax25/af_ax25.cpos = begin + len;
len2153net/ax25/af_ax25.clen   = 0;
len2164net/ax25/af_ax25.clen   -= (offset - begin);
len2166net/ax25/af_ax25.cif (len > length) len = length;
len2168net/ax25/af_ax25.creturn(len);
len2299net/ax25/af_ax25.csize = skb->len;
len2346net/ax25/af_ax25.cvoid *saddr, unsigned len)
len76net/ax25/ax25_in.cax25->fraglen += skb->len;
len97net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
len102net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
len119net/ax25/ax25_in.cax25->fraglen = skb->len;
len61net/ax25/ax25_out.cint err, frontlen, mtu, len, fragno, first = 1;
len65net/ax25/ax25_out.cif ((skb->len - 1) > mtu) {
len68net/ax25/ax25_out.cfragno = skb->len / mtu;
len69net/ax25/ax25_out.cif (skb->len % mtu == 0) fragno--;
len73net/ax25/ax25_out.cwhile (skb->len > 0) {
len88net/ax25/ax25_out.clen = (mtu > skb->len) ? skb->len : mtu;
len90net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
len91net/ax25/ax25_out.cskb_pull(skb, len);
len274net/ax25/ax25_route.cint len     = 0;
len282net/ax25/ax25_route.clen += sprintf(buffer, "callsign  dev  count time      mode digipeaters\n");
len289net/ax25/ax25_route.clen += sprintf(buffer + len, "%-9s %-4s %5d %9d",
len298net/ax25/ax25_route.clen += sprintf(buffer + len, "   vc");
len302net/ax25/ax25_route.clen += sprintf(buffer + len, "   dg");
len305net/ax25/ax25_route.clen += sprintf(buffer + len, "    *");
len311net/ax25/ax25_route.clen += sprintf(buffer + len, " %s", ax2asc(&ax25_rt->digipeat->calls[i]));
len313net/ax25/ax25_route.clen += sprintf(buffer + len, "\n");
len315net/ax25/ax25_route.cpos = begin + len;
len318net/ax25/ax25_route.clen   = 0;
len329net/ax25/ax25_route.clen   -= (offset - begin);
len331net/ax25/ax25_route.cif (len > length) len = length;
len333net/ax25/ax25_route.creturn len;
len339net/ax25/ax25_route.cint len     = 0;
len345net/ax25/ax25_route.clen += sprintf(buffer, "Policy: %d\n", ax25_uid_policy);
len348net/ax25/ax25_route.clen += sprintf(buffer + len, "%6d %s\n", pt->uid, ax2asc(&pt->call));
len350net/ax25/ax25_route.cpos = begin + len;
len353net/ax25/ax25_route.clen = 0;
len364net/ax25/ax25_route.clen   -= offset - begin;
len366net/ax25/ax25_route.cif (len > length) len = length;
len368net/ax25/ax25_route.creturn len;
len652net/ax25/ax25_route.cint len     = 0;
len658net/ax25/ax25_route.clen += sprintf(buffer, "dev  callsign\n");
len661net/ax25/ax25_route.clen += sprintf(buffer + len, "%-4s %-9s\n",
len665net/ax25/ax25_route.cpos = begin + len;
len668net/ax25/ax25_route.clen   = 0;
len679net/ax25/ax25_route.clen   -= (offset - begin);
len681net/ax25/ax25_route.cif (len > length) len = length;
len683net/ax25/ax25_route.creturn len;
len333net/ax25/ax25_subr.cunsigned char *ax25_parse_addr(unsigned char *buf, int len, ax25_address *src, ax25_address *dest, ax25_digi *digi, int *flags, int *dama)
len337net/ax25/ax25_subr.cif (len < 14) return NULL;
len359net/ax25/ax25_subr.clen -= 2 * AX25_ADDR_LEN;
len366net/ax25/ax25_subr.cif (len < 7) return NULL;  /* Short packet */
len380net/ax25/ax25_subr.clen -= AX25_ADDR_LEN;
len392net/ax25/ax25_subr.cint len = 0;
len402net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len425net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len437net/ax25/ax25_subr.clen += AX25_ADDR_LEN;
len443net/ax25/ax25_subr.creturn len;
len760net/core/dev.cint len;
len771net/core/dev.clen = ifc.ifc_len;
len779net/core/dev.cerr=verify_area(VERIFY_WRITE,pos,len);
len800net/core/dev.cif (len < sizeof(struct ifreq)) 
len809net/core/dev.clen -= sizeof(struct ifreq);    
len864net/core/dev.cint len=0;
len876net/core/dev.clen+=size;
len881net/core/dev.csize = sprintf_stats(buffer+len, dev);
len882net/core/dev.clen+=size;
len883net/core/dev.cpos=begin+len;
len887net/core/dev.clen=0;
len895net/core/dev.clen-=(offset-begin);    /* Start slop */
len896net/core/dev.cif(len>length)
len897net/core/dev.clen=length;    /* Ending slop */
len898net/core/dev.creturn len;
len31net/core/iovec.cint len=0;
len60net/core/iovec.clen+=iov[ct].iov_len;
len63net/core/iovec.creturn len;
len70net/core/iovec.cvoid memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
len72net/core/iovec.cwhile(len>0)
len76net/core/iovec.cint copy = min(iov->iov_len,len);
len79net/core/iovec.clen-=copy;
len91net/core/iovec.cvoid memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len)
len93net/core/iovec.cwhile(len>0)
len97net/core/iovec.cint copy=min(len,iov->iov_len);
len99net/core/iovec.clen-=copy;
len871net/core/net_alias.cint len=0;
len874net/core/net_alias.clen=sprintf(buffer,"type    name            n_attach\n");
len878net/core/net_alias.clen += sprintf(buffer+len, "%-7d %-15s %-7d\n",
len880net/core/net_alias.cpos=begin+len;
len883net/core/net_alias.clen=0;
len890net/core/net_alias.clen-=(offset-begin);
len891net/core/net_alias.cif(len>length)
len892net/core/net_alias.clen=length;  
len893net/core/net_alias.creturn len;
len908net/core/net_alias.cint len=0;
len914net/core/net_alias.clen=sprintf(buffer,"%-*s\n",NET_ALIASES_RECSIZ-1,"device           family address");
len920net/core/net_alias.cdlen=sprintf(buffer+len, "%-16s %-6d ", alias->name, alias->dev.family);
len927net/core/net_alias.cdlen += nat->alias_print_1(nat, alias, buffer+len+dlen, NET_ALIASES_RECSIZ - dlen);
len929net/core/net_alias.cdlen += sprintf(buffer+len+dlen, "-");
len935net/core/net_alias.cif (dlen < NET_ALIASES_RECSIZ) memset(buffer+len+dlen, ' ', NET_ALIASES_RECSIZ - dlen);
len940net/core/net_alias.clen += NET_ALIASES_RECSIZ;
len941net/core/net_alias.cbuffer[len-1] = '\n';
len943net/core/net_alias.cpos=begin+len;
len946net/core/net_alias.clen=0;
len953net/core/net_alias.clen-=(offset-begin);
len954net/core/net_alias.cif(len>length)
len955net/core/net_alias.clen=length;  
len956net/core/net_alias.creturn len;
len169net/core/skbuff.cif(skb->tail-skb->data!=skb->len)
len173net/core/skbuff.cskb,skb->data,skb->end,skb->len);
len381net/core/skbuff.cunsigned char *skb_put(struct sk_buff *skb, int len)
len385net/core/skbuff.cskb->tail+=len;
len386net/core/skbuff.cskb->len+=len;
len389net/core/skbuff.cpanic("skput:over: %p:%d", __builtin_return_address(0),len);
len393net/core/skbuff.cunsigned char *skb_push(struct sk_buff *skb, int len)
len396net/core/skbuff.cskb->data-=len;
len397net/core/skbuff.cskb->len+=len;
len400net/core/skbuff.cpanic("skpush:under: %p:%d", __builtin_return_address(0),len);
len404net/core/skbuff.cunsigned char * skb_pull(struct sk_buff *skb, int len)
len407net/core/skbuff.cif(len>skb->len)
len409net/core/skbuff.cskb->data+=len;
len410net/core/skbuff.cskb->len-=len;
len426net/core/skbuff.cvoid skb_reserve(struct sk_buff *skb, int len)
len429net/core/skbuff.cskb->data+=len;
len430net/core/skbuff.cskb->tail+=len;
len438net/core/skbuff.cvoid skb_trim(struct sk_buff *skb, int len)
len441net/core/skbuff.cif(skb->len>len)
len443net/core/skbuff.cskb->len=len;
len444net/core/skbuff.cskb->tail=skb->data+len;
len520net/core/skbuff.cint len=size;
len585net/core/skbuff.cskb->end=bptr+len;
len586net/core/skbuff.cskb->len=0;
len688net/core/skbuff.cskb_put(n,skb->len);
len567net/core/sock.cskb->saddr, skb->len, skb->daddr, 1,
len90net/ethernet/eth.cvoid *daddr, void *saddr, unsigned len)
len102net/ethernet/eth.ceth->h_proto = htons(len);
len14net/ethernet/pe2.cdev->hard_header(skb, dev, ETH_P_IPX, dest_node, NULL, skb->len);
len558net/ipv4/af_inet.cstatic void def_callback2(struct sock *sk,int len)
len662net/ipv4/arp.cdev->hard_header(skb,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len);
len1320net/ipv4/arp.cint len=0;
len1331net/ipv4/arp.clen+=size;
len1365net/ipv4/arp.csize = sprintf(buffer+len,
len1372net/ipv4/arp.csize += sprintf(buffer+len+size,
len1377net/ipv4/arp.csize += sprintf(buffer+len+size,
len1385net/ipv4/arp.clen += size;
len1389net/ipv4/arp.clen=0;
len1396net/ipv4/arp.c*start = buffer+len-(pos-offset);  /* Start of wanted data */
len1397net/ipv4/arp.clen = pos-offset;      /* Start slop */
len1398net/ipv4/arp.cif (len>length)
len1399net/ipv4/arp.clen = length;      /* Ending slop */
len1400net/ipv4/arp.creturn len;
len1638net/ipv4/arp.cstatic inline int empty(unsigned char * addr, int len)
len1640net/ipv4/arp.cwhile (len > 0) {
len1643net/ipv4/arp.clen--;
len151net/ipv4/icmp.cvoid (*handler)(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len);
len339net/ipv4/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
len470net/ipv4/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 source, __u32 daddr, int len)
len540net/ipv4/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
len546net/ipv4/icmp.cicmp_param.data_len=len;
len560net/ipv4/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
len569net/ipv4/icmp.cif(len<12)
len610net/ipv4/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
len627net/ipv4/icmp.cstatic void icmp_discard(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
len637net/ipv4/icmp.c__u32 daddr, unsigned short len,
len647net/ipv4/icmp.cif (ip_compute_csum((unsigned char *) icmph, len)) 
len694net/ipv4/icmp.clen-=sizeof(struct icmphdr);
len696net/ipv4/icmp.c(icmp_pointers[icmph->type].handler)(icmph,skb,skb->dev,saddr,daddr,len);
len427net/ipv4/igmp.c__u32 daddr, unsigned short len, __u32 saddr, int redo,
len447net/ipv4/igmp.cif(skb->len <sizeof(struct igmphdr) || skb->ip_hdr->ttl>1 || ip_compute_csum((void *)skb->h.raw,sizeof(struct igmphdr)))
len71net/ipv4/ip_alias.cip_alias_print_1(struct net_alias_type *this, struct net_alias *alias, char *buf, int len)
len45net/ipv4/ip_forward.cstatic void ip_encap(struct sk_buff *skb, int len, struct device *out, __u32 daddr)
len53net/ipv4/ip_forward.cif(len>65515)
len54net/ipv4/ip_forward.clen=65515;
len63net/ipv4/ip_forward.ciph->tot_len  =  htons(skb->len);
len73net/ipv4/ip_forward.cif (out->hard_header && out->hard_header(skb, out, ETH_P_IP, NULL, NULL, len)<0)
len248net/ipv4/ip_forward.cif (skb->len+encap > dev2->mtu && (ntohs(iph->frag_off) & IP_DF)) 
len260net/ipv4/ip_forward.cskb2 = alloc_skb(dev2->hard_header_len + skb->len + encap + 15, GFP_ATOMIC);
len264net/ipv4/ip_forward.cskb2 = alloc_skb(dev2->hard_header_len + skb->len + 15, GFP_ATOMIC);
len288net/ipv4/ip_forward.cip_encap(skb2,skb->len, dev2, raddr);
len292net/ipv4/ip_forward.cip_send(rt,skb2,raddr,skb->len,dev2,dev2->pa_addr);
len299net/ipv4/ip_forward.cptr = skb_put(skb2,skb->len);
len306net/ipv4/ip_forward.cmemcpy(ptr, skb->h.raw, skb->len);
len320net/ipv4/ip_forward.cip_encap(skb,skb->len, dev2, raddr);
len339net/ipv4/ip_forward.cif(dev2->hard_header(skb, dev2, ETH_P_IP, NULL, NULL, skb->len)<0)
len418net/ipv4/ip_forward.cif(skb2->len > dev2->mtu + dev2->hard_header_len)
len64net/ipv4/ip_fragment.cextern __inline__ void frag_kfree_s(void *ptr, int len)
len69net/ipv4/ip_fragment.cip_frag_mem-=len;
len71net/ipv4/ip_fragment.ckfree_s(ptr,len);
len107net/ipv4/ip_fragment.cfp->len = end - offset;
len281net/ipv4/ip_fragment.cqp->len = 0;
len314net/ipv4/ip_fragment.cif (qp->len == 0)
len347net/ipv4/ip_fragment.cint count, len;
len352net/ipv4/ip_fragment.clen = qp->ihlen + qp->len;
len354net/ipv4/ip_fragment.cif ((skb = dev_alloc_skb(len)) == NULL)
len363net/ipv4/ip_fragment.cskb_put(skb,len);
len378net/ipv4/ip_fragment.cif(count+fp->len > skb->len)
len386net/ipv4/ip_fragment.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
len387net/ipv4/ip_fragment.ccount += fp->len;
len500net/ipv4/ip_fragment.cqp->len = end;
len540net/ipv4/ip_fragment.ctmp->len -= i;        /* so reduce size of  */
len547net/ipv4/ip_fragment.cif (tmp->len <= 0)
len624net/ipv4/ip_fragment.cint left, mtu, hlen, len;
len696net/ipv4/ip_fragment.clen = left;
len698net/ipv4/ip_fragment.cif (len > mtu)
len699net/ipv4/ip_fragment.clen = mtu;
len702net/ipv4/ip_fragment.cif (len < left)
len704net/ipv4/ip_fragment.clen/=8;
len705net/ipv4/ip_fragment.clen*=8;
len711net/ipv4/ip_fragment.cif ((skb2 = alloc_skb(len + hlen+15,GFP_ATOMIC)) == NULL)
len726net/ipv4/ip_fragment.cskb_put(skb2,len + hlen);
len752net/ipv4/ip_fragment.cmemcpy(skb2->h.raw + hlen, ptr, len);
len753net/ipv4/ip_fragment.cleft -= len;
len779net/ipv4/ip_fragment.cptr += len;
len780net/ipv4/ip_fragment.coffset += len;
len646net/ipv4/ip_fw.cwhile (skb->len - ((unsigned char *)data - skb->h.raw) > 18)
len746net/ipv4/ip_fw.cprintk("MASQUERADE: resizing needed for %d bytes (%ld)\n",diff, skb->len);
len748net/ipv4/ip_fw.cskb2 = alloc_skb(MAX_HEADER + skb->len+diff, GFP_ATOMIC);
len755net/ipv4/ip_fw.cskb_put(skb2,skb->len + diff);
len772net/ipv4/ip_fw.cskb->len - (data-(char *)skb->data));
len778net/ipv4/ip_fw.ciph->tot_len = htons(skb->len + diff);
len792net/ipv4/ip_fw.cunsigned long daddr, int len)
len795net/ipv4/ip_fw.cuh->check=csum_tcpudp_magic(saddr,daddr,len,
len796net/ipv4/ip_fw.cIPPROTO_UDP, csum_partial((char *)uh,len,0));
len864net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
len886net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr-skb->h.raw);
len959net/ipv4/ip_fw.cint size = skb->len - ((unsigned char *)portptr - skb->h.raw);
len1051net/ipv4/ip_fw.cstatic int insert_in_chain(struct ip_fw *volatile* chainptr, struct ip_fw *frwl,int len)
len1067net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
len1081net/ipv4/ip_fw.cstatic int append_to_chain(struct ip_fw *volatile* chainptr, struct ip_fw *frwl,int len)
len1099net/ipv4/ip_fw.cmemcpy(ftmp, frwl, len);
len1197net/ipv4/ip_fw.cstruct ip_fw *check_ipfw_struct(struct ip_fw *frwl, int len)
len1200net/ipv4/ip_fw.cif ( len != sizeof(struct ip_fw) )
len1203net/ipv4/ip_fw.cprintk("ip_fw_ctl: len=%d, want %d\n",len, sizeof(struct ip_fw));
len1260net/ipv4/ip_fw.cint ip_acct_ctl(int stage, void *m, int len)
len1277net/ipv4/ip_fw.cif (!(frwl=check_ipfw_struct(m,len)))
len1283net/ipv4/ip_fw.creturn( insert_in_chain(&ip_acct_chain,frwl,len));
len1285net/ipv4/ip_fw.creturn( append_to_chain(&ip_acct_chain,frwl,len));
len1306net/ipv4/ip_fw.cint ip_fw_ctl(int stage, void *m, int len)
len1339net/ipv4/ip_fw.cif ( len < sizeof(struct ip_fwpkt) )
len1343net/ipv4/ip_fw.clen, sizeof(struct ip_fwpkt));
len1383net/ipv4/ip_fw.cfrwl=check_ipfw_struct(m,len);
len1391net/ipv4/ip_fw.creturn(insert_in_chain(chains[fwtype],frwl,len));
len1393net/ipv4/ip_fw.creturn(append_to_chain(chains[fwtype],frwl,len));
len1422net/ipv4/ip_fw.cint len, p;
len1430net/ipv4/ip_fw.clen=sprintf(buffer, "IP firewall input rules, default %d\n",
len1435net/ipv4/ip_fw.clen=sprintf(buffer, "IP firewall output rules, default %d\n",
len1440net/ipv4/ip_fw.clen=sprintf(buffer, "IP firewall forward rules, default %d\n",
len1447net/ipv4/ip_fw.clen=sprintf(buffer,"IP accounting rules\n");
len1453net/ipv4/ip_fw.clen=0;
len1462net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%08lX/%08lX->%08lX/%08lX %08lX %X ",
len1466net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%u %u %-9lu %-9lu",
len1469net/ipv4/ip_fw.clen+=sprintf(buffer+len, " %u", i->fw_pts[p]);
len1470net/ipv4/ip_fw.clen+=sprintf(buffer+len, " A%02X X%02X", i->fw_tosand, i->fw_tosxor);
len1471net/ipv4/ip_fw.cbuffer[len++]='\n';
len1472net/ipv4/ip_fw.cbuffer[len]='\0';
len1473net/ipv4/ip_fw.cpos=begin+len;
len1476net/ipv4/ip_fw.clen=0;
len1491net/ipv4/ip_fw.clen-=(offset-begin);
len1492net/ipv4/ip_fw.cif(len>length)
len1493net/ipv4/ip_fw.clen=length;  
len1494net/ipv4/ip_fw.creturn len;
len1541net/ipv4/ip_fw.cint len=0;
len1543net/ipv4/ip_fw.clen=sprintf(buffer,"Prc FromIP   FPrt ToIP     TPrt Masq Init-seq  Delta PDelta Expires\n"); 
len1553net/ipv4/ip_fw.clen+=sprintf(buffer+len,"%s %08lX:%04X %08lX:%04X %04X %08X %6d %6d %lu\n",
len1562net/ipv4/ip_fw.cpos=begin+len;
len1565net/ipv4/ip_fw.clen=0;
len1574net/ipv4/ip_fw.clen-=(offset-begin);
len1575net/ipv4/ip_fw.cif(len>length)
len1576net/ipv4/ip_fw.clen=length;
len1577net/ipv4/ip_fw.creturn len;
len247net/ipv4/ip_input.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0
len248net/ipv4/ip_input.c|| skb->len < ntohs(iph->tot_len))
len369net/ipv4/ip_options.cif (ts->ptr+3 > ts->len) 
len384net/ipv4/ip_options.cif (ts->ptr+7 > ts->len) 
len400net/ipv4/ip_options.cif (ts->ptr+7 > ts->len) 
len70net/ipv4/ip_output.cint len=ntohs(skb->ip_hdr->tot_len);
len71net/ipv4/ip_output.cstruct sk_buff *newskb=dev_alloc_skb(len+dev->hard_header_len+15);
len90net/ipv4/ip_output.cip_send(NULL,newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr);
len94net/ipv4/ip_output.cnewskb->ip_hdr=(struct iphdr *)skb_put(newskb, len);
len100net/ipv4/ip_output.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
len114net/ipv4/ip_output.cint ip_send(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
len140net/ipv4/ip_output.cmac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
len151net/ipv4/ip_output.cstatic int ip_send_room(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
len173net/ipv4/ip_output.cmac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
len194net/ipv4/ip_output.cint len, int tos, int ttl, struct rtable ** rp)
len263net/ipv4/ip_output.ctmp = ip_send_room(rt, skb, raddr, len, *dev, saddr);
len265net/ipv4/ip_output.ctmp = ip_send(rt, skb, raddr, len, *dev, saddr);
len366net/ipv4/ip_output.ciph->tot_len = ntohs(skb->len-(((unsigned char *)iph)-skb->data));
len48net/ipv4/ip_sockglue.cint len=0;
len51net/ipv4/ip_sockglue.clen=sprintf(buffer,"Device    : Count\tGroup    Users Timer\n");  
len59net/ipv4/ip_sockglue.clen+=sprintf(buffer+len,"%-10s: %5d\n",
len63net/ipv4/ip_sockglue.clen+=sprintf(buffer+len,
len67net/ipv4/ip_sockglue.cpos=begin+len;
len70net/ipv4/ip_sockglue.clen=0;
len80net/ipv4/ip_sockglue.clen-=(offset-begin);
len81net/ipv4/ip_sockglue.cif(len>length)
len82net/ipv4/ip_sockglue.clen=length;  
len83net/ipv4/ip_sockglue.creturn len;
len434net/ipv4/ip_sockglue.cint len;
len522net/ipv4/ip_sockglue.clen=strlen(sk->ip_mc_name);
len523net/ipv4/ip_sockglue.cerr=verify_area(VERIFY_WRITE, optval, len);
len526net/ipv4/ip_sockglue.cput_user(len,(int *) optlen);
len527net/ipv4/ip_sockglue.cmemcpy_tofs((void *)optval,sk->ip_mc_name, len);
len53net/ipv4/ipip.c__u32 daddr, unsigned short len, __u32 saddr,
len279net/ipv4/ipmr.cskb->ip_hdr->tot_len=htons(skb->len);      /* Fix the length */
len712net/ipv4/ipmr.cvif->bytes_out+=skb->len;
len740net/ipv4/ipmr.cvif_table[vif].bytes_in+=skb->len;
len799net/ipv4/ipmr.cint len=0;
len805net/ipv4/ipmr.clen += sprintf(buffer,
len807net/ipv4/ipmr.cpos=len;
len816net/ipv4/ipmr.csize = sprintf(buffer+len, "%-10s %8ld  %7ld  %8ld   %7ld   %05X %08lX %08lX\n",
len819net/ipv4/ipmr.clen+=size;
len823net/ipv4/ipmr.clen=0;
len831net/ipv4/ipmr.clen-=(offset-begin);
len832net/ipv4/ipmr.cif(len>length)
len833net/ipv4/ipmr.clen=length;
len834net/ipv4/ipmr.creturn len;
len840net/ipv4/ipmr.cint len=0;
len846net/ipv4/ipmr.clen += sprintf(buffer,
len848net/ipv4/ipmr.cpos=len;
len876net/ipv4/ipmr.csize = sprintf(buffer+len, "%08lX %08lX %-8s %s\n",
len881net/ipv4/ipmr.clen+=size;
len885net/ipv4/ipmr.clen=0;
len899net/ipv4/ipmr.clen-=(offset-begin);
len900net/ipv4/ipmr.cif(len>length)
len901net/ipv4/ipmr.clen=length;
len902net/ipv4/ipmr.creturn len;
len122net/ipv4/packet.cstatic int packet_sendmsg(struct sock *sk, struct msghdr *msg, int len,
len164net/ipv4/packet.cif(len>dev->mtu+dev->hard_header_len)
len167net/ipv4/packet.cskb = sock_wmalloc(sk, len, 0, GFP_KERNEL);
len186net/ipv4/packet.cmemcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
len197net/ipv4/packet.creturn(len);
len378net/ipv4/packet.cint packet_recvmsg(struct sock *sk, struct msghdr *msg, int len,
len426net/ipv4/packet.ccopied = min(len, skb->len);
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");
len111net/ipv4/proc.clen += sprintf(buffer+len, "%2d: %08lX:%04X %08lX:%04X %02X %08lX:%08lX %02X:%08lX %08X %d %d\n",
len126net/ipv4/proc.cpos=begin+len;
len129net/ipv4/proc.clen=0;
len143net/ipv4/proc.clen-=(offset-begin);
len144net/ipv4/proc.cif(len>length)
len145net/ipv4/proc.clen=length;
len146net/ipv4/proc.creturn len;
len177net/ipv4/proc.cint len  = socket_get_info(buffer,start,offset,length);
len179net/ipv4/proc.clen += sprintf(buffer+len,"SOCK_ARRAY_SIZE=%d\n",SOCK_ARRAY_SIZE);
len180net/ipv4/proc.clen += sprintf(buffer+len,"TCP: inuse %d highest %d\n",
len182net/ipv4/proc.clen += sprintf(buffer+len,"UDP: inuse %d highest %d\n",
len184net/ipv4/proc.clen += sprintf(buffer+len,"RAW: inuse %d highest %d\n",
len186net/ipv4/proc.clen += sprintf(buffer+len,"PAC: inuse %d highest %d\n",
len189net/ipv4/proc.clen -= offset;
len190net/ipv4/proc.cif (len > length)
len191net/ipv4/proc.clen = length;
len192net/ipv4/proc.creturn len;
len204net/ipv4/proc.cint len;
len209net/ipv4/proc.clen = sprintf (buffer,
len223net/ipv4/proc.clen += sprintf (buffer + len,
len240net/ipv4/proc.clen += sprintf (buffer + len,
len250net/ipv4/proc.clen += sprintf (buffer + len,
len260net/ipv4/proc.cif (offset >= len)
len266net/ipv4/proc.clen -= offset;
len267net/ipv4/proc.cif (len > length)
len268net/ipv4/proc.clen = length;
len269net/ipv4/proc.creturn len;
len486net/ipv4/rarp.cint len=0;
len497net/ipv4/rarp.clen+=size;
len504net/ipv4/rarp.clen+=size;
len516net/ipv4/rarp.csize = sprintf(buffer+len,
len527net/ipv4/rarp.clen+=size;
len528net/ipv4/rarp.cpos=begin+len;
len532net/ipv4/rarp.clen=0;
len542net/ipv4/rarp.clen   -= (offset-begin);  /* Start slop */
len543net/ipv4/rarp.cif (len>length)
len544net/ipv4/rarp.clen = length;    /* Ending slop */
len545net/ipv4/rarp.creturn len;
len191net/ipv4/raw.cint len, int noblock, unsigned flags, struct sockaddr_in *usin, int addr_len)
len240net/ipv4/raw.cif(len>65535)
len242net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getrawfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);
len246net/ipv4/raw.cif(len>65535-sizeof(struct iphdr))
len248net/ipv4/raw.cerr=ip_build_xmit(sk, raw_getfrag, from, len, sin.sin_addr.s_addr, 0, sk->opt, flags, sin.sin_port, noblock);
len250net/ipv4/raw.creturn err<0?err:len;
len257net/ipv4/raw.cstatic int raw_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
len261net/ipv4/raw.creturn raw_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
len273net/ipv4/raw.cif(len>65515)
len275net/ipv4/raw.cbuf=kmalloc(len, GFP_KERNEL);
len278net/ipv4/raw.cmemcpy_fromiovec(buf, msg->msg_iov, len);
len281net/ipv4/raw.cerr=raw_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
len283net/ipv4/raw.ckfree_s(buf,len);
len312net/ipv4/raw.cint raw_recvmsg(struct sock *sk, struct msghdr *msg, int len,
len333net/ipv4/raw.ccopied = min(len, skb->len);
len806net/ipv4/route.cint len=0;
len816net/ipv4/route.clen = 128;
len834net/ipv4/route.clen = 0;
len862net/ipv4/route.clen=0;
len871net/ipv4/route.csprintf(buffer+len,"%-127s\n",temp);
len873net/ipv4/route.clen += 128;
len884net/ipv4/route.c*start = buffer+len-(pos-offset);
len885net/ipv4/route.clen = pos - offset;
len886net/ipv4/route.cif (len>length)
len887net/ipv4/route.clen = length;
len888net/ipv4/route.creturn len;
len893net/ipv4/route.cint len=0;
len904net/ipv4/route.clen = 128;
len923net/ipv4/route.clen = 0;
len931net/ipv4/route.csprintf(buffer+len,"%-127s\n",temp);
len932net/ipv4/route.clen += 128;
len942net/ipv4/route.c*start = buffer+len-(pos-offset);
len943net/ipv4/route.clen = pos-offset;
len944net/ipv4/route.cif (len>length)
len945net/ipv4/route.clen = length;
len946net/ipv4/route.creturn len;
len632net/ipv4/tcp.csum = skb->len - (counted - skb->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
len807net/ipv4/tcp.cunsigned long daddr, int len, struct sk_buff *skb)
len813net/ipv4/tcp.cth->check = tcp_check(th, len, saddr, daddr,
len819net/ipv4/tcp.cth->check = tcp_check(th, len, saddr, daddr,
len820net/ipv4/tcp.ccsum_partial((char *)th,len,0));
len893net/ipv4/tcp.cint len, int nonblock, int flags)
len1018net/ipv4/tcp.clen -= copy;
len1130net/ipv4/tcp.clen -= copy;
len1150net/ipv4/tcp.cint len, int nonblock, int flags)
len1178net/ipv4/tcp.cretval = do_tcp_sendmsg(sk, msg, len, nonblock, flags);
len1286net/ipv4/tcp.cstruct msghdr *msg, int len, int flags, int *addr_len)
len1433net/ipv4/tcp.cint len, int nonblock, int flags, int *addr_len)
len1453net/ipv4/tcp.creturn tcp_recv_urg(sk, nonblock, msg, len, flags, addr_len);
len1468net/ipv4/tcp.cwhile (len > 0) 
len1496net/ipv4/tcp.cif (offset < skb->len)
len1566net/ipv4/tcp.cused = skb->len - offset;
len1567net/ipv4/tcp.cif (len < used)
len1568net/ipv4/tcp.cused = len;
len1608net/ipv4/tcp.clen -= used;
len1620net/ipv4/tcp.cif (used + offset < skb->len)
len154net/ipv4/tcp_input.cstatic void bad_tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
len588net/ipv4/tcp_input.cstatic int tcp_ack(struct sock *sk, struct tcphdr *th, u32 ack, int len)
len623net/ipv4/tcp_input.cif (len != th->doff*4) 
len1190net/ipv4/tcp_input.cunsigned long saddr, unsigned short len)
len1199net/ipv4/tcp_input.cskb_trim(skb,len-(th->doff*4));
len1206net/ipv4/tcp_input.csk->bytes_rcv += skb->len;
len1208net/ipv4/tcp_input.cif (skb->len == 0 && !th->fin) 
len1235net/ipv4/tcp_input.cif(skb->len)  /* We don't care if it's just an ack or
len1238net/ipv4/tcp_input.cnew_seq = skb->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
len1315net/ipv4/tcp_input.cif (skb->seq==skb1->seq && skb->len>=skb1->len)
len1539net/ipv4/tcp_input.cstatic inline void tcp_urg(struct sock *sk, struct tcphdr *th, unsigned long len)
len1559net/ipv4/tcp_input.cif (ptr < len) {
len1574net/ipv4/tcp_input.c__u32 daddr, unsigned short len,
len1606net/ipv4/tcp_input.cskb->csum = csum_partial((char *)th, len, 0);
len1608net/ipv4/tcp_input.cif (tcp_check(th, len, saddr, daddr, skb->csum))
len1618net/ipv4/tcp_input.cskb->end_seq = skb->seq + th->syn + th->fin + len - th->doff*4;
len1740net/ipv4/tcp_input.cif(!tcp_ack(sk,th,skb->ack_seq,len))
len1865net/ipv4/tcp_input.cbad_tcp_sequence(sk, th, len, opt, saddr, dev);
len1890net/ipv4/tcp_input.cif(th->ack && !tcp_ack(sk,th,skb->ack_seq,len))
len1923net/ipv4/tcp_input.ctcp_urg(sk, th, len);
len1929net/ipv4/tcp_input.cif(tcp_data(skb,sk, saddr, len))
len40net/ipv4/tcp_output.csize = skb->len - ((unsigned char *) th - skb->data);
len46net/ipv4/tcp_output.cif (size < sizeof(struct tcphdr) || size > skb->len) 
len49net/ipv4/tcp_output.cskb, skb->data, th, skb->len);
len272net/ipv4/tcp_output.csize = skb->len - (((unsigned char *) th) - skb->data);
len416net/ipv4/tcp_output.cif(dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, skb->len)<0)
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 = jiffies+len;
len138net/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);
len211net/ipv4/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
len213net/ipv4/udp.creturn(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));
len236net/ipv4/udp.cunsigned int len;
len240net/ipv4/udp.clen = fraglen;
len246net/ipv4/udp.clen = fraglen-sizeof(struct udphdr);
len250net/ipv4/udp.cufh->wcheck = csum_partial_copy_fromuser(src, dst, len, ufh->wcheck);
len256net/ipv4/udp.cntohs(ufh->uh.len),
len276net/ipv4/udp.cunsigned int len;
len280net/ipv4/udp.clen = fraglen;
len286net/ipv4/udp.clen = fraglen-sizeof(struct udphdr);
len290net/ipv4/udp.cmemcpy_fromfs(dst,src,len);
len301net/ipv4/udp.cconst unsigned char *from, int len, int rt,
len304net/ipv4/udp.cint ulen = len + sizeof(struct udphdr);
len313net/ipv4/udp.cufh.uh.len = htons(ulen);
len334net/ipv4/udp.creturn len;
len338net/ipv4/udp.cstatic int udp_sendto(struct sock *sk, const unsigned char *from, int len, int noblock,
len398net/ipv4/udp.ctmp = udp_send(sk, usin, from, len, flags, saddr, noblock);
len409net/ipv4/udp.cstatic int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len, int noblock, 
len413net/ipv4/udp.creturn udp_sendto(sk,msg->msg_iov[0].iov_base,len, noblock, flags, msg->msg_name, msg->msg_namelen);
len425net/ipv4/udp.cif(len>65515)
len427net/ipv4/udp.cbuf=kmalloc(len, GFP_KERNEL);
len430net/ipv4/udp.cmemcpy_fromiovec(buf, msg->msg_iov, len);
len433net/ipv4/udp.cerr=udp_sendto(sk,buf,len, noblock, flags, msg->msg_name, msg->msg_namelen);
len435net/ipv4/udp.ckfree_s(buf,len);
len477net/ipv4/udp.camount = skb->len-sizeof(struct udphdr);
len499net/ipv4/udp.cint udp_recvmsg(struct sock *sk, struct msghdr *msg, int len,
len524net/ipv4/udp.ctruesize = skb->len - sizeof(struct udphdr);
len525net/ipv4/udp.ccopied = min(len, truesize);
len593net/ipv4/udp.c__u32 daddr, unsigned short len,
len616net/ipv4/udp.culen = ntohs(uh->len);
len618net/ipv4/udp.cif (ulen > len || len < sizeof(*uh) || ulen < sizeof(*uh)) 
len620net/ipv4/udp.cNETDEBUG(printk("UDP: short packet: %d/%d\n", ulen, len));
len634net/ipv4/udp.c( (skb->ip_summed == CHECKSUM_HW) && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
len635net/ipv4/udp.c( (skb->ip_summed == CHECKSUM_NONE) && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
len656net/ipv4/udp.clen=ulen;
len679net/ipv4/udp.cudp_deliver(sk, uh, skb1, dev,saddr,daddr,len);
len716net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
len719net/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)
len723net/ipv4/udp.cskb_trim(skb,len);
len536net/ipx/af_ipx.cint  len;
len545net/ipx/af_ipx.clen = skb->len + out_offset;
len546net/ipx/af_ipx.cskb2 = alloc_skb(len, GFP_ATOMIC);
len549net/ipx/af_ipx.cskb2->h.raw=skb_put(skb2,skb->len);
len552net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
len1157net/ipx/af_ipx.cstatic int ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, struct iovec *iov, int len)
len1183net/ipx/af_ipx.csize=sizeof(ipx_packet)+len;
len1198net/ipx/af_ipx.cipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
len1224net/ipx/af_ipx.cmemcpy_fromiovec(skb_put(skb,len),iov,len);
len1324net/ipx/af_ipx.cint len=0;
len1330net/ipx/af_ipx.clen += sprintf (buffer,"%-11s%-15s%-9s%-11s%s\n", "Network", 
len1333net/ipx/af_ipx.clen += sprintf(buffer+len, "%08lX   ", ntohl(i->if_netnum));
len1334net/ipx/af_ipx.clen += sprintf (buffer+len,"%02X%02X%02X%02X%02X%02X   ", 
len1337net/ipx/af_ipx.clen += sprintf(buffer+len, "%-9s", (i == ipx_primary_net) ?
len1339net/ipx/af_ipx.clen += sprintf (buffer+len, "%-11s", ipx_device_name(i));
len1340net/ipx/af_ipx.clen += sprintf (buffer+len, "%s\n", 
len1344net/ipx/af_ipx.cpos=begin+len;
len1347net/ipx/af_ipx.clen=0;      /* Keep dumping into the buffer start */
len1356net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
len1357net/ipx/af_ipx.cif(len>length)
len1358net/ipx/af_ipx.clen=length;    /* Remove unwanted tail data from length */
len1360net/ipx/af_ipx.creturn len;
len1368net/ipx/af_ipx.cint len=0;
len1375net/ipx/af_ipx.clen += sprintf (buffer,"%-28s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
len1377net/ipx/af_ipx.clen += sprintf (buffer,"%-15s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
len1384net/ipx/af_ipx.clen += sprintf(buffer+len,
len1392net/ipx/af_ipx.clen += sprintf(buffer+len,"%08lX:%04X  ", 
len1397net/ipx/af_ipx.clen += sprintf(buffer+len, "%-28s", "Not_Connected");
len1399net/ipx/af_ipx.clen += sprintf (buffer+len,
len1407net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX  %08lX  ", 
len1409net/ipx/af_ipx.clen += sprintf (buffer+len,"%02X     %03d\n", 
len1413net/ipx/af_ipx.cpos=begin+len;
len1417net/ipx/af_ipx.clen=0;      /* Keep dumping into the buffer start */
len1427net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
len1428net/ipx/af_ipx.cif(len>length)
len1429net/ipx/af_ipx.clen=length;    /* Remove unwanted tail data from length */
len1431net/ipx/af_ipx.creturn len;
len1438net/ipx/af_ipx.cint len=0;
len1442net/ipx/af_ipx.clen += sprintf (buffer,"%-11s%-13s%s\n", 
len1446net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX   ", ntohl(rt->ir_net));
len1448net/ipx/af_ipx.clen += sprintf (buffer+len,"%08lX     %02X%02X%02X%02X%02X%02X\n", 
len1454net/ipx/af_ipx.clen += sprintf (buffer+len, "%-13s%s\n",
len1457net/ipx/af_ipx.cpos=begin+len;
len1460net/ipx/af_ipx.clen=0;
len1467net/ipx/af_ipx.clen-=(offset-begin);
len1468net/ipx/af_ipx.cif(len>length)
len1469net/ipx/af_ipx.clen=length;
len1470net/ipx/af_ipx.creturn len;
len1574net/ipx/af_ipx.cstatic void def_callback2(struct sock *sk, int len)
len1870net/ipx/af_ipx.cvoid dump_data(char *str,unsigned char *d, int len) {
len1874net/ipx/af_ipx.cfor (l=0;len > 0 && l<16;l++) {
len1876net/ipx/af_ipx.cfor (i=0; i < 8 ; i++, --len) {
len1877net/ipx/af_ipx.cif (len > 0) {
len1889net/ipx/af_ipx.clen += 8;
len1890net/ipx/af_ipx.cfor (i=0; i < 8 ; i++, --len)
len1891net/ipx/af_ipx.cif (len > 0)
len1916net/ipx/af_ipx.cint len = ntohs(p->ipx_pktsize);
len1918net/ipx/af_ipx.cif (len > 30)
len1919net/ipx/af_ipx.cdump_data(str,(unsigned char *)p + 30, len - 30);
len1963net/ipx/af_ipx.cstatic int ipx_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock,
len2009net/ipx/af_ipx.cretval = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len);
len2012net/ipx/af_ipx.creturn len;
len2092net/ipx/af_ipx.camount=skb->len-sizeof(struct ipx_packet);
len103net/netlink.crdq_size[minor]-=skb->len;
len105net/netlink.cif(skb->len<count)
len106net/netlink.ccount=skb->len;
len202net/netlink.cif(rdq_size[unit]+skb->len>MAX_QBYTES)
len207net/netlink.crdq_size[unit]+=skb->len;
len404net/netrom/af_netrom.cstatic void def_callback2(struct sock *sk, int len)
len936net/netrom/af_netrom.cif ((frametype & 0x0F) == NR_CONNACK && skb->len == 22)
len979net/netrom/af_netrom.cif (skb->len == 37) {
len1006net/netrom/af_netrom.csk->data_ready(sk, skb->len);
len1011net/netrom/af_netrom.cstatic int nr_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock, int flags)
len1055net/netrom/af_netrom.csize = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
len1064net/netrom/af_netrom.cskb_reserve(skb, size - len);
len1090net/netrom/af_netrom.cskb->h.raw = skb_put(skb, len);
len1098net/netrom/af_netrom.cmemcpy_fromiovec(asmptr, msg->msg_iov, len);
len1110net/netrom/af_netrom.creturn len;
len1145net/netrom/af_netrom.ccopied = (size < skb->len) ? size : skb->len;
len1197net/netrom/af_netrom.camount = skb->len - 20;
len1269net/netrom/af_netrom.cint len = 0;
len1275net/netrom/af_netrom.clen += sprintf(buffer, "user_addr dest_node src_node  dev    my  your  st vs vr va    t1     t2    n2  rtt wnd Snd-Q Rcv-Q\n");
len1283net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s ",
len1285net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s ",
len1287net/netrom/af_netrom.clen += sprintf(buffer + len, "%-9s %-3s  %02X/%02X %02X/%02X %2d %2d %2d %2d %3d/%03d %2d/%02d %2d/%02d %3d %3d %5ld %5ld\n",
len1302net/netrom/af_netrom.cpos = begin + len;
len1305net/netrom/af_netrom.clen   = 0;
len1316net/netrom/af_netrom.clen   -= (offset - begin);
len1318net/netrom/af_netrom.cif (len > length) len = length;
len1320net/netrom/af_netrom.creturn(len);
len77net/netrom/nr_dev.cvoid *daddr, void *saddr, unsigned len)
len58net/netrom/nr_in.csk->nr->fraglen += skb->len;
len64net/netrom/nr_in.csk->nr->fraglen += skb->len;
len77net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
len82net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
len53net/netrom/nr_out.cint err, frontlen, len, mtu;
len57net/netrom/nr_out.cif (skb->len - NR_TRANSPORT_LEN > mtu) {
len64net/netrom/nr_out.cwhile (skb->len > 0) {
len74net/netrom/nr_out.clen = (mtu > skb->len) ? skb->len : mtu;
len77net/netrom/nr_out.cmemcpy(skb_put(skbn, len), skb->data, len);
len78net/netrom/nr_out.cskb_pull(skb, len);
len84net/netrom/nr_out.cif (skb->len > 0)
len716net/netrom/nr_route.cint len     = 0;
len723net/netrom/nr_route.clen += sprintf(buffer, "callsign  mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
len726net/netrom/nr_route.clen += sprintf(buffer + len, "%-9s %-7s  %d %d",
len733net/netrom/nr_route.clen += sprintf(buffer + len, "  %3d   %d %05d",
len739net/netrom/nr_route.clen += sprintf(buffer + len, "\n");
len741net/netrom/nr_route.cpos = begin + len;
len744net/netrom/nr_route.clen   = 0;
len755net/netrom/nr_route.clen   -= (offset - begin);
len757net/netrom/nr_route.cif (len > length) len = length;
len759net/netrom/nr_route.creturn(len);
len766net/netrom/nr_route.cint len     = 0;
len772net/netrom/nr_route.clen += sprintf(buffer, "addr  callsign  dev  qual lock count\n");
len775net/netrom/nr_route.clen += sprintf(buffer + len, "%05d %-9s %-4s  %3d    %d   %3d\n",
len783net/netrom/nr_route.cpos = begin + len;
len786net/netrom/nr_route.clen   = 0;
len797net/netrom/nr_route.clen   -= (offset - begin);
len799net/netrom/nr_route.cif (len > length) len = length;
len801net/netrom/nr_route.creturn(len);
len155net/netrom/nr_subr.cint len, timeout;
len157net/netrom/nr_subr.clen = AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
len161net/netrom/nr_subr.clen += 17;
len164net/netrom/nr_subr.clen += (sk->nr->bpqext) ? 2 : 1;
len175net/netrom/nr_subr.cif ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
len250net/netrom/nr_subr.cint len;
len252net/netrom/nr_subr.clen = AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN + 1;
len254net/netrom/nr_subr.cif ((skbn = alloc_skb(len, GFP_ATOMIC)) == NULL)
len138net/socket.cint len;
len143net/socket.clen=get_user(ulen);
len144net/socket.cif(len>klen)
len145net/socket.clen=klen;
len146net/socket.cif(len<0 || len> MAX_SOCK_ADDR)
len148net/socket.cif(len)
len150net/socket.cif((err=verify_area(VERIFY_WRITE,uaddr,len))<0)
len152net/socket.cmemcpy_tofs(uaddr,kaddr,len);
len154net/socket.cput_user(len,ulen);
len707net/socket.cint len;
len751net/socket.cnewsock->ops->getname(newsock, (struct sockaddr *)address, &len, 1);
len752net/socket.cmove_addr_to_user(address,len, upeer_sockaddr, upeer_addrlen);
len818net/socket.cint len;
len826net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
len829net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len843net/socket.cint len;
len851net/socket.cerr=sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
len854net/socket.cif((err=move_addr_to_user(address,len, usockaddr, usockaddr_len))<0)
len864net/socket.casmlinkage int sys_send(int fd, void * buff, int len, unsigned flags)
len877net/socket.cif(len<0)
len879net/socket.cerr=verify_area(VERIFY_READ, buff, len);
len884net/socket.ciov.iov_len=len;
len889net/socket.creturn(sock->ops->sendmsg(sock, &msg, len, (file->f_flags & O_NONBLOCK), flags));
len898net/socket.casmlinkage int sys_sendto(int fd, void * buff, int len, unsigned flags,
len913net/socket.cif(len<0)
len915net/socket.cerr=verify_area(VERIFY_READ,buff,len);
len923net/socket.ciov.iov_len=len;
len929net/socket.creturn(sock->ops->sendmsg(sock, &msg, len, (file->f_flags & O_NONBLOCK),
len1128net/socket.cint len;
len1148net/socket.clen=sock->ops->recvmsg(sock, &msg_sys, total_len, (file->f_flags&O_NONBLOCK), flags, &addr_len);
len1149net/socket.cif(len<0)
len1150net/socket.creturn len;
len1156net/socket.creturn len;
len1390net/socket.cint len = sprintf(buffer, "sockets: used %d\n", sockets_in_use);
len1391net/socket.cif (offset >= len)
len1397net/socket.clen -= offset;
len1398net/socket.cif (len > length)
len1399net/socket.clen = length;
len1400net/socket.creturn len;
len74net/unix/af_unix.cstatic inline void unix_mkname(struct sockaddr_un * sunaddr, unsigned long len)
len76net/unix/af_unix.cif (len >= sizeof(*sunaddr))
len77net/unix/af_unix.clen = sizeof(*sunaddr)-1;
len78net/unix/af_unix.c((char *)sunaddr)[len]=0;
len253net/unix/af_unix.cstatic void def_callback2(struct sock *sk, int len)
len683net/unix/af_unix.cstatic int unix_sendmsg(struct socket *sock, struct msghdr *msg, int len, int nonblock, int flags)
len742net/unix/af_unix.cwhile(sent < len)
len749net/unix/af_unix.csize=len-sent;
len889net/unix/af_unix.cint len;
len909net/unix/af_unix.clen=iov->iov_len;
len912net/unix/af_unix.cwhile(done<len)
len948net/unix/af_unix.cnum=min(skb->len,size-copied);
len963net/unix/af_unix.cif (skb->len) {
len1036net/unix/af_unix.camount=skb->len;
len1054net/unix/af_unix.cint len=0;
len1057net/unix/af_unix.clen+= sprintf(buffer,"Num       RefCount Protocol Flags    Type St Path\n");
len1061net/unix/af_unix.clen+=sprintf(buffer+len,"%p: %08X %08X %08lX %04X %02X",
len1069net/unix/af_unix.clen+=sprintf(buffer+len, " %s\n", s->protinfo.af_unix.name);
len1071net/unix/af_unix.cbuffer[len++]='\n';
len1073net/unix/af_unix.cpos=begin+len;
len1076net/unix/af_unix.clen=0;
len1084net/unix/af_unix.clen-=(offset-begin);
len1085net/unix/af_unix.cif(len>length)
len1086net/unix/af_unix.clen=length;
len1087net/unix/af_unix.creturn len;