taglinefilesource code
count172arch/alpha/boot/main.cstatic inline long load(long dev, unsigned long addr, unsigned long count)
count184arch/alpha/boot/main.creturn dispatch(CCB_READ, dev, count, addr, BOOT_SIZE/512 + 1);
count157arch/alpha/boot/tools/build.cunsigned long count = (system_start + system_size) - start;
count159arch/alpha/boot/tools/build.cwhile (count > 0) {
count161arch/alpha/boot/tools/build.cif (i > count)
count162arch/alpha/boot/tools/build.ci = count;
count168arch/alpha/boot/tools/build.ccount -= i;
count67arch/alpha/kernel/osf_sys.cint count;
count78arch/alpha/kernel/osf_sys.cif (reclen > buf->count)
count92arch/alpha/kernel/osf_sys.cbuf->count -= reclen;
count97arch/alpha/kernel/osf_sys.cunsigned int count, long *basep)
count107arch/alpha/kernel/osf_sys.cerror = verify_area(VERIFY_WRITE, dirent, count);
count117arch/alpha/kernel/osf_sys.cbuf.count = count;
count122arch/alpha/kernel/osf_sys.cif (count == buf.count)
count124arch/alpha/kernel/osf_sys.creturn count - buf.count;
count144arch/alpha/kernel/setup.cunsigned long count, va, pc;
count185arch/alpha/kernel/setup.cunaligned[0].count, unaligned[0].pc, unaligned[0].va,
count186arch/alpha/kernel/setup.cunaligned[1].count, unaligned[1].pc, unaligned[1].va);
count141arch/alpha/kernel/traps.cunsigned long count, va, pc;
count160arch/alpha/kernel/traps.c++unaligned[0].count;
count221arch/alpha/kernel/traps.c++unaligned[1].count;
count49arch/alpha/lib/checksum.cint odd, count;
count60arch/alpha/lib/checksum.ccount = len >> 1;    /* nr of 16-bit words.. */
count61arch/alpha/lib/checksum.cif (count) {
count64arch/alpha/lib/checksum.ccount--;
count68arch/alpha/lib/checksum.ccount >>= 1;    /* nr of 32-bit words.. */
count69arch/alpha/lib/checksum.cif (count) {
count72arch/alpha/lib/checksum.ccount--;
count76arch/alpha/lib/checksum.ccount >>= 1;  /* nr of 64-bit words.. */
count77arch/alpha/lib/checksum.cif (count) {
count81arch/alpha/lib/checksum.ccount--;
count86arch/alpha/lib/checksum.c} while (count);
count93arch/alpha/lib/io.cvoid insb (unsigned long port, void *dst, unsigned long count)
count96arch/alpha/lib/io.cif (!count)
count98arch/alpha/lib/io.ccount--;
count103arch/alpha/lib/io.cwhile (count >= 4) {
count105arch/alpha/lib/io.ccount -= 4;
count114arch/alpha/lib/io.cwhile (count) {
count115arch/alpha/lib/io.c--count;
count129arch/alpha/lib/io.cvoid insw (unsigned long port, void *dst, unsigned long count)
count135arch/alpha/lib/io.cif (!count)
count137arch/alpha/lib/io.ccount--;
count142arch/alpha/lib/io.cwhile (count >= 2) {
count144arch/alpha/lib/io.ccount -= 2;
count151arch/alpha/lib/io.cif (count) {
count164arch/alpha/lib/io.cvoid insl (unsigned long port, void *dst, unsigned long count)
count170arch/alpha/lib/io.cwhile (count) {
count171arch/alpha/lib/io.c--count;
count183arch/alpha/lib/io.cvoid outsb(unsigned long port, const void * src, unsigned long count)
count185arch/alpha/lib/io.cwhile (count) {
count186arch/alpha/lib/io.ccount--;
count198arch/alpha/lib/io.cvoid outsw (unsigned long port, const void *src, unsigned long count)
count206arch/alpha/lib/io.c--count;
count209arch/alpha/lib/io.cwhile (count >= 2) {
count211arch/alpha/lib/io.ccount -= 2;
count218arch/alpha/lib/io.cif (count) {
count230arch/alpha/lib/io.cvoid outsl (unsigned long port, const void *src, unsigned long count)
count236arch/alpha/lib/io.cwhile (count) {
count237arch/alpha/lib/io.c--count;
count248arch/alpha/lib/io.cvoid _memcpy_fromio(void * to, unsigned long from, unsigned long count)
count250arch/alpha/lib/io.cwhile (count) {
count251arch/alpha/lib/io.ccount--;
count262arch/alpha/lib/io.cvoid _memcpy_toio(unsigned long to, void * from, unsigned long count)
count264arch/alpha/lib/io.cwhile (count) {
count265arch/alpha/lib/io.ccount--;
count276arch/alpha/lib/io.cvoid _memset_io(unsigned long dst, int c, unsigned long count)
count278arch/alpha/lib/io.cwhile (count) {
count279arch/alpha/lib/io.ccount--;
count13arch/alpha/lib/memset.cinline void * __constant_c_memset(void * s, unsigned long c, long count)
count21arch/alpha/lib/memset.cwhile (count > 0 && (xs & 7)) {
count23arch/alpha/lib/memset.ccount--; xs++;
count25arch/alpha/lib/memset.cwhile (count > 7) {
count27arch/alpha/lib/memset.ccount -=8; xs += 8;
count29arch/alpha/lib/memset.cwhile (count > 0) {
count31arch/alpha/lib/memset.ccount--; xs++;
count36arch/alpha/lib/memset.cvoid * __memset(void * s,char c,size_t count)
count38arch/alpha/lib/memset.c__constant_c_memset(s,0x0101010101010101UL * (unsigned char) c, count);
count72arch/alpha/mm/init.celse if (!mem_map[i].count)
count75arch/alpha/mm/init.cshared += mem_map[i].count-1;
count172arch/alpha/mm/init.cmem_map[MAP_NR(tmp)].count = 1;
count193arch/alpha/mm/init.cif (!mem_map[i].count)
count195arch/alpha/mm/init.cval->sharedram += mem_map[i].count-1;
count8arch/i386/kernel/hexify.cint count=0;
count16arch/i386/kernel/hexify.cif(count==8)
count18arch/i386/kernel/hexify.ccount=0;
count21arch/i386/kernel/hexify.cif(count==0)
count24arch/i386/kernel/hexify.ccount++;
count26arch/i386/kernel/hexify.cif(count)
count111arch/i386/kernel/smp.cint count=sizeof(*mpc);
count113arch/i386/kernel/smp.cunsigned char *mpt=((unsigned char *)mpc)+count;
count146arch/i386/kernel/smp.cwhile(count<mpc->mpc_length)
count186arch/i386/kernel/smp.ccount+=sizeof(*m);
count199arch/i386/kernel/smp.ccount+=sizeof(*m);
count215arch/i386/kernel/smp.ccount+=sizeof(*m); 
count224arch/i386/kernel/smp.ccount+=sizeof(*m);
count232arch/i386/kernel/smp.ccount+=sizeof(*m);
count119arch/i386/kernel/time.cint count;
count124arch/i386/kernel/time.ccount = inb_p(0x40);  /* read the latched count */
count125arch/i386/kernel/time.ccount |= inb(0x40) << 8;
count127arch/i386/kernel/time.cif (count > (LATCH - LATCH/100)) {
count133arch/i386/kernel/time.ccount = ((LATCH-1) - count) * TICK_SIZE;
count134arch/i386/kernel/time.ccount = (count + LATCH/2) / LATCH;
count135arch/i386/kernel/time.creturn offset + count;
count85arch/i386/mm/init.celse if (!mem_map[i].count)
count88arch/i386/mm/init.cshared += mem_map[i].count-1;
count248arch/i386/mm/init.cmem_map[MAP_NR(tmp)].count = 1;
count284arch/i386/mm/init.cif (!mem_map[i].count)
count286arch/i386/mm/init.cval->sharedram += mem_map[i].count-1;
count140arch/ppc/mm/init.celse if (!mem_map[i].count)
count143arch/ppc/mm/init.cshared += mem_map[i].count-1;
count253arch/ppc/mm/init.cmem_map[MAP_NR(tmp)].count = 1;
count230arch/sparc/kernel/sparc-stub.cint count;
count240arch/sparc/kernel/sparc-stub.ccount = 0;
count243arch/sparc/kernel/sparc-stub.cwhile (count < BUFMAX) {
count248arch/sparc/kernel/sparc-stub.cbuffer[count] = ch;
count249arch/sparc/kernel/sparc-stub.ccount = count + 1;
count252arch/sparc/kernel/sparc-stub.cif (count >= BUFMAX)
count255arch/sparc/kernel/sparc-stub.cbuffer[count] = 0;
count269arch/sparc/kernel/sparc-stub.ccount = strlen(buffer);
count270arch/sparc/kernel/sparc-stub.cfor (i=3; i <= count; i++)
count284arch/sparc/kernel/sparc-stub.cint count;
count291arch/sparc/kernel/sparc-stub.ccount = 0;
count293arch/sparc/kernel/sparc-stub.cwhile ((ch = buffer[count])) {
count296arch/sparc/kernel/sparc-stub.ccount += 1;
count315arch/sparc/kernel/sparc-stub.cmem2hex(char *mem, char *buf, int count)
count319arch/sparc/kernel/sparc-stub.cwhile (count-- > 0) {
count333arch/sparc/kernel/sparc-stub.chex2mem(char *buf, char *mem, int count)
count338arch/sparc/kernel/sparc-stub.cfor (i=0; i<count; i++) {
count339arch/sparc/kernel/sys_sunos.cint count;
count354arch/sparc/kernel/sys_sunos.cif (reclen > buf->count)
count368arch/sparc/kernel/sys_sunos.cbuf->count -= reclen;
count390arch/sparc/kernel/sys_sunos.cbuf.count = cnt;
count399arch/sparc/kernel/sys_sunos.creturn cnt - buf.count;
count74arch/sparc/mm/init.celse if (!mem_map[i].count)
count77arch/sparc/mm/init.cshared += mem_map[i].count-1;
count181arch/sparc/mm/init.cmem_map[MAP_NR(addr)].count = 1;
count223arch/sparc/mm/init.cif (!mem_map[i].count)
count225arch/sparc/mm/init.cval->sharedram += mem_map[i].count-1;
count59arch/sparc/mm/srmmu.cint srmmu_pte_inuse(pte_t *ptep)        { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
count64arch/sparc/mm/srmmu.cmem_map[MAP_NR(ptep)].count++;
count75arch/sparc/mm/srmmu.cint srmmu_pmd_inuse(pmd_t *pmdp)        { return mem_map[MAP_NR(pmdp)].reserved || mem_map[MAP_NR(pmdp)].count != 1; }
count80arch/sparc/mm/srmmu.cmem_map[MAP_NR(pmdp)].count++;
count95arch/sparc/mm/srmmu.cmem_map[MAP_NR(pgdp)].count++;
count68arch/sparc/mm/sun4c.cint sun4c_pte_inuse(pte_t *ptep)        { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
count73arch/sparc/mm/sun4c.cmem_map[MAP_NR(ptep)].count++;
count1973drivers/block/floppy.cint count,head_shift,track_shift;
count2008drivers/block/floppy.cfor (count = 0; count < F_SECT_PER_TRACK; ++count) {
count2009drivers/block/floppy.chere[count].track = format_req.track;
count2010drivers/block/floppy.chere[count].head = format_req.head;
count2011drivers/block/floppy.chere[count].sect = 0;
count2012drivers/block/floppy.chere[count].size = F_SIZECODE;
count2015drivers/block/floppy.cfor (count = 1; count <= F_SECT_PER_TRACK; ++count) {
count2016drivers/block/floppy.chere[n].sect = count;
count3363drivers/block/floppy.cchar * buf, int count)
count3370drivers/block/floppy.creturn block_read(inode, filp, buf, count);
count3374drivers/block/floppy.cconst char * buf, int count)
count3387drivers/block/floppy.cblock = (filp->f_pos + count) >> 9;
count3389drivers/block/floppy.cret= block_write(inode, filp, buf, count);
count301drivers/block/ll_rw_blk.cunsigned int sector, count;
count320drivers/block/ll_rw_blk.ccount = bh->b_size >> 9;
count321drivers/block/ll_rw_blk.csector = bh->b_blocknr * count;
count323drivers/block/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
count375drivers/block/ll_rw_blk.creq->nr_sectors += count;
count384drivers/block/ll_rw_blk.creq->sector - count == sector &&
count387drivers/block/ll_rw_blk.creq->nr_sectors += count;
count390drivers/block/ll_rw_blk.creq->current_nr_sectors = count;
count419drivers/block/ll_rw_blk.creq->nr_sectors = count;
count420drivers/block/ll_rw_blk.creq->current_nr_sectors = count;
count163drivers/block/triton.cunsigned int count = 0;
count192drivers/block/triton.cif (++count >= PRD_ENTRIES) {
count206drivers/block/triton.cif (count) {
count212drivers/block/xd.cu_int block,count,retry;
count223drivers/block/xd.ccount = CURRENT->nr_sectors;
count229drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
count334drivers/block/xd.cstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count)
count341drivers/block/xd.cprintk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
count345drivers/block/xd.cwhile (count) {
count346drivers/block/xd.ctemp = count < xd_maxsectors ? count : xd_maxsectors;
count378drivers/block/xd.ccount -= temp, buffer += temp * 0x200, block += temp;
count408drivers/block/xd.cstatic u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
count410drivers/block/xd.cif (buffer < ((u_char *) 0x1000000 - count)) {    /* transfer to address < 16M? */
count411drivers/block/xd.cif (((u_int) buffer & 0xFFFF0000) != (((u_int) buffer + count) & 0xFFFF0000)) {
count421drivers/block/xd.cset_dma_count(xd_dma,count);
count432drivers/block/xd.cstatic u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control)
count438drivers/block/xd.ccmdblk[4] = count;
count521drivers/block/xd.cu_char cmdblk[6],i,count = 0;
count526drivers/block/xd.cinit_drive(count);
count527drivers/block/xd.ccount++;
count530drivers/block/xd.creturn (count);
count1524drivers/cdrom/aztcd.c{       long int count, max_count;
count1552drivers/cdrom/aztcd.cfor (count=0;count<10000;count++);          /*delay a bit*/       
count1583drivers/cdrom/aztcd.cfor (count=0;count<50;count++)
count1597drivers/cdrom/aztcd.cfor (count = 0; count < AZT_TIMEOUT; count++); 
count1598drivers/cdrom/aztcd.c{ count=count*2;          /* delay a bit */
count1599drivers/cdrom/aztcd.ccount=count/2;
count1619drivers/cdrom/aztcd.cfor (count=1;count<50;count++)   /*Reading version string*/
count1626drivers/cdrom/aztcd.cresult[count]=inb(DATA_PORT);
count1628drivers/cdrom/aztcd.cif (count>30) max_count=30;  /*print max.30 chars of the version string*/
count1629drivers/cdrom/aztcd.celse          max_count=count;
count1631drivers/cdrom/aztcd.cfor (count=1;count<max_count;count++) printk("%c",result[count]);
count1649drivers/cdrom/aztcd.cfor (count=1;count<5;count++) printk("%c",result[count]);
count700drivers/cdrom/gscd.cstatic void cmd_info_in ( char *pb, int count )
count715drivers/cdrom/gscd.cif ( count > 0 )
count719drivers/cdrom/gscd.ccount--;
count734drivers/cdrom/gscd.cstatic void cmd_read_b ( char *pb, int count, int size )
count768drivers/cdrom/gscd.ccount--;
count769drivers/cdrom/gscd.c} while ( count > 0 );
count811drivers/cdrom/gscd.cstatic void cmd_read_w ( char *pb, int count, int size )
count841drivers/cdrom/gscd.ccount--;
count842drivers/cdrom/gscd.c} while ( count > 0 );
count945drivers/cdrom/mcd.cint count= QUICK_LOOP_COUNT;
count946drivers/cdrom/mcd.cwhile (count--) {
count951drivers/cdrom/mcd.cprintk(" %d ",QUICK_LOOP_COUNT-count);
count1165drivers/cdrom/mcd.cint count;
count1194drivers/cdrom/mcd.cfor (count = 0; count < 2000000; count++)
count1198drivers/cdrom/mcd.cfor (count = 0; count < 2000000; count++)
count1202drivers/cdrom/mcd.cif (count >= 2000000) {
count1207drivers/cdrom/mcd.ccount = inb(MCDPORT(0));    /* pick up the status */
count1210drivers/cdrom/mcd.cfor(count=0;count<3;count++)
count1211drivers/cdrom/mcd.cif(getValue(result+count)) {
count1400drivers/cdrom/mcd.cint count;
count1403drivers/cdrom/mcd.cfor (count = 0; count < 2000; count++)
count1407drivers/cdrom/mcd.cif (count >= 2000)
count134drivers/cdrom/optcd.cunsigned long count = 0;
count136drivers/cdrom/optcd.cif (++count >= BUSY_TIMEOUT)
count142drivers/cdrom/optcd.cprintk("optcd: STEN low after %ld\n", count);
count150drivers/cdrom/optcd.cunsigned long count = 0;
count152drivers/cdrom/optcd.cif (++count >= BUSY_TIMEOUT)
count158drivers/cdrom/optcd.cprintk("optcd: DTEN low after %ld\n", count);
count334drivers/cdrom/optcd.cunsigned long count = 0;
count340drivers/cdrom/optcd.cwhile (++count < RESET_WAIT)
count342drivers/cdrom/optcd.ccount = 0;
count344drivers/cdrom/optcd.cif (++count >= BUSY_TIMEOUT)
count571drivers/cdrom/optcd.cint st, count, px, limit;
count577drivers/cdrom/optcd.cfor (count = 0; count < MAX_TRACKS; count++)
count578drivers/cdrom/optcd.cToc[count].pointIndex = 0;
count582drivers/cdrom/optcd.ccount = DiskInfo.last + 3;
count583drivers/cdrom/optcd.cfor (limit = 300; (limit > 0) && (count > 0); limit--) {
count590drivers/cdrom/optcd.ccount--;
count621drivers/cdrom/optcd.creturn count ? -ERR_TOC_MISSINGENTRY : 0;
count1346drivers/cdrom/optcd.cint count, i, ch;
count1350drivers/cdrom/optcd.cif ((count = optGetData()) < 0)
count1352drivers/cdrom/optcd.cfor (i = 0, ch = -1; count > 0; count--) {
count2488drivers/cdrom/sbpcd.cfor (count=D_S[d].first_session;count<zwanzig;count++)
count2493drivers/cdrom/sbpcd.cdrvcmd[3]=count;
count2498drivers/cdrom/sbpcd.cD_S[d].msf_multi_n[count]=make32(make16(0,infobuf[5]),make16(infobuf[6],infobuf[7]));
count2825drivers/cdrom/sbpcd.cstatic int cc_SubChanInfo(int frame, int count, u_char *buffer)
count2843drivers/cdrom/sbpcd.cdrvcmd[5]=(count>>8)&0xFF;
count2844drivers/cdrom/sbpcd.cdrvcmd[6]=count&0xFF;
count137drivers/char/atixlmouse.cstatic int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
count142drivers/char/atixlmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count146drivers/char/atixlmouse.cif (count < 3)
count163drivers/char/atixlmouse.cfor(i = 3; i < count; i++)
count157drivers/char/busmouse.cstatic int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
count166drivers/char/busmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count173drivers/char/busmouse.cif (count < 3)
count175drivers/char/busmouse.cif ((r = verify_area(VERIFY_WRITE, buffer, count)))
count207drivers/char/busmouse.cfor (r = 3; r < count; r++)
count526drivers/char/console.cint count ;
count533drivers/char/console.ccount = (video_num_lines-1)*video_num_columns;
count534drivers/char/console.cwhile (count) {
count535drivers/char/console.ccount--;
count594drivers/char/console.cunsigned int count;
count596drivers/char/console.ccount = (video_num_lines-1)*video_num_columns;
count597drivers/char/console.cwhile (count) {
count598drivers/char/console.ccount--;
count601drivers/char/console.ccount = video_num_columns;
count602drivers/char/console.cwhile (count) {
count603drivers/char/console.ccount--;
count614drivers/char/console.cunsigned int count;
count617drivers/char/console.ccount = video_num_columns;
count618drivers/char/console.cwhile (count) {
count619drivers/char/console.ccount--;
count629drivers/char/console.cunsigned int count = (b-t-1) * video_num_columns;
count631drivers/char/console.cwhile (count) {
count632drivers/char/console.ccount--;
count635drivers/char/console.ccount = video_num_columns;
count636drivers/char/console.cwhile (count) {
count637drivers/char/console.ccount--;
count647drivers/char/console.cunsigned int count;
count653drivers/char/console.ccount = (b-t-1)*video_num_columns;
count654drivers/char/console.cwhile (count) {
count655drivers/char/console.ccount--;
count658drivers/char/console.ccount = video_num_columns;
count659drivers/char/console.cwhile (count) {
count660drivers/char/console.ccount--;
count716drivers/char/console.cunsigned long count;
count721drivers/char/console.ccount = (scr_end-pos)>>1;
count725drivers/char/console.ccount = ((pos-origin)>>1)+1;
count729drivers/char/console.ccount = video_num_columns * video_num_lines;
count735drivers/char/console.cwhile (count) {
count736drivers/char/console.ccount--;
count744drivers/char/console.cunsigned long count;
count749drivers/char/console.ccount = video_num_columns-x;
count754drivers/char/console.ccount = x+1;
count758drivers/char/console.ccount = video_num_columns;
count763drivers/char/console.cwhile (count) {
count764drivers/char/console.ccount--;
count772drivers/char/console.cunsigned long count;
count779drivers/char/console.ccount = (vpar > video_num_columns-x) ? (video_num_columns-x) : vpar;
count781drivers/char/console.cwhile (count) {
count782drivers/char/console.ccount--;
count972drivers/char/console.cvoid invert_screen(int currcons, int offset, int count, int viewed)
count976drivers/char/console.ccount /= 2;
count979drivers/char/console.cwhile (count--) {
count985drivers/char/console.cwhile (count--) {
count1358drivers/char/console.cconst unsigned char *buf, int count)
count1379drivers/char/console.cwhile (!tty->stopped &&  count) {
count1381drivers/char/console.cbuf++; n++; count--;
count715drivers/char/cyclades.cif (tty->flip.count < TTY_FLIPBUF_SIZE){
count716drivers/char/cyclades.ctty->flip.count++;
count744drivers/char/cyclades.cif(tty->flip.count < TTY_FLIPBUF_SIZE){
count745drivers/char/cyclades.ctty->flip.count++;
count779drivers/char/cyclades.cif (tty->flip.count >= TTY_FLIPBUF_SIZE){
count782drivers/char/cyclades.ctty->flip.count++;
count1612drivers/char/cyclades.cconst unsigned char *buf, int count)
count1632drivers/char/cyclades.cc = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
count1652drivers/char/cyclades.ccount -= c;
count2325drivers/char/cyclades.cprintk("cy_close ttyC%d, count = %d\n", info->line, info->count);
count2336drivers/char/cyclades.cif ((tty->count == 1) && (info->count != 1)) {
count2345drivers/char/cyclades.c"info->count is %d\n", info->count);
count2346drivers/char/cyclades.cinfo->count = 1;
count2349drivers/char/cyclades.cprintk("cyc: %d(%d): decrementing count to %d\n", __LINE__, current->pid, info->count - 1);
count2351drivers/char/cyclades.cif (--info->count < 0) {
count2355drivers/char/cyclades.cinfo->count = 0;
count2357drivers/char/cyclades.cif (info->count)
count2419drivers/char/cyclades.cinfo->count = 0;
count2505drivers/char/cyclades.cinfo->line, info->count);/**/
count2507drivers/char/cyclades.cinfo->count--;
count2509drivers/char/cyclades.cprintk("cyc: %d(%d): decrementing count to %d\n", __LINE__, current->pid, info->count);
count2560drivers/char/cyclades.cinfo->line, info->count);/**/
count2567drivers/char/cyclades.cinfo->count++;
count2569drivers/char/cyclades.cprintk("cyc: %d(%d): incrementing count to %d\n", __LINE__, current->pid, info->count);
count2575drivers/char/cyclades.cinfo->line, info->count);/**/
count2609drivers/char/cyclades.cprintk("cy_open ttyC%d, count = %d\n", info->line, info->count);/**/
count2611drivers/char/cyclades.cinfo->count++;
count2613drivers/char/cyclades.cprintk("cyc: %d(%d): incrementing count to %d\n", __LINE__, current->pid, info->count);
count2625drivers/char/cyclades.cif ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
count2885drivers/char/cyclades.cinfo->count = 0;
count3150drivers/char/cyclades.cinfo->close_delay, info->event, info->count);
count584drivers/char/istallion.cstatic int  stli_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count);
count603drivers/char/istallion.cstatic int  stli_memread(struct inode *ip, struct file *fp, char *buf, int count);
count604drivers/char/istallion.cstatic int  stli_memwrite(struct inode *ip, struct file *fp, const char *buf, int count);
count1379drivers/char/istallion.cstatic int stli_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
count1391drivers/char/istallion.cprintk("stli_write(tty=%x,from_user=%d,buf=%x,count=%d)\n", (int) tty, from_user, (int) buf, count);
count1427drivers/char/istallion.ccount = MIN(len, count);
count1431drivers/char/istallion.cmemcpy_fromfs(stli_tmpwritebuf, chbuf, count);
count1457drivers/char/istallion.clen = MIN(len, count);
count1458drivers/char/istallion.ccount = 0;
count1466drivers/char/istallion.ccount += stlen;
count1489drivers/char/istallion.creturn(count);
count1537drivers/char/istallion.cunsigned int    len, stlen, head, tail, size, count, cooksize;
count1586drivers/char/istallion.ccount = 0;
count1595drivers/char/istallion.ccount += stlen;
count2275drivers/char/istallion.clen = MIN(len, (TTY_FLIPBUF_SIZE - tty->flip.count));
count2284drivers/char/istallion.ctty->flip.count += stlen;
count2460drivers/char/istallion.cif (tty->flip.count < TTY_FLIPBUF_SIZE) {
count2461drivers/char/istallion.ctty->flip.count++;
count3832drivers/char/istallion.cstatic int stli_memread(struct inode *ip, struct file *fp, char *buf, int count)
count3840drivers/char/istallion.cprintk("stli_memread(ip=%x,fp=%x,buf=%x,count=%d)\n", (int) ip, (int) fp, (int) buf, count);
count3852drivers/char/istallion.csize = MIN(count, (brdp->memsize - fp->f_pos));
count3868drivers/char/istallion.creturn(count);
count3879drivers/char/istallion.cstatic int stli_memwrite(struct inode *ip, struct file *fp, const char *buf, int count)
count3888drivers/char/istallion.cprintk("stli_memwrite(ip=%x,fp=%x,buf=%x,count=%x)\n", (int) ip, (int) fp, (int) buf, count);
count3901drivers/char/istallion.csize = MIN(count, (brdp->memsize - fp->f_pos));
count3917drivers/char/istallion.creturn(count);
count69drivers/char/lp.cunsigned long count  = 0;
count74drivers/char/lp.ccount ++;
count77drivers/char/lp.c} while(!LP_READY(minor,status) && count < LP_CHAR(minor));
count79drivers/char/lp.cif (count == LP_CHAR(minor)) {
count95drivers/char/lp.cif (count > stats->maxwait) {
count97drivers/char/lp.cprintk(KERN_DEBUG "lp%d success after %d counts.\n",minor,count);
count99drivers/char/lp.cstats->maxwait = count;
count101drivers/char/lp.ccount *= 256;
count102drivers/char/lp.cwait = (count > stats->meanwait)? count - stats->meanwait :
count103drivers/char/lp.cstats->meanwait - count;
count104drivers/char/lp.cstats->meanwait = (255*stats->meanwait + count + 128) / 256;
count113drivers/char/lp.cunsigned long count = 0;
count134drivers/char/lp.cif (count) {
count135drivers/char/lp.cif (count > stats->maxwait)
count136drivers/char/lp.cstats->maxwait = count;
count137drivers/char/lp.ccount *= 256;
count138drivers/char/lp.cwait = (count > stats->meanwait)? count - stats->meanwait :
count139drivers/char/lp.cstats->meanwait - count;
count140drivers/char/lp.cstats->meanwait = (255*stats->meanwait + count + 128) / 256;
count145drivers/char/lp.c} while (count++ < LP_CHAR(minor));
count162drivers/char/lp.cstatic inline int lp_write_interrupt(unsigned int minor, const char * buf, int count)
count172drivers/char/lp.ccopy_size = (count <= LP_BUFFER_SIZE ? count : LP_BUFFER_SIZE);
count224drivers/char/lp.ccount -= bytes_written;
count226drivers/char/lp.c} while (count > 0);
count231drivers/char/lp.cstatic inline int lp_write_polled(unsigned int minor, const char * buf, int count)
count238drivers/char/lp.cwhile (count > 0) {
count243drivers/char/lp.ccount--; temp++;
count297drivers/char/lp.cstatic int lp_write(struct inode * inode, struct file * file, const char * buf, int count)
count306drivers/char/lp.creturn lp_write_interrupt(minor, buf, count);
count308drivers/char/lp.creturn lp_write_polled(minor, buf, count);
count562drivers/char/lp.cint count = 0;
count586drivers/char/lp.ccount++;
count589drivers/char/lp.cif (count)
count597drivers/char/lp.ccount += ret;
count599drivers/char/lp.cif (count == 0)
count29drivers/char/mem.cstatic int read_ram(struct inode * inode, struct file * file, char * buf, int count)
count34drivers/char/mem.cstatic int write_ram(struct inode * inode, struct file * file, const char * buf, int count)
count39drivers/char/mem.cstatic int read_mem(struct inode * inode, struct file * file, char * buf, int count)
count45drivers/char/mem.cif (count < 0)
count49drivers/char/mem.cif (count > high_memory - p)
count50drivers/char/mem.ccount = high_memory - p;
count53drivers/char/mem.cwhile (p < PAGE_OFFSET + PAGE_SIZE && count > 0) {
count57drivers/char/mem.ccount--;
count61drivers/char/mem.cmemcpy_tofs(buf, (void *) p, count);
count62drivers/char/mem.cread += count;
count67drivers/char/mem.cstatic int write_mem(struct inode * inode, struct file * file, const char * buf, int count)
count73drivers/char/mem.cif (count < 0)
count77drivers/char/mem.cif (count > high_memory - p)
count78drivers/char/mem.ccount = high_memory - p;
count81drivers/char/mem.cwhile (PAGE_OFFSET + p < PAGE_SIZE && count > 0) {
count85drivers/char/mem.ccount--;
count89drivers/char/mem.cmemcpy_fromfs((void *) p, buf, count);
count90drivers/char/mem.cwritten += count;
count92drivers/char/mem.creturn count;
count116drivers/char/mem.cstatic int read_kmem(struct inode *inode, struct file *file, char *buf, int count)
count120drivers/char/mem.cread1 = read_mem(inode, file, buf, count);
count123drivers/char/mem.cread2 = vread(buf + read1, (char *) ((unsigned long) file->f_pos), count - read1);
count130drivers/char/mem.cstatic int read_port(struct inode * inode, struct file * file,char * buf, int count)
count135drivers/char/mem.cwhile (count-- > 0 && i < 65536) {
count144drivers/char/mem.cstatic int write_port(struct inode * inode, struct file * file, const char * buf, int count)
count149drivers/char/mem.cwhile (count-- > 0 && i < 65536) {
count158drivers/char/mem.cstatic int read_null(struct inode * node, struct file * file, char * buf, int count)
count163drivers/char/mem.cstatic int write_null(struct inode * inode, struct file * file, const char * buf, int count)
count165drivers/char/mem.creturn count;
count168drivers/char/mem.cstatic int read_zero(struct inode * node, struct file * file, char * buf, int count)
count172drivers/char/mem.cfor (left = count; left > 0; left--) {
count176drivers/char/mem.creturn count;
count188drivers/char/mem.cstatic int read_full(struct inode * node, struct file * file, char * buf,int count)
count190drivers/char/mem.creturn count;
count193drivers/char/mem.cstatic int write_full(struct inode * inode, struct file * file, const char * buf, int count)
count123drivers/char/msbusmouse.cstatic int write_mouse(struct inode * inode, struct file * file, const char * buffer, int count)
count128drivers/char/msbusmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count132drivers/char/msbusmouse.cif (count < 3)
count141drivers/char/msbusmouse.cfor (i = 3; i < count; i++)
count536drivers/char/n_tty.cchar *fp, int count)
count546drivers/char/n_tty.ci = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
count552drivers/char/n_tty.ccount -= i;
count554drivers/char/n_tty.ci = MIN(count, MIN(N_TTY_BUF_SIZE - tty->read_cnt,
count560drivers/char/n_tty.cfor (i=count, p = cp, f = fp; i; i--, p++) {
count945drivers/char/n_tty.cif (tty_hung_up_p(file) || (tty->link && !tty->link->count)) {
count378drivers/char/psaux.cstatic int write_aux(struct inode * inode, struct file * file, const char * buffer, int count)
count380drivers/char/psaux.cint i = count;
count391drivers/char/psaux.creturn count;
count400drivers/char/psaux.cstatic int write_qp(struct inode * inode, struct file * file, const char * buffer, int count)
count402drivers/char/psaux.cint i = count;
count410drivers/char/psaux.creturn count;
count419drivers/char/psaux.cstatic int read_aux(struct inode * inode, struct file * file, char * buffer, int count)
count422drivers/char/psaux.cint i = count;
count444drivers/char/psaux.cif (count-i) {
count446drivers/char/psaux.creturn count-i;
count69drivers/char/pty.cif (tty->count > 1)
count70drivers/char/pty.cprintk("master pty_close: count = %d!!\n", tty->count);
count72drivers/char/pty.cif (tty->count > 2)
count115drivers/char/pty.cconst unsigned char *buf, int count)
count128drivers/char/pty.cwhile (count > 0) {
count129drivers/char/pty.cn = MIN(count, PTY_BUF_SIZE);
count137drivers/char/pty.ccount -= n;
count141drivers/char/pty.cc = MIN(count, to->ldisc.receive_room(to));
count212drivers/char/pty.cif (!tty->link->count)
count241drivers/char/random.cconst char * buffer, int count);
count645drivers/char/random.cint      count = 0;
count670drivers/char/random.ccount += n;
count679drivers/char/random.creturn (count ? count : retval);
count703drivers/char/random.cconst char * buffer, int count)
count708drivers/char/random.cfor (i = count, p = (__u32 *)buffer;
count721drivers/char/random.creturn count;
count161drivers/char/scc.cint scc_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count);
count1556drivers/char/scc.cwhile(tty->flip.count < TTY_FLIPBUF_SIZE-3)
count2140drivers/char/scc.cint scc_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
count2146drivers/char/scc.cif (!tty) return count;
count2151drivers/char/scc.cif (scc->kiss.tx_inhibit) return count;
count2155drivers/char/scc.ccnt2 = count;
count2180drivers/char/scc.creturn count;
count49drivers/char/selection.hextern void invert_screen(int currcons, int offset, int count, int shift);
count181drivers/char/selection.hstatic inline void memsetw(void * s, unsigned short c, unsigned int count)
count185drivers/char/selection.hcount /= 2;
count186drivers/char/selection.hwhile (count) {
count187drivers/char/selection.hcount--;
count193drivers/char/selection.hunsigned int count)
count195drivers/char/selection.hcount /= 2;
count196drivers/char/selection.hwhile (count) {
count197drivers/char/selection.hcount--;
count385drivers/char/serial.cif (tty->flip.count >= TTY_FLIPBUF_SIZE)
count387drivers/char/serial.ctty->flip.count++;
count413drivers/char/serial.cint count;
count429drivers/char/serial.ccount = info->xmit_fifo_size;
count435drivers/char/serial.c} while (--count > 0);
count1295drivers/char/serial.cconst unsigned char *buf, int count)
count1310drivers/char/serial.cc = MIN(count, MIN(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
count1328drivers/char/serial.ccount -= c;
count1509drivers/char/serial.cif ((change_port || change_irq) && (info->count > 1))
count1653drivers/char/serial.cif (info->count > 1)
count2013drivers/char/serial.cprintk("rs_close ttys%d, count = %d\n", info->line, info->count);
count2015drivers/char/serial.cif ((tty->count == 1) && (info->count != 1)) {
count2024drivers/char/serial.c"info->count is %d\n", info->count);
count2025drivers/char/serial.cinfo->count = 1;
count2027drivers/char/serial.cif (--info->count < 0) {
count2029drivers/char/serial.cinfo->line, info->count);
count2030drivers/char/serial.cinfo->count = 0;
count2032drivers/char/serial.cif (info->count) {
count2119drivers/char/serial.cinfo->count = 0;
count2203drivers/char/serial.cinfo->line, info->count);
count2205drivers/char/serial.cinfo->count--;
count2238drivers/char/serial.cinfo->line, info->count);
count2245drivers/char/serial.cinfo->count++;
count2249drivers/char/serial.cinfo->line, info->count);
count2277drivers/char/serial.cinfo->count);
count2279drivers/char/serial.cinfo->count++;
count2305drivers/char/serial.cif ((info->count == 1) && (info->flags & ASYNC_SPLIT_TERMIOS)) {
count2655drivers/char/serial.cinfo->count = 0;
count2720drivers/char/serial.c(rs_table[i].count == 0))
count2728drivers/char/serial.cif (rs_table[i].count) {
count460drivers/char/stallion.cstatic int  stl_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count);
count894drivers/char/stallion.cstatic int stl_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
count903drivers/char/stallion.cprintk("stl_write(tty=%x,from_user=%d,buf=%x,count=%d)\n", (int) tty, from_user, (int) buf, count);
count926drivers/char/stallion.ccount = MIN(len, count);
count931drivers/char/stallion.cmemcpy_fromfs(stl_tmpwritebuf, chbuf, count);
count947drivers/char/stallion.clen = MIN(len, count);
count948drivers/char/stallion.ccount = 0;
count954drivers/char/stallion.ccount += stlen;
count966drivers/char/stallion.creturn(count);
count1651drivers/char/stallion.c((buflen = TTY_FLIPBUF_SIZE - tty->flip.count) == 0)) {
count1662drivers/char/stallion.ctty->flip.count += len;
count1691drivers/char/stallion.cif (tty->flip.count < TTY_FLIPBUF_SIZE) {
count1694drivers/char/stallion.ctty->flip.count++;
count1921drivers/char/tpqic02.cstatic int qic02_tape_read(struct inode * inode, struct file * filp, char * buf, int count)
count1937drivers/char/tpqic02.cMINOR(dev), buf, count, (unsigned long) filp->f_pos, flags);
count1939drivers/char/tpqic02.cif (count % TAPE_BLKSIZE) {  /* Only allow mod 512 bytes at a time. */
count1951drivers/char/tpqic02.cerror = verify_area(VERIFY_WRITE, buf, count);
count1958drivers/char/tpqic02.cwhile (count>=0) {
count1962drivers/char/tpqic02.cif (bytes_todo>count)
count1963drivers/char/tpqic02.cbytes_todo = count;
count2059drivers/char/tpqic02.ccount -= bytes_done;
count2096drivers/char/tpqic02.cstatic int qic02_tape_write(struct inode * inode, struct file * filp, const char * buf, int count)
count2111drivers/char/tpqic02.cMINOR(dev), buf, count, (unsigned long) filp->f_pos, flags);
count2113drivers/char/tpqic02.cif (count % TAPE_BLKSIZE) {  /* only allow mod 512 bytes at a time */
count2133drivers/char/tpqic02.cerror = verify_area(VERIFY_READ, buf, count);
count2140drivers/char/tpqic02.cwhile (count>=0) {
count2144drivers/char/tpqic02.cif (bytes_todo>count)
count2145drivers/char/tpqic02.cbytes_todo = count;
count2226drivers/char/tpqic02.ccount -= bytes_done;
count2231drivers/char/tpqic02.cprintk(TPQIC02_NAME ": status_bytes_wr %x, buf %p, total_bytes_done %lx, count %x\n", status_bytes_wr, buf, total_bytes_done, count);
count167drivers/char/tty_io.cint i, count = 0;
count173drivers/char/tty_io.ccount++;
count178drivers/char/tty_io.ctty->link && tty->link->count)
count179drivers/char/tty_io.ccount++;
count180drivers/char/tty_io.cif (tty->count != count) {
count182drivers/char/tty_io.ckdevname(tty->device), tty->count, count, routine);
count183drivers/char/tty_io.creturn count;
count296drivers/char/tty_io.cstatic int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
count301drivers/char/tty_io.cstatic int hung_up_tty_write(struct inode * inode, struct file * file, const char * buf, int count)
count699drivers/char/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
count728drivers/char/tty_io.ci = (tty->ldisc.read)(tty,file,(unsigned char *)buf,(unsigned int)count);
count736drivers/char/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, const char * buf, int count)
count764drivers/char/tty_io.ci = (tty->ldisc.write)(tty,file,(const unsigned char *)buf,(unsigned int)count);
count805drivers/char/tty_io.c*tty_loc && (*tty_loc)->count)
count883drivers/char/tty_io.c(*tty_loc)->count++;
count887drivers/char/tty_io.c(*tty_loc)->count--;
count900drivers/char/tty_io.c(*tty_loc)->count++;
count919drivers/char/tty_io.c(*tty_loc)->count--;
count929drivers/char/tty_io.c(*o_tty_loc)->count++;
count1001drivers/char/tty_io.ctty->count);
count1040drivers/char/tty_io.cif (--tty->link->count < 0) {
count1042drivers/char/tty_io.ctty->count, tty_name(tty));
count1043drivers/char/tty_io.ctty->link->count = 0;
count1046drivers/char/tty_io.cif (--tty->count < 0) {
count1048drivers/char/tty_io.ctty->count, tty_name(tty));
count1049drivers/char/tty_io.ctty->count = 0;
count1051drivers/char/tty_io.cif (tty->count)
count1058drivers/char/tty_io.cif (o_tty->count)
count1649drivers/char/tty_io.cint    count;
count1668drivers/char/tty_io.ccount = tty->flip.count;
count1669drivers/char/tty_io.ctty->flip.count = 0;
count1673drivers/char/tty_io.cif (count > tty->max_flip_cnt)
count1674drivers/char/tty_io.ctty->max_flip_cnt = count;
count1676drivers/char/tty_io.ctty->ldisc.receive_buf(tty, cp, fp, count);
count63drivers/char/vc_screen.cvcs_read(struct inode *inode, struct file *file, char *buf, int count)
count84drivers/char/vc_screen.cif (count < 0 || p > size)
count86drivers/char/vc_screen.cif (count > size - p)
count87drivers/char/vc_screen.ccount = size - p;
count92drivers/char/vc_screen.cwhile (count-- > 0)
count100drivers/char/vc_screen.cwhile (p < HEADER_SIZE && count-- > 0)
count105drivers/char/vc_screen.cif ((p & 1) && count-- > 0)
count107drivers/char/vc_screen.cwhile (count > 1) {
count110drivers/char/vc_screen.ccount -= 2;
count112drivers/char/vc_screen.cif (count > 0)
count121drivers/char/vc_screen.cvcs_write(struct inode *inode, struct file *file, const char *buf, int count)
count142drivers/char/vc_screen.cif (count < 0 || p > size)
count144drivers/char/vc_screen.cif (count > size - p)
count145drivers/char/vc_screen.ccount = size - p;
count150drivers/char/vc_screen.cwhile (count-- > 0) {
count159drivers/char/vc_screen.cwhile (p < HEADER_SIZE && count-- > 0)
count166drivers/char/vc_screen.cif ((p & 1) && count-- > 0) {
count171drivers/char/vc_screen.cwhile (count > 1) {
count174drivers/char/vc_screen.ccount -= 2;
count176drivers/char/vc_screen.cif (count > 0)
count33drivers/char/vt.c#define VT_IS_IN_USE(i)  (console_driver.table[i] && console_driver.table[i]->count)
count156drivers/char/vt.ckd_mksound(unsigned int count, unsigned int ticks)
count162drivers/char/vt.cif (count) {
count168drivers/char/vt.coutb_p(count & 0xff, 0x42);
count169drivers/char/vt.coutb((count >> 8) & 0xff, 0x42);
count33drivers/char/vt_kern.hvoid kd_mksound(unsigned int count, unsigned int ticks);
count75drivers/net/3c503.cstatic void el2_block_output(struct device *dev, int count,
count77drivers/net/3c503.cstatic void el2_block_input(struct device *dev, int count, struct sk_buff *skb,
count428drivers/net/3c503.cel2_block_output(struct device *dev, int count,
count442drivers/net/3c503.cmemcpy_toio(dest_addr, buf, count);
count456drivers/net/3c503.cfor(i = 0; i < count; i++) {
count461drivers/net/3c503.cdev->name, i, count, boguscount);
count499drivers/net/3c503.cel2_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count508drivers/net/3c503.cif (dev->mem_start + ring_offset + count > end_of_ring) {
count512drivers/net/3c503.ccount -= semi_count;
count513drivers/net/3c503.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
count516drivers/net/3c503.ceth_io_copy_and_sum(skb, dev->mem_start + ring_offset, count, 0);
count528drivers/net/3c503.cfor(i = 0; i < count; i++) {
count533drivers/net/3c503.cdev->name, i, count, boguscount);
count445drivers/net/8390.cpkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
count465drivers/net/8390.cdev->name, rx_frame.count, rx_frame.status,
count492drivers/net/8390.crx_frame.count);
count24drivers/net/8390.hunsigned short count; /* header + packet length in bytes */
count75drivers/net/ac3200.cstatic void ac_block_input(struct device *dev, int count,
count77drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, const int count,
count269drivers/net/ac3200.cstatic void ac_block_input(struct device *dev, int count, struct sk_buff *skb,
count274drivers/net/ac3200.cif (xfer_start + count > dev->rmem_end) {
count278drivers/net/ac3200.ccount -= semi_count;
count279drivers/net/ac3200.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
count282drivers/net/ac3200.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
count286drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, int count,
count291drivers/net/ac3200.cmemcpy_toio(shmem, buf, count);
count116drivers/net/apricot.cunsigned short count;
count212drivers/net/apricot.crfd->count = 0;
count339drivers/net/apricot.cint pkt_len = lp->scb.rfd->count & 0x3fff;
count376drivers/net/apricot.clp->rx_tail->count = 0;
count419drivers/net/apricot.cunsigned short count = *((unsigned short *) (ptr + 1));
count422drivers/net/apricot.ckfree_s((unsigned char *)ptr, (sizeof (struct i596_cmd) + count + 2));
count829drivers/net/apricot.cunsigned short count = *((unsigned short *) (ptr + 1));
count832drivers/net/apricot.ckfree_s((unsigned char *)ptr, (sizeof (struct i596_cmd) + count + 2));
count307drivers/net/de620.cde620_write_block(struct device *dev, byte *buffer, int count)
count314drivers/net/de620.cint bytes = count;
count323drivers/net/de620.cfor ( ; count > 0; --count, ++buffer) {
count332drivers/net/de620.cfor ( ; count > 0; count -=2) {
count343drivers/net/de620.cde620_read_block(struct device *dev, byte *data, int count)
count351drivers/net/de620.cint bytes = count;
count359drivers/net/de620.cwhile (count-- > 0) {
count368drivers/net/de620.cwhile (count-- > 0) {
count101drivers/net/e2100.cstatic void e21_block_input(struct device *dev, int count,
count103drivers/net/e2100.cstatic void e21_block_output(struct device *dev, int count,
count313drivers/net/e2100.ce21_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count321drivers/net/e2100.ceth_io_copy_and_sum(skb, dev->mem_start + (ring_offset & 0xff), count, 0);
count327drivers/net/e2100.ce21_block_output(struct device *dev, int count, const unsigned char *buf,
count338drivers/net/e2100.cmemcpy_toio(shared_mem, buf, count);
count101drivers/net/hp-plus.cstatic void hpp_mem_block_input(struct device *dev, int count,
count103drivers/net/hp-plus.cstatic void hpp_mem_block_output(struct device *dev, int count,
count107drivers/net/hp-plus.cstatic void hpp_io_block_input(struct device *dev, int count,
count109drivers/net/hp-plus.cstatic void hpp_io_block_output(struct device *dev, int count,
count340drivers/net/hp-plus.chpp_io_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count346drivers/net/hp-plus.cinsw(ioaddr + HP_DATAPORT, buf, count>>1);
count347drivers/net/hp-plus.cif (count & 0x01)
count348drivers/net/hp-plus.cbuf[count-1] = inw(ioaddr + HP_DATAPORT);
count363drivers/net/hp-plus.chdr->count = (hdr->count + 3) & ~3;  /* Round up allocation. */
count367drivers/net/hp-plus.chpp_mem_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count380drivers/net/hp-plus.cmemcpy_fromio(skb->data, dev->mem_start, count);
count387drivers/net/hp-plus.chpp_io_block_output(struct device *dev, int count,
count392drivers/net/hp-plus.coutsl(ioaddr + HP_DATAPORT, buf, (count+3)>>2);
count397drivers/net/hp-plus.chpp_mem_block_output(struct device *dev, int count,
count405drivers/net/hp-plus.cmemcpy_toio(dev->mem_start, buf, (count + 3) & ~3);
count65drivers/net/hp.cstatic void hp_block_input(struct device *dev, int count,
count67drivers/net/hp.cstatic void hp_block_output(struct device *dev, int count,
count276drivers/net/hp.chp_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count280drivers/net/hp.cint xfer_count = count;
count285drivers/net/hp.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count286drivers/net/hp.coutb_p(count >> 8, nic_base + EN0_RCNTHI);
count291drivers/net/hp.cinsw(nic_base - NIC_OFFSET + HP_DATAPORT,buf,count>>1);
count292drivers/net/hp.cif (count & 0x01)
count293drivers/net/hp.cbuf[count-1] = inb(nic_base - NIC_OFFSET + HP_DATAPORT), xfer_count++;
count295drivers/net/hp.cinsb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count);
count311drivers/net/hp.chp_block_output(struct device *dev, int count,
count321drivers/net/hp.cif (ei_status.word16 && (count & 0x01))
count322drivers/net/hp.ccount++;
count340drivers/net/hp.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count341drivers/net/hp.coutb_p(count >> 8,   nic_base + EN0_RCNTHI);
count348drivers/net/hp.coutsw(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count>>1);
count350drivers/net/hp.coutsb(nic_base - NIC_OFFSET + HP_DATAPORT, buf, count);
count360drivers/net/hp.cif ((start_page << 8) + count != addr)
count362drivers/net/hp.cdev->name, (start_page << 8) + count, addr);
count102drivers/net/ne.cstatic void ne_block_input(struct device *dev, int count,
count104drivers/net/ne.cstatic void ne_block_output(struct device *dev, const int count,
count448drivers/net/ne.cne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count451drivers/net/ne.cint xfer_count = count;
count466drivers/net/ne.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count467drivers/net/ne.coutb_p(count >> 8, nic_base + EN0_RCNTHI);
count472drivers/net/ne.cinsw(NE_BASE + NE_DATAPORT,buf,count>>1);
count473drivers/net/ne.cif (count & 0x01) {
count474drivers/net/ne.cbuf[count-1] = inb(NE_BASE + NE_DATAPORT);
count480drivers/net/ne.cinsb(NE_BASE + NE_DATAPORT, buf, count);
count510drivers/net/ne.cne_block_output(struct device *dev, int count,
count522drivers/net/ne.cif (ei_status.word16 && (count & 0x01))
count523drivers/net/ne.ccount++;
count560drivers/net/ne.coutb_p(count & 0xff, nic_base + EN0_RCNTLO);
count561drivers/net/ne.coutb_p(count >> 8,   nic_base + EN0_RCNTHI);
count567drivers/net/ne.coutsw(NE_BASE + NE_DATAPORT, buf, count>>1);
count569drivers/net/ne.coutsb(NE_BASE + NE_DATAPORT, buf, count);
count583drivers/net/ne.cif ((start_page << 8) + count == addr)
count589drivers/net/ne.cdev->name, (start_page << 8) + count, addr);
count160drivers/net/ppp.c#define ins_char(pbuf,c) (buf_base(pbuf) [(pbuf)->count++] = (u_char)(c))
count194drivers/net/ppp.c#define dev_alloc_skb(count)        alloc_skb(count, GFP_ATOMIC)
count195drivers/net/ppp.c#define skb_put(skb,count)          skb_data(skb)
count243drivers/net/ppp.cchar *fp, int count);
count589drivers/net/ppp.cbuf->count  = 0;
count933drivers/net/ppp.cregister int count, actual;
count947drivers/net/ppp.ccount = xbuf->count - xbuf->tail;
count949drivers/net/ppp.cbuf_base (xbuf) + xbuf->tail, count);
count956drivers/net/ppp.cactual = count;
count963drivers/net/ppp.cif (actual == count) {
count1116drivers/net/ppp.cchar *flags, int count)
count1145drivers/net/ppp.cppp_print_buffer ("receive buffer", data, count);
count1150drivers/net/ppp.cwhile (count-- > 0) {
count1191drivers/net/ppp.cppp->stats.ppp_ibytes += ppp->rbuf->count;
count1205drivers/net/ppp.cbuf->count  = 0;
count1230drivers/net/ppp.cif (buf->count < buf->size) {
count1231drivers/net/ppp.cbuf_base (buf)[buf->count++] = chr;
count1251drivers/net/ppp.cppp_rcv_rx (struct ppp *ppp, unsigned short proto, u_char * data, int count)
count1253drivers/net/ppp.csk_buff *skb = dev_alloc_skb (count);
count1269drivers/net/ppp.cskb->len = count;
count1274drivers/net/ppp.cmemcpy (skb_put(skb,count), data, count);  /* move data */
count1289drivers/net/ppp.crcv_proto_ip (struct ppp *ppp, unsigned short proto, u_char * data, int count)
count1292drivers/net/ppp.cif (count > 0)
count1293drivers/net/ppp.creturn ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
count1303drivers/net/ppp.crcv_proto_ipx (struct ppp *ppp, unsigned short proto, u_char * data, int count)
count1307drivers/net/ppp.cif (count > 0)
count1308drivers/net/ppp.creturn ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
count1320drivers/net/ppp.cu_char *data, int count)
count1323drivers/net/ppp.cint new_count = slhc_uncompress (ppp->slcomp, data, count);
count1340drivers/net/ppp.cu_char *data, int count)
count1343drivers/net/ppp.cif (slhc_remember (ppp->slcomp, data, count) > 0) {
count1344drivers/net/ppp.creturn rcv_proto_ip (ppp, PPP_IP, data, count);
count1573drivers/net/ppp.cstatic void ppp_doframe_lower (struct ppp *ppp, u_char *data, int count)
count1580drivers/net/ppp.cif (count <= 4)
count1587drivers/net/ppp.cppp_print_buffer ("receive frame", data, count);
count1600drivers/net/ppp.ccount - PPP_HARD_HDR_LEN))
count1601drivers/net/ppp.cppp->stats.ppp_ioctects += count;
count1613drivers/net/ppp.cint  count = ppp->rbuf->count;
count1633drivers/net/ppp.cif (count == 0)
count1638drivers/net/ppp.cif (count < PPP_HARD_HDR_LEN) {
count1641drivers/net/ppp.c"ppp: got runt ppp frame, %d chars\n", count);
count1658drivers/net/ppp.ccount -= 2;    /* ignore the fcs characters */
count1667drivers/net/ppp.ccount -= 2;
count1675drivers/net/ppp.c--count;
count1686drivers/net/ppp.ccount    += 3;
count1705drivers/net/ppp.ccount);
count1713drivers/net/ppp.ccount,
count1750drivers/net/ppp.ccount);
count1755drivers/net/ppp.cppp_doframe_lower (ppp, data, count);
count1937drivers/net/ppp.cif ((buf->count < 0) || (buf->count > 3000))
count1939drivers/net/ppp.c(unsigned int) buf->count,
count1963drivers/net/ppp.cu_char *data, int count, int non_ip)
count1971drivers/net/ppp.cbuf->count = 0;
count2005drivers/net/ppp.ccount -= 4;
count2007drivers/net/ppp.cwhile (count-- > 0)
count2028drivers/net/ppp.cbuf->count);
count2033drivers/net/ppp.cbuf->count);
count2038drivers/net/ppp.cppp->stats.ppp_obytes += buf->count;
count2051drivers/net/ppp.cu_char *data, int count)
count2061drivers/net/ppp.cppp_print_buffer ("write frame", data, count);
count2076drivers/net/ppp.cnew_data = kmalloc (count, GFP_ATOMIC);
count2087drivers/net/ppp.ccount,
count2088drivers/net/ppp.ccount);
count2109drivers/net/ppp.cppp->stats.ppp_ooctects += count;
count2113drivers/net/ppp.cppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
count2163drivers/net/ppp.cunsigned int count)
count2181drivers/net/ppp.cif (count > PPP_MTU) {
count2185drivers/net/ppp.c"from %u to mtu %d\n", count, PPP_MTU);
count2186drivers/net/ppp.ccount = PPP_MTU;
count2191drivers/net/ppp.cnew_data = kmalloc (count, GFP_KERNEL);
count2222drivers/net/ppp.cstatus = verify_area (VERIFY_READ, data, count);
count2229drivers/net/ppp.cmemcpy_fromfs (new_data, data, count);
count2233drivers/net/ppp.ccount = send_revise_frame (ppp, new_data, count);
count2237drivers/net/ppp.cppp_dev_xmit_frame (ppp, ppp->tbuf, new_data, count);
count2239drivers/net/ppp.creturn (int) count;
count3379drivers/net/ppp.cppp_print_hex (register u_char * out, const u_char * in, int count)
count3384drivers/net/ppp.cwhile (count-- > 0) {
count3393drivers/net/ppp.cppp_print_char (register u_char * out, const u_char * in, int count)
count3397drivers/net/ppp.cwhile (count-- > 0) {
count3412drivers/net/ppp.cppp_print_buffer (const u_char * name, const u_char * buf, int count)
count3417drivers/net/ppp.cprintk (KERN_DEBUG "ppp: %s, count = %d\n", name, count);
count3419drivers/net/ppp.cwhile (count > 8) {
count3424drivers/net/ppp.ccount -= 8;
count3428drivers/net/ppp.cif (count > 0) {
count3430drivers/net/ppp.cppp_print_hex (line, buf, count);
count3431drivers/net/ppp.cppp_print_char (&line[8 * 3], buf, count);
count340drivers/net/slip.cint count;
count342drivers/net/slip.ccount = sl->rcount;
count353drivers/net/slip.cif (count + 80 > sl->buffsize) {
count357drivers/net/slip.ccount = slhc_uncompress(sl->slcomp, sl->rbuff, count);
count358drivers/net/slip.cif (count <= 0) {
count369drivers/net/slip.cif (slhc_remember(sl->slcomp, sl->rbuff, count) <= 0) {
count376drivers/net/slip.cskb = dev_alloc_skb(count);
count383drivers/net/slip.cmemcpy(skb_put(skb,count), sl->rbuff, count);
count398drivers/net/slip.cint actual, count;
count425drivers/net/slip.ccount = slip_esc6(p, (unsigned char *) sl->xbuff, len);
count428drivers/net/slip.ccount = slip_esc(p, (unsigned char *) sl->xbuff, len);
count439drivers/net/slip.cactual = sl->tty->driver.write(sl->tty, 0, sl->xbuff, count);
count443drivers/net/slip.csl->xleft = count - actual;
count679drivers/net/slip.cslip_receive_buf(struct tty_struct *tty, const unsigned char *cp, char *fp, int count)
count699drivers/net/slip.cwhile (count--) {
count72drivers/net/smc-ultra.cstatic void ultra_block_input(struct device *dev, int count,
count74drivers/net/smc-ultra.cstatic void ultra_block_output(struct device *dev, int count,
count281drivers/net/smc-ultra.cultra_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count288drivers/net/smc-ultra.cif (xfer_start + count > dev->rmem_end) {
count292drivers/net/smc-ultra.ccount -= semi_count;
count293drivers/net/smc-ultra.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
count296drivers/net/smc-ultra.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
count303drivers/net/smc-ultra.cultra_block_output(struct device *dev, int count, const unsigned char *buf,
count311drivers/net/smc-ultra.cmemcpy_toio(shmem, buf, count);
count54drivers/net/wd.cstatic void wd_block_input(struct device *dev, int count,
count56drivers/net/wd.cstatic void wd_block_output(struct device *dev, int count,
count364drivers/net/wd.cwd_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
count369drivers/net/wd.cif (xfer_start + count > dev->rmem_end) {
count373drivers/net/wd.ccount -= semi_count;
count374drivers/net/wd.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
count377drivers/net/wd.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
count386drivers/net/wd.cwd_block_output(struct device *dev, int count, const unsigned char *buf,
count396drivers/net/wd.cmemcpy_toio(shmem, buf, count);
count399drivers/net/wd.cmemcpy_toio(shmem, buf, count);
count495drivers/net/znet.cint count, status;
count511drivers/net/znet.ccount = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
count517drivers/net/znet.ccount, status);
count520drivers/net/znet.ccur_frame_end[-2] = count;
count522drivers/net/znet.ccur_frame_end_offset -= ((count + 1)>>1) + 3;
count991drivers/scsi/53c7,8xx.cint count;      /* Number of boards detected */
count997drivers/scsi/53c7,8xx.cfor (current_override = count = 0; current_override < OVERRIDE_LIMIT; 
count1015drivers/scsi/53c7,8xx.c++count;
count1027drivers/scsi/53c7,8xx.c++count, ++pci_index);
count1029drivers/scsi/53c7,8xx.creturn count;
count2155drivers/scsi/53c7,8xx.cchar *buf,int count) {
count2168drivers/scsi/53c7,8xx.cif (error = verify_area(VERIFY_READ,buf,count))
count2171drivers/scsi/53c7,8xx.cif (count > 80) 
count2174drivers/scsi/53c7,8xx.cmemcpy_from_fs(input_buf, buf, count);
count2176drivers/scsi/53c7,8xx.cif (input_buf[count - 1] != '\n')
count2179drivers/scsi/53c7,8xx.cinput_buf[count - 1]=0;
count2203drivers/scsi/53c7,8xx.creturn count;
count2207drivers/scsi/53c7,8xx.cchar *buf,int count) {
count2605drivers/scsi/53c7,8xx.cu32 count = cmd->use_sg ?
count2611drivers/scsi/53c7,8xx.c<< 24) | count;
count2625drivers/scsi/53c7,8xx.c| count;
count957drivers/scsi/53c7,8xx.hu32 count;
count1466drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
count1469drivers/scsi/NCR5380.cregister int c = *count;
count1570drivers/scsi/NCR5380.c*count = c;
count1606drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
count1608drivers/scsi/NCR5380.cregister int c = *count;
count1765drivers/scsi/NCR5380.c*count -= c;
count1777drivers/scsi/NCR5380.c*count -= 1;
count1787drivers/scsi/NCR5380.c*count -= toPIO - cnt;
count1793drivers/scsi/NCR5380.c*data, *count, *(*data+*count-1), *(*data+*count));
count1883drivers/scsi/NCR5380.c*count = 0;
count296drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
count299drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
count303drivers/scsi/NCR5380.hunsigned char *ptr, unsigned int count, unsigned char mode) {
count307drivers/scsi/NCR5380.hif (count > 65536)
count308drivers/scsi/NCR5380.hcount = 65536;
count311drivers/scsi/NCR5380.hif (count > 65536 * 2) 
count312drivers/scsi/NCR5380.hcount = 65536 * 2;
count316drivers/scsi/NCR5380.hif (count > limit) count = limit;
count318drivers/scsi/NCR5380.hif ((count & 1) || (((unsigned) ptr) & 1))
count324drivers/scsi/NCR5380.hset_dma_count(instance->dma_channel, count);
count328drivers/scsi/NCR5380.hreturn count;
count332drivers/scsi/NCR5380.hunsigned char *src, unsigned int count) {
count333drivers/scsi/NCR5380.hreturn NCR5380_i386_dma_setup (instance, src, count, DMA_MODE_WRITE);
count337drivers/scsi/NCR5380.hunsigned char *src, unsigned int count) {
count338drivers/scsi/NCR5380.hreturn NCR5380_i386_dma_setup (instance, src, count, DMA_MODE_READ);
count101drivers/scsi/NCR53c406a.c#define LOAD_DMA_COUNT(count) \
count102drivers/scsi/NCR53c406a.coutb(count & 0xff, TC_LSB); \
count103drivers/scsi/NCR53c406a.coutb((count >> 8) & 0xff, TC_MSB); \
count104drivers/scsi/NCR53c406a.coutb((count >> 16) & 0xff, TC_HIGH);
count288drivers/scsi/NCR53c406a.cunsigned int count, 
count293drivers/scsi/NCR53c406a.cVDEB(printk("dma: before count=%d   ", count));
count295drivers/scsi/NCR53c406a.cif (count > 65536)
count296drivers/scsi/NCR53c406a.ccount = 65536;
count299drivers/scsi/NCR53c406a.cif (count > (65536<<1)) 
count300drivers/scsi/NCR53c406a.ccount = (65536<<1);
count304drivers/scsi/NCR53c406a.cif (count > limit) count = limit;
count306drivers/scsi/NCR53c406a.cVDEB(printk("after count=%d\n", count));
count307drivers/scsi/NCR53c406a.cif ((count & 1) || (((unsigned) ptr) & 1))
count315drivers/scsi/NCR53c406a.cset_dma_count(dma_chan, count);
count320drivers/scsi/NCR53c406a.creturn count;
count324drivers/scsi/NCR53c406a.cNCR53c406a_dma_write(unsigned char *src, unsigned int count) {
count325drivers/scsi/NCR53c406a.creturn NCR53c406a_dma_setup (src, count, DMA_MODE_WRITE);
count329drivers/scsi/NCR53c406a.cNCR53c406a_dma_read(unsigned char *src, unsigned int count) {
count330drivers/scsi/NCR53c406a.creturn NCR53c406a_dma_setup (src, count, DMA_MODE_READ);
count934drivers/scsi/aha1542.cint count = 0;
count1071drivers/scsi/aha1542.ccount++;
count1079drivers/scsi/aha1542.creturn count;
count1085drivers/scsi/aha1542.cint count = 0;
count1097drivers/scsi/aha1542.ccount++;
count1100drivers/scsi/aha1542.cprintk("Potential to restart %d stalled commands...\n", count);
count1103drivers/scsi/aha1542.cif (count) aha1542_out(shost->io_port, &ahacmd, 1);
count127drivers/scsi/g_NCR5380.cint count;
count132drivers/scsi/g_NCR5380.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count169drivers/scsi/g_NCR5380.c++count;
count171drivers/scsi/g_NCR5380.creturn count;
count189drivers/scsi/in2000.cunsigned count, infcnt, txcnt;
count195drivers/scsi/in2000.ccount = (infcnt << 3) - 32;  /* don't fill completely */
count196drivers/scsi/in2000.cif ( count > in2000_datalen )
count197drivers/scsi/in2000.ccount = in2000_datalen;  /* limit to actual data on hand */
count198drivers/scsi/in2000.ccount >>= 1;    /* Words, not bytes */
count200drivers/scsi/in2000.cif ( count ) {
count201drivers/scsi/in2000.cport_write(INFIFO, in2000_dataptr, count);
count202drivers/scsi/in2000.cin2000_datalen -= (count<<1);
count205drivers/scsi/in2000.cwhile ( count-- )
count222drivers/scsi/in2000.ccount = 32;  /* Always says to use this much flush */
count223drivers/scsi/in2000.cwhile ( count-- )
count231drivers/scsi/in2000.cunsigned fic, count, count2;
count233drivers/scsi/in2000.ccount = inb(INFCNT) & 0xe1;
count235drivers/scsi/in2000.ccount2 = count;
count236drivers/scsi/in2000.ccount = (fic = inb(INFCNT)) & 0xe1;
count237drivers/scsi/in2000.c} while ( count != count2 );
count243drivers/scsi/in2000.cif(fic > 128) count = 1024;
count244drivers/scsi/in2000.celse if(fic > 64) count = 512;
count245drivers/scsi/in2000.celse if (fic > 32) count = 256;
count247drivers/scsi/in2000.ccount = in2000_datalen - count2;  /* FIFO has the rest */
count248drivers/scsi/in2000.cif ( count > in2000_datalen )  /* count2 is lesser of FIFO & rqst */
count251drivers/scsi/in2000.ccount2 = count >> 1;
count252drivers/scsi/in2000.ccount >>= 1;    /* also to words */
count253drivers/scsi/in2000.ccount -= count2;  /* extra left over in FIFO */
count284drivers/scsi/in2000.cunsigned int count,auxstatus,scsistatus,cmdphase,scsibyte;
count290drivers/scsi/in2000.cif (( (ficmsk & (count = inb(INFCNT))) == 0xfe ) ||
count300drivers/scsi/in2000.cDEB(printk("(int2000:%02x %02x %02x %02x %02x)\n",count,auxstatus,
count357drivers/scsi/pas16.cint  count;
count361drivers/scsi/pas16.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count434drivers/scsi/pas16.c++count;
count436drivers/scsi/pas16.creturn count;
count654drivers/scsi/sd.cint count, this_count_max;
count660drivers/scsi/sd.ccount = 0;
count668drivers/scsi/sd.cif (count < SCpnt->host->sg_tablesize) count++;
count677drivers/scsi/sd.c((unsigned int) SCpnt->request.bh->b_data-1) == ISA_DMA_THRESHOLD) count--;
count679drivers/scsi/sd.cSCpnt->use_sg = count;  /* Number of chains */
count680drivers/scsi/sd.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes */
count681drivers/scsi/sd.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count682drivers/scsi/sd.ccount = count << 1;
count683drivers/scsi/sd.cSCpnt->sglist_len = count;
count684drivers/scsi/sd.cmax_sg = count / sizeof(struct scatterlist);
count687drivers/scsi/sd.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count694drivers/scsi/sd.cmemset(sgpnt, 0, count);  /* Zero so it is easy to fill, but only
count699drivers/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh, bhp = bh->b_reqnext;
count700drivers/scsi/sd.ccount < SCpnt->use_sg && bh; 
count701drivers/scsi/sd.ccount++, bh = bhp) {
count705drivers/scsi/sd.cif(!sgpnt[count].address) sgpnt[count].address = bh->b_data;
count706drivers/scsi/sd.csgpnt[count].length += bh->b_size;
count709drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length - 1 > 
count711drivers/scsi/sd.c!sgpnt[count].alt_address) {
count712drivers/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
count717drivers/scsi/sd.cif(dma_free_sectors < (sgpnt[count].length >> 9) + 10) {
count718drivers/scsi/sd.csgpnt[count].address = NULL;
count720drivers/scsi/sd.csgpnt[count].address = 
count721drivers/scsi/sd.c(char *) scsi_malloc(sgpnt[count].length);
count728drivers/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count732drivers/scsi/sd.cwhile(--count >= 0){
count733drivers/scsi/sd.cif(sgpnt[count].alt_address) 
count734drivers/scsi/sd.cscsi_free(sgpnt[count].address, 
count735drivers/scsi/sd.csgpnt[count].length);
count742drivers/scsi/sd.cSCpnt->use_sg = count;
count757drivers/scsi/sd.cif (((long) sgpnt[count].address) + sgpnt[count].length +
count760drivers/scsi/sd.c!sgpnt[count].alt_address) continue;
count762drivers/scsi/sd.cif(!sgpnt[count].alt_address) {count--; continue; }
count764drivers/scsi/sd.ctmp = (char *) scsi_malloc(sgpnt[count].length 
count771drivers/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count772drivers/scsi/sd.csgpnt[count].address = tmp;
count773drivers/scsi/sd.ccount--;
count788drivers/scsi/sd.cif(count < SCpnt->use_sg || SCpnt->use_sg 
count792drivers/scsi/sd.cSCpnt->use_sg, count, dma_free_sectors);
count800drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
count801drivers/scsi/sd.cprintk("{%d:%p %p %d}  ", count,
count802drivers/scsi/sd.csgpnt[count].address,
count803drivers/scsi/sd.csgpnt[count].alt_address,
count804drivers/scsi/sd.csgpnt[count].length);
count809drivers/scsi/sd.cfor(count=0; count<SCpnt->use_sg; count++)
count810drivers/scsi/sd.cif(sgpnt[count].alt_address)
count811drivers/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
count812drivers/scsi/sd.csgpnt[count].length);
count252drivers/scsi/seagate.cregister int count = 0, start = jiffies + 1, stop = start + 25;
count255drivers/scsi/seagate.cfor (;jiffies < stop; ++count);
count262drivers/scsi/seagate.cborken_calibration =  (count * 4) / (SLOW_RATE*1024);
count273drivers/scsi/seagate.cregister int count;
count274drivers/scsi/seagate.cfor (count = borken_calibration; count && (STATUS & STAT_REQ); 
count275drivers/scsi/seagate.c--count);
count277drivers/scsi/seagate.cif (count)
count199drivers/scsi/sg.cstatic int sg_read(struct inode *inode,struct file *filp,char *buf,int count)
count205drivers/scsi/sg.cif ((i=verify_area(VERIFY_WRITE,buf,count)))
count234drivers/scsi/sg.cif (count>=sizeof(struct sg_header))
count238drivers/scsi/sg.cif (count>device->header.pack_len)
count239drivers/scsi/sg.ccount=device->header.pack_len;
count240drivers/scsi/sg.cif (count > sizeof(struct sg_header)) {
count241drivers/scsi/sg.cmemcpy_tofs(buf,device->buff,count-sizeof(struct sg_header));
count245drivers/scsi/sg.ccount=0;
count255drivers/scsi/sg.creturn count;
count298drivers/scsi/sg.cstatic int sg_write(struct inode *inode,struct file *filp,const char *buf,int count)
count309drivers/scsi/sg.cif ((i=verify_area(VERIFY_READ,buf,count)))
count315drivers/scsi/sg.cif (count<(sizeof(struct sg_header) + 6))
count345drivers/scsi/sg.cdevice->header.pack_len=count;
count423drivers/scsi/sg.cif( count < (sizeof(struct sg_header) + size) )
count467drivers/scsi/sg.creturn count;
count723drivers/scsi/sr.cint count, this_count_max;
count726drivers/scsi/sr.ccount = 0;
count731drivers/scsi/sr.cif(this_count) count++;
count732drivers/scsi/sr.cwhile(bh && count < SCpnt->host->sg_tablesize) {
count735drivers/scsi/sr.ccount++;
count741drivers/scsi/sr.cif (count < SCpnt->host->sg_tablesize) {
count742drivers/scsi/sr.ccount++;
count746drivers/scsi/sr.ccount--;
count750drivers/scsi/sr.cSCpnt->use_sg = count;  /* Number of chains */
count751drivers/scsi/sr.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
count752drivers/scsi/sr.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count753drivers/scsi/sr.ccount = count << 1;
count754drivers/scsi/sr.cSCpnt->sglist_len = count;
count755drivers/scsi/sr.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count761drivers/scsi/sr.ccount = 0;
count764drivers/scsi/sr.csgpnt[count].length = (SCpnt->request.sector % 4) << 9;
count765drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
count766drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count767drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
count769drivers/scsi/sr.ccount++;
count771drivers/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
count772drivers/scsi/sr.ccount++, bh = bh->b_reqnext) {
count774drivers/scsi/sr.csgpnt[count].address = bh->b_data;
count775drivers/scsi/sr.csgpnt[count].length = bh->b_size;
count776drivers/scsi/sr.csgpnt[count].alt_address = NULL;
count778drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(end_rec);
count779drivers/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count780drivers/scsi/sr.csgpnt[count].length = end_rec;
count781drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count782drivers/scsi/sr.cif (count+1 != SCpnt->use_sg) panic("Bad sr request list");
count785drivers/scsi/sr.cif (((long) sgpnt[count].address) + sgpnt[count].length > ISA_DMA_THRESHOLD &&
count787drivers/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count791drivers/scsi/sr.cif(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
count792drivers/scsi/sr.csgpnt[count].address = NULL;
count794drivers/scsi/sr.csgpnt[count].address = (char *) scsi_malloc(sgpnt[count].length);
count800drivers/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count803drivers/scsi/sr.cwhile(--count >= 0){
count804drivers/scsi/sr.cif(sgpnt[count].alt_address) 
count805drivers/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count818drivers/scsi/sr.cfor(count=0; count<SCpnt->use_sg; count++)
count819drivers/scsi/sr.cprintk("SGlist: %d %x %x %x\n", count,
count820drivers/scsi/sr.csgpnt[count].address, 
count821drivers/scsi/sr.csgpnt[count].alt_address, 
count822drivers/scsi/sr.csgpnt[count].length);
count728drivers/scsi/st.cst_write(struct inode * inode, struct file * filp, const char * buf, int count)
count761drivers/scsi/st.ccount > (STp->buffer)->buffer_size &&
count762drivers/scsi/st.c!enlarge_buffer(STp->buffer, count))
count803drivers/scsi/st.cif (STp->block_size != 0 && (count % STp->block_size) != 0)
count812drivers/scsi/st.ctotal = count;
count821drivers/scsi/st.cwhile((STp->block_size == 0 && !STp->do_async_writes && count > 0) ||
count823drivers/scsi/st.c(STp->buffer)->buffer_bytes + count > write_threshold))
count827drivers/scsi/st.cdo_count = count;
count831drivers/scsi/st.cif (do_count > count)
count832drivers/scsi/st.cdo_count = count;
count872drivers/scsi/st.ccount -= do_count - transfer;
count905drivers/scsi/st.cif (count < total)
count906drivers/scsi/st.creturn total - count;
count912drivers/scsi/st.ccount -= do_count;
count922drivers/scsi/st.cif (count != 0) {
count925drivers/scsi/st.c(STp->buffer)->buffer_bytes,b_point,count);
count926drivers/scsi/st.cfilp->f_pos += count;
count927drivers/scsi/st.c(STp->buffer)->buffer_bytes += count;
count928drivers/scsi/st.ccount = 0;
count983drivers/scsi/st.cst_read(struct inode * inode, struct file * filp, char * buf, int count)
count1003drivers/scsi/st.ccount > (STp->buffer)->buffer_size &&
count1004drivers/scsi/st.c!enlarge_buffer(STp->buffer, count))
count1008drivers/scsi/st.c(count % STp->block_size) != 0)
count1035drivers/scsi/st.cfor (total = 0; total < count; ) {
count1044drivers/scsi/st.cblks = bytes = count;
count1051drivers/scsi/st.cbytes = count;
count1179drivers/scsi/st.c(STp->buffer)->buffer_bytes, count - total);
count1181drivers/scsi/st.ctransfer = (STp->buffer)->buffer_bytes < count - total ?
count1182drivers/scsi/st.c(STp->buffer)->buffer_bytes : count - total;
count1209drivers/scsi/st.ccount = total;  /* Read only one variable length block */
count203drivers/scsi/t128.cint sig, count;
count207drivers/scsi/t128.cfor (count = 0; current_override < NO_OVERRIDES; ++current_override) {
count274drivers/scsi/t128.c++count;
count276drivers/scsi/t128.creturn count;
count119drivers/sound/ad1848.cstatic void     ad1848_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count120drivers/sound/ad1848.cstatic void     ad1848_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count819drivers/sound/ad1848.cad1848_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count824drivers/sound/ad1848.ccnt = count;
count855drivers/sound/ad1848.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count871drivers/sound/ad1848.cad1848_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count876drivers/sound/ad1848.ccnt = count;
count906drivers/sound/ad1848.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count189drivers/sound/audio.caudio_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
count197drivers/sound/audio.cc = count;
count209drivers/sound/audio.cif (!count)      /*
count286drivers/sound/audio.creturn count;
count290drivers/sound/audio.caudio_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count298drivers/sound/audio.cc = count;
count354drivers/sound/audio.creturn count - c;
count1740drivers/sound/configure.cint             count;
count1752drivers/sound/configure.ccount = read (fd, &c, 1);
count1753drivers/sound/configure.cif (count == 0)
count151drivers/sound/dev_table.hint count, int intrflag, int dma_restart);
count153drivers/sound/dev_table.hint count, int intrflag, int dma_restart);
count195drivers/sound/dev_table.hint offs, int count, int pmgr_flag);
count509drivers/sound/dev_table.hint count, int dma_mode, int autoinit);
count605drivers/sound/dmabuf.cint             bytes, count;
count615drivers/sound/dmabuf.ccount = (fact >> 16) & 0xffff;
count617drivers/sound/dmabuf.cif (count == 0)
count618drivers/sound/dmabuf.ccount = MAX_SUB_BUFFERS;
count623drivers/sound/dmabuf.cif (count < 2)
count627drivers/sound/dmabuf.cdmap->max_fragments = count;
count637drivers/sound/dmabuf.creturn snd_ioctl_return ((int *) arg, bytes | (count << 16));
count1075drivers/sound/dmabuf.cDMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
count1120drivers/sound/dmabuf.cset_dma_count (chan, count);
count1125drivers/sound/dmabuf.creturn count;
count1482drivers/sound/dmabuf.cDMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode)
count1509drivers/sound/gus_wave.cint offs, int count, int pmgr_flag)
count1525drivers/sound/gus_wave.cif (count < sizeof_patch)
count1531drivers/sound/gus_wave.ccount -= sizeof_patch;
count1554drivers/sound/gus_wave.cif (count < patch.len)
count1557drivers/sound/gus_wave.ccount, (int) patch.len);
count1558drivers/sound/gus_wave.cpatch.len = count;
count2260drivers/sound/gus_wave.cint             this_one, count;
count2268drivers/sound/gus_wave.ccount = total_count / gus_sampling_channels;
count2278drivers/sound/gus_wave.cpcm_datasize[this_one] = count;
count2284drivers/sound/gus_wave.cDMAbuf_start_dma (dev, buf + (chn * count), count, DMA_MODE_WRITE);
count2318drivers/sound/gus_wave.cif (!pcm_active && (pcm_qlen > 0 || count < pcm_bsize))
count2347drivers/sound/gus_wave.cgus_sampling_start_input (int dev, unsigned long buf, int count,
count2356drivers/sound/gus_wave.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count54drivers/sound/maui.cint offs, int count, int pmgr_flag) = NULL;
count102drivers/sound/maui.cint offs, int count, int pmgr_flag)
count111drivers/sound/maui.creturn orig_load_patch (dev, format, addr, offs, count, pmgr_flag);
count118drivers/sound/maui.cif (count < hdr_size)
count124drivers/sound/maui.ccount -= hdr_size;
count133drivers/sound/maui.cif (count < header.len)
count136drivers/sound/maui.ccount, (int) header.len);
count137drivers/sound/maui.cheader.len = count;
count500drivers/sound/midi_synth.cint offs, int count, int pmgr_flag)
count521drivers/sound/midi_synth.cif (count < hdr_size)
count527drivers/sound/midi_synth.ccount -= hdr_size;
count536drivers/sound/midi_synth.cif (count < sysex.len)
count539drivers/sound/midi_synth.ccount, (int) sysex.len);
count540drivers/sound/midi_synth.csysex.len = count;
count11drivers/sound/midi_synth.hint offs, int count, int pmgr_flag);
count339drivers/sound/midibuf.cMIDIbuf_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
count347drivers/sound/midibuf.cif (!count)
count355drivers/sound/midibuf.cwhile (c < count)
count389drivers/sound/midibuf.cif (n > (count - c))
count390drivers/sound/midibuf.cn = count - c;
count407drivers/sound/midibuf.cMIDIbuf_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count450drivers/sound/midibuf.cif (n > count)
count451drivers/sound/midibuf.cn = count;
count880drivers/sound/opl3.cint offs, int count, int pmgr_flag)
count884drivers/sound/opl3.cif (count < sizeof (ins))
count265drivers/sound/pas2_pcm.cpas_pcm_output_block (int dev, unsigned long buf, int count,
count270drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static void pas_pcm_output_block(char *buf = %P, int count = %X)\n", buf, count));
count272drivers/sound/pas2_pcm.ccnt = count;
count290drivers/sound/pas2_pcm.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count293drivers/sound/pas2_pcm.ccount >>= 1;
count295drivers/sound/pas2_pcm.cif (count != pcm_count)
count299drivers/sound/pas2_pcm.cpas_write (count & 0xff, SAMPLE_BUFFER_COUNTER);
count300drivers/sound/pas2_pcm.cpas_write ((count >> 8) & 0xff, SAMPLE_BUFFER_COUNTER);
count303drivers/sound/pas2_pcm.cpcm_count = count;
count314drivers/sound/pas2_pcm.cpas_pcm_start_input (int dev, unsigned long buf, int count,
count320drivers/sound/pas2_pcm.cTRACE (printk ("pas2_pcm.c: static void pas_pcm_start_input(char *buf = %P, int count = %X)\n", buf, count));
count322drivers/sound/pas2_pcm.ccnt = count;
count337drivers/sound/pas2_pcm.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count340drivers/sound/pas2_pcm.ccount >>= 1;
count342drivers/sound/pas2_pcm.cif (count != pcm_count)
count346drivers/sound/pas2_pcm.cpas_write (count & 0xff, SAMPLE_BUFFER_COUNTER);
count347drivers/sound/pas2_pcm.cpas_write ((count >> 8) & 0xff, SAMPLE_BUFFER_COUNTER);
count350drivers/sound/pas2_pcm.cpcm_count = count;
count94drivers/sound/patmgr.cpmgr_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count99drivers/sound/patmgr.cif (count != sizeof (struct patmgr_info))
count134drivers/sound/patmgr.cmemcpy_tofs (&((buf)[0]), (char *) mbox[dev], count);
count145drivers/sound/patmgr.creturn count;
count149drivers/sound/patmgr.cpmgr_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
count153drivers/sound/patmgr.cif (count < 4)
count170drivers/sound/patmgr.cbuf, 4, count, 1);
count173drivers/sound/patmgr.cif (count != sizeof (struct patmgr_info))
count189drivers/sound/patmgr.cmemcpy_fromfs (&((char *) mbox[dev])[4], &((buf)[4]), count - 4);
count203drivers/sound/patmgr.creturn count;
count247drivers/sound/pss.cint             i, limit, val, count;
count265drivers/sound/pss.ccount = 1;
count280drivers/sound/pss.cif (count >= size && flags & CPF_LAST)
count285drivers/sound/pss.ccount, size);
count291drivers/sound/pss.ccount++;
count62drivers/sound/sb16_dsp.cstatic void     sb16_dsp_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count63drivers/sound/sb16_dsp.cstatic void     sb16_dsp_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart);
count264drivers/sound/sb16_dsp.csb16_dsp_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count268drivers/sound/sb16_dsp.ccnt = count;
count274drivers/sound/sb16_dsp.cprintk ("output_block: %x %d %d\n", buf, count, intrflag);
count305drivers/sound/sb16_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count323drivers/sound/sb16_dsp.csb16_dsp_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count327drivers/sound/sb16_dsp.ccnt = count;
count333drivers/sound/sb16_dsp.cprintk ("start_input: %x %d %d\n", buf, count, intrflag);
count364drivers/sound/sb16_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count396drivers/sound/sb_dsp.csb_dsp_output_block (int dev, unsigned long buf, int count,
count404drivers/sound/sb_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE);
count409drivers/sound/sb_dsp.ccount >>= 1;
count410drivers/sound/sb_dsp.ccount--;
count411drivers/sound/sb_dsp.cdsp_count = count;
count451drivers/sound/sb_dsp.csb_dsp_start_input (int dev, unsigned long buf, int count, int intrflag,
count469drivers/sound/sb_dsp.cDMAbuf_start_dma (dev, buf, count, DMA_MODE_READ);
count473drivers/sound/sb_dsp.ccount >>= 1;
count474drivers/sound/sb_dsp.ccount--;
count475drivers/sound/sb_dsp.cdsp_count = count;
count104drivers/sound/sequencer.csequencer_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count106drivers/sound/sequencer.cint             c = count, p = 0;
count117drivers/sound/sequencer.creturn pmgr_read (dev - 1, file, buf, count);
count167drivers/sound/sequencer.creturn count - c;
count265drivers/sound/sequencer.csequencer_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
count274drivers/sound/sequencer.cDEB (printk ("sequencer_write(dev=%d, count=%d)\n", dev, count));
count282drivers/sound/sequencer.creturn pmgr_write (dev - 1, file, buf, count);
count284drivers/sound/sequencer.cc = count;
count323drivers/sound/sequencer.creturn count - c;
count371drivers/sound/sequencer.cint             processed = count - c;
count390drivers/sound/sequencer.creturn count;      /* This will "eat" chunks shorter than 4 bytes (if written
count13drivers/sound/sound_calls.hint DMAbuf_start_dma (int dev, unsigned long physaddr, int count, int dma_mode);
count26drivers/sound/sound_calls.hint audio_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count27drivers/sound/sound_calls.hint audio_write (int dev, struct fileinfo *file, const snd_rw_buf *buf, int count);
count41drivers/sound/sound_calls.hint sequencer_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count42drivers/sound/sound_calls.hint sequencer_write (int dev, struct fileinfo *file, const snd_rw_buf *buf, int count);
count61drivers/sound/sound_calls.hint MIDIbuf_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count62drivers/sound/sound_calls.hint MIDIbuf_write (int dev, struct fileinfo *file, const snd_rw_buf *buf, int count);
count68drivers/sound/sound_calls.hvoid MIDIbuf_bytes_received(int dev, unsigned char *buf, int count);
count81drivers/sound/sound_calls.hvoid request_sound_timer (int count);
count90drivers/sound/sound_calls.hint sound_read_sw (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count91drivers/sound/sound_calls.hint sound_write_sw (int dev, struct fileinfo *file, const snd_rw_buf *buf, int count);
count197drivers/sound/sound_calls.hint pmgr_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count);
count198drivers/sound/sound_calls.hint pmgr_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count);
count239drivers/sound/sound_calls.hint pss_read (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count240drivers/sound/sound_calls.hint pss_write (int dev, struct fileinfo *file, snd_rw_buf *buf, int count);
count310drivers/sound/sound_switch.cread_status (snd_rw_buf * buf, int count)
count317drivers/sound/sound_switch.cl = count;
count332drivers/sound/sound_switch.csound_read_sw (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
count334drivers/sound/sound_switch.cDEB (printk ("sound_read_sw(dev=%d, count=%d)\n", dev, count));
count339drivers/sound/sound_switch.creturn read_status (buf, count);
count346drivers/sound/sound_switch.creturn audio_read (dev, file, buf, count);
count353drivers/sound/sound_switch.creturn sequencer_read (dev, file, buf, count);
count359drivers/sound/sound_switch.creturn MIDIbuf_read (dev, file, buf, count);
count370drivers/sound/sound_switch.csound_write_sw (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
count373drivers/sound/sound_switch.cDEB (printk ("sound_write_sw(dev=%d, count=%d)\n", dev, count));
count381drivers/sound/sound_switch.creturn sequencer_write (dev, file, buf, count);
count389drivers/sound/sound_switch.creturn audio_write (dev, file, buf, count);
count395drivers/sound/sound_switch.creturn MIDIbuf_write (dev, file, buf, count);
count402drivers/sound/sound_switch.creturn count;
count77drivers/sound/soundcard.csound_read (struct inode *inode, struct file *file, char *buf, int count)
count85drivers/sound/soundcard.creturn sound_read_sw (dev, &files[dev], buf, count);
count89drivers/sound/soundcard.csound_write (struct inode *inode, struct file *file, const char *buf, int count)
count97drivers/sound/soundcard.creturn sound_write_sw (dev, &files[dev], buf, count);
count502drivers/sound/soundcard.crequest_sound_timer (int count)
count506drivers/sound/soundcard.cif (count < 0)
count507drivers/sound/soundcard.ccount = jiffies + (-count);
count509drivers/sound/soundcard.ccount += seq_time;
count513drivers/sound/soundcard.cseq_timer.expires = ((count - jiffies)) + jiffies;
count165drivers/sound/sscape.chost_write (struct sscape_info *devc, unsigned char *data, int count)
count177drivers/sound/sscape.cfor (i = 0; i < count; i++)
count823drivers/sound/sscape.csscape_audio_output_block (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count828drivers/sound/sscape.csscape_audio_start_input (int dev, unsigned long buf, int count, int intrflag, int dma_restart)
count81drivers/sound/uart6850.cint             count;
count83drivers/sound/uart6850.ccount = 10;
count85drivers/sound/uart6850.cwhile (count)      /*
count92drivers/sound/uart6850.ccount = 100;
count98drivers/sound/uart6850.cwhile (!input_avail () && count)
count99drivers/sound/uart6850.ccount--;
count23fs/block_dev.cint block_write(struct inode * inode, struct file * filp, const char * buf, int count)
count63fs/block_dev.cwhile (count>0) {
count67fs/block_dev.cif (chars > count)
count68fs/block_dev.cchars=count;
count122fs/block_dev.ccount -= chars;
count160fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
count205fs/block_dev.cif (left > count)
count206fs/block_dev.cleft = count;
count583fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
count631fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1)
count655fs/buffer.cif (mem_map[MAP_NR((unsigned long) bh->b_data)].count != 1 ||
count781fs/buffer.celse if (mem_map[MAP_NR((unsigned long) buf->b_data)].count > 1)
count835fs/buffer.cif (mem_map[MAP_NR(buf->b_data)].count != 1) {
count1078fs/buffer.cmem_map[MAP_NR(page)].count++;
count1135fs/buffer.cmem_map[MAP_NR(address)].count++;
count1340fs/buffer.creturn !mem_map[MAP_NR(page)].count;
count1548fs/buffer.cif(mem_map[MAP_NR(((unsigned long) bh->b_data))].count !=1) shared++;
count1582fs/buffer.cif(mem_map[MAP_NR(page)].count != 1) return 0;
count488fs/exec.cchar * addr, unsigned long count, int to_kmem)
count515fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
count518fs/exec.cresult = verify_area(VERIFY_WRITE, addr, count);
count521fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
count537fs/exec.cif (current->mm->count > 1) {
count546fs/exec.cmm->count = 1;
count551fs/exec.ccurrent->mm->count--;
count630fs/exec.cif ((bprm.argc = count(argv)) < 0)
count632fs/exec.cif ((bprm.envc = count(envp)) < 0)
count23fs/ext/dir.cstatic int ext_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count72fs/ext/file.cstatic int ext_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count96fs/ext/file.cif (left > count)
count97fs/ext/file.cleft = count;
count197fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
count221fs/ext/file.cwhile (written<count) {
count229fs/ext/file.cif (c > count-written)
count230fs/ext/file.cc = count-written;
count61fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock || efb->count == 254) {
count72fs/ext/freelists.cefb->count = 0;
count75fs/ext/freelists.cefb->free[efb->count++] = block;
count98fs/ext/freelists.cif (efb->count) {
count99fs/ext/freelists.cj = efb->free[--efb->count];
count145fs/ext/freelists.cunsigned long count, block;
count149fs/ext/freelists.ccount = 0;
count152fs/ext/freelists.ccount = efb->count + 1;
count160fs/ext/freelists.ccount += efb->count + 1;
count167fs/ext/freelists.csb->u.ext_sb.s_freeblockscount, count);
count169fs/ext/freelists.creturn count;
count215fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeinodeblock || efi->count == 14) {
count227fs/ext/freelists.cefi->count = 0;
count231fs/ext/freelists.cefi->free[efi->count++] = ino;
count257fs/ext/freelists.cif (efi->count) {
count258fs/ext/freelists.cj = efi->free[--efi->count];
count305fs/ext/freelists.cunsigned long count, block, ino;
count309fs/ext/freelists.ccount = 0;
count313fs/ext/freelists.ccount = efi->count + 1;
count328fs/ext/freelists.ccount += efi->count + 1;
count335fs/ext/freelists.csb->u.ext_sb.s_freeinodescount, count);
count337fs/ext/freelists.creturn count;
count169fs/ext2/balloc.cunsigned long count)
count187fs/ext2/balloc.c(block + count) > es->s_blocks_count) {
count190fs/ext2/balloc.c"block = %lu, count = %lu", block, count);
count200fs/ext2/balloc.cif (bit + count > EXT2_BLOCKS_PER_GROUP(sb))
count204fs/ext2/balloc.cblock, count);
count210fs/ext2/balloc.c(in_range (gdp->bg_block_bitmap, block, count) ||
count211fs/ext2/balloc.cin_range (gdp->bg_inode_bitmap, block, count) ||
count214fs/ext2/balloc.cin_range (block + count - 1, gdp->bg_inode_table,
count219fs/ext2/balloc.cblock, count);
count221fs/ext2/balloc.cfor (i = 0; i < count; i++) {
count27fs/ext2/dir.cchar * buf, int count)
count81fs/ext2/file.cchar * buf, int count)
count110fs/ext2/file.cif (left > count)
count111fs/ext2/file.cleft = count;
count232fs/ext2/file.cconst char * buf, int count)
count279fs/ext2/file.cwhile (count > 0) {
count291fs/ext2/file.ccount -= c;
count292fs/ext2/file.cif (count < 0)
count293fs/ext2/file.cc += count;
count187fs/hpfs/hpfs_fs.cchar *buf, int count);
count811fs/hpfs/hpfs_fs.cunsigned n, count, n_bands;
count828fs/hpfs/hpfs_fs.ccount = 0;
count837fs/hpfs/hpfs_fs.ccount += count_one_bitmap(s->s_dev, bitmaps[n]);
count840fs/hpfs/hpfs_fs.creturn count;
count851fs/hpfs/hpfs_fs.cunsigned i, count;
count857fs/hpfs/hpfs_fs.ccount = 0;
count860fs/hpfs/hpfs_fs.ccount += (test_bit(i, bits) != 0);
count863fs/hpfs/hpfs_fs.creturn count;
count873fs/hpfs/hpfs_fs.cchar *buf, int count)
count886fs/hpfs/hpfs_fs.cif (count > inode->i_size - (off_t) filp->f_pos)
count887fs/hpfs/hpfs_fs.ccount = inode->i_size - filp->f_pos;
count890fs/hpfs/hpfs_fs.cwhile (count > 0) {
count902fs/hpfs/hpfs_fs.cif (n > count)
count903fs/hpfs/hpfs_fs.cn = count;
count932fs/hpfs/hpfs_fs.cif (count > inode->i_size - (off_t) filp->f_pos - n + n0)
count933fs/hpfs/hpfs_fs.ccount = inode->i_size - filp->f_pos - n + n0;
count943fs/hpfs/hpfs_fs.ccount -= n0;
count1574fs/hpfs/hpfs_fs.cchar *buf, int count)
count464fs/inode.cinode->i_sem.count = 1;
count117fs/isofs/file.cstatic int isofs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count141fs/isofs/file.cif (left > count)
count142fs/isofs/file.cleft = count;
count17fs/minix/dir.cstatic int minix_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count66fs/minix/file.cstatic int minix_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count90fs/minix/file.cif (left > count)
count91fs/minix/file.cleft = count;
count189fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
count209fs/minix/file.cwhile (written < count) {
count217fs/minix/file.cif (c > count-written)
count218fs/minix/file.cc = count-written;
count23fs/msdos/dir.cstatic int msdos_dir_read(struct inode * inode,struct file * filp, char * buf,int count)
count106fs/msdos/fat.cint count;
count110fs/msdos/fat.cfor (count = 0; count < FAT_CACHE; count++) {
count111fs/msdos/fat.ccache[count].device = 0;
count112fs/msdos/fat.ccache[count].next = count == FAT_CACHE-1 ? NULL :
count113fs/msdos/fat.c&cache[count+1];
count227fs/msdos/fat.cint nr,count;
count231fs/msdos/fat.ccount = 0;
count232fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&nr); count < cluster;
count233fs/msdos/fat.ccount++) {
count153fs/msdos/file.cint count)
count157fs/msdos/file.cchar *end   = buf + count;
count172fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
count182fs/msdos/file.cPRINTK (("#### ino %ld pos %ld size %ld count %d\n",inode->i_ino,filp->f_pos,inode->i_size,count));
count188fs/msdos/file.cint count_max = (filp->f_pos & (SECTOR_SIZE-1)) + count;
count207fs/msdos/file.cPRINTK (("count %d ahead %d nblist %d\n",count,read_ahead[MAJOR(inode->i_dev)],pre.nblist));
count223fs/msdos/file.cPRINTK (("file_read pos %ld nblist %d %d %d\n",filp->f_pos,pre.nblist,pre.fetched,count));
count252fs/msdos/file.cPRINTK (("--- %d -> %d\n",count,(int)(buf-start)));
count267fs/msdos/file.cint count)
count293fs/msdos/file.cif (count <= 0) return 0;
count295fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
count303fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
count331fs/msdos/file.cfor (size = 0; size < count && left; size++) {
count119fs/msdos/misc.cint count,nr,limit,last,curr,sector,last_sector,file_cluster;
count128fs/msdos/misc.cfor (count = 0; count < limit; count++) {
count129fs/msdos/misc.cnr = ((count+MSDOS_SB(inode->i_sb)->prev_free) % limit)+2;
count132fs/msdos/misc.cPRINTK (("cnt = %d --",count));
count136fs/msdos/misc.cMSDOS_SB(inode->i_sb)->prev_free = (count+MSDOS_SB(inode->i_sb)->
count138fs/msdos/misc.cif (count >= limit) {
count417fs/msdos/misc.cint count,cluster;
count419fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->dir_entries/MSDOS_DPS; count++) {
count420fs/msdos/misc.cif ((cluster = raw_scan_sector(sb,MSDOS_SB(sb)->dir_start+count,
count436fs/msdos/misc.cint count,cluster;
count442fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->cluster_size; count++) {
count445fs/msdos/misc.ccount,name,number,ino,res_bh,res_de,scantype)) >= 0)
count523fs/msdos/misc.cint count;
count525fs/msdos/misc.ccount = 0;
count527fs/msdos/misc.c(void) raw_scan_root(dir->i_sb,NULL,&count,NULL,NULL,NULL,SCAN_ANY);
count531fs/msdos/misc.cNULL,&count,NULL,NULL,NULL,SCAN_ANY);
count533fs/msdos/misc.creturn count;
count22fs/nfs/dir.cint count);
count73fs/nfs/dir.cint count)
count95fs/nfs/file.cint count)
count112fs/nfs/file.cif (pos + count > inode->i_size)
count113fs/nfs/file.ccount = inode->i_size - pos;
count114fs/nfs/file.cif (count <= 0)
count121fs/nfs/file.c&& (cache[i].file_pos + cache[i].len >= pos + count)
count128fs/nfs/file.cmemcpy_tofs(buf, cache[i].buf + pos - cache[i].file_pos, count);
count130fs/nfs/file.cfile->f_pos += count;
count131fs/nfs/file.creturn count;
count135fs/nfs/file.cfor (i = 0; i < count - n; i += n) {
count160fs/nfs/file.chunk = count - i;
count190fs/nfs/file.cint count)
count204fs/nfs/file.cif (count <= 0)
count218fs/nfs/file.cfor (i = 0; i < count; i += n) {
count219fs/nfs/file.chunk = count - i;
count727fs/nfs/nfsroot.cif (current->files->count > 0)
count728fs/nfs/nfsroot.ccurrent->files->count--;
count376fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr, int fs)
count383fs/nfs/proc.cPRINTK("NFS call  read %d @ %d\n", count, offset);
count390fs/nfs/proc.c*p++ = htonl(count);
count391fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count400fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count, fs))) {
count422fs/nfs/proc.cint offset, int count, const char *data, struct nfs_fattr *fattr)
count428fs/nfs/proc.cPRINTK("NFS call  write %d @ %d\n", count, offset);
count436fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count437fs/nfs/proc.cp = xdr_encode_data(p, data, count);
count726fs/nfs/proc.cint cookie, int count, struct nfs_entry *entry)
count735fs/nfs/proc.cPRINTK("NFS call  readdir %d @ %d\n", count, cookie);
count751fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
count760fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
count761fs/nfs/proc.c|| (i < count && *p++);
count25fs/pipe.cstatic int pipe_read(struct inode * inode, struct file * filp, char * buf, int count)
count48fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
count50fs/pipe.cif (chars > count)
count51fs/pipe.cchars = count;
count59fs/pipe.ccount -= chars;
count72fs/pipe.cstatic int pipe_write(struct inode * inode, struct file * filp, const char * buf, int count)
count82fs/pipe.cif (count <= PIPE_BUF)
count83fs/pipe.cfree = count;
count86fs/pipe.cwhile (count>0) {
count99fs/pipe.cwhile (count>0 && (free = PIPE_FREE(*inode))) {
count101fs/pipe.cif (chars > count)
count102fs/pipe.cchars = count;
count108fs/pipe.ccount -= chars;
count124fs/pipe.cstatic int bad_pipe_r(struct inode * inode, struct file * filp, char * buf, int count)
count129fs/pipe.cstatic int bad_pipe_w(struct inode * inode, struct file * filp, const char * buf, int count)
count203fs/pipe.cstatic int connect_read(struct inode * inode, struct file * filp, char * buf, int count)
count216fs/pipe.creturn pipe_read(inode,filp,buf,count);
count57fs/proc/array.cstatic int read_core(struct inode * inode, struct file * file,char * buf, int count)
count77fs/proc/array.cif (count < 0)
count82fs/proc/array.cif (count > memsize - p)
count83fs/proc/array.ccount = memsize - p;
count86fs/proc/array.cif (p < sizeof(struct user) && count > 0) {
count87fs/proc/array.ccount1 = count;
count94fs/proc/array.ccount -= count1;
count98fs/proc/array.cwhile (count > 0 && p < PAGE_SIZE + FIRST_MAPPED) {
count102fs/proc/array.ccount--;
count105fs/proc/array.cmemcpy_tofs(buf, (void *) (PAGE_OFFSET + p - PAGE_SIZE), count);
count106fs/proc/array.cread += count;
count130fs/proc/array.cstatic int read_profile(struct inode *inode, struct file *file, char *buf, int count)
count137fs/proc/array.cif (count < 0)
count141fs/proc/array.cif (count > (prof_len+1)*sizeof(unsigned long) - p)
count142fs/proc/array.ccount = (prof_len+1)*sizeof(unsigned long) - p;
count145fs/proc/array.cwhile (p < sizeof(unsigned long) && count > 0) {
count147fs/proc/array.cbuf++; p++; count--; read++;
count150fs/proc/array.cmemcpy_tofs(buf,(void *)pnt,count);
count151fs/proc/array.cread += count;
count157fs/proc/array.cstatic int write_profile(struct inode * inode, struct file * file, const char * buf, int count)
count163fs/proc/array.creturn count;
count392fs/proc/array.cint count = 0;
count406fs/proc/array.c} while (count++ < 16);
count574fs/proc/array.cif (mem_map[MAP_NR(pte_page(page))].count > 1)
count673fs/proc/array.cstatic int read_maps (int pid, struct file * file, char * buf, int count)
count685fs/proc/array.cif (!(*p)->mm || count == 0)
count735fs/proc/array.cif (i > count)
count736fs/proc/array.ci = count;
count738fs/proc/array.cdestptr += i; count -= i;
count747fs/proc/array.cif (count == 0)
count852fs/proc/array.cstatic int array_read(struct inode * inode, struct file * file,char * buf, int count)
count860fs/proc/array.cif (count < 0)
count862fs/proc/array.cif (count > PROC_BLOCK_SIZE)
count863fs/proc/array.ccount = PROC_BLOCK_SIZE;
count871fs/proc/array.c&start, file->f_pos, count);
count880fs/proc/array.ccount = length;
count887fs/proc/array.cif (count + file->f_pos > length)
count888fs/proc/array.ccount = length - file->f_pos;
count889fs/proc/array.cend = count + file->f_pos;
count890fs/proc/array.cmemcpy_tofs(buf, (char *) page + file->f_pos, count);
count894fs/proc/array.creturn count;
count928fs/proc/array.cstatic int arraylong_read (struct inode * inode, struct file * file, char * buf, int count)
count933fs/proc/array.cif (count < 0)
count938fs/proc/array.creturn read_maps(pid, file, buf, count);
count19fs/proc/kmsg.casmlinkage int sys_syslog(int type, char * bug, int count);
count31fs/proc/kmsg.cstatic int kmsg_read(struct inode * inode, struct file * file,char * buf, int count)
count33fs/proc/kmsg.creturn sys_syslog(2,buf,count);
count26fs/proc/mem.cstatic int check_range(struct task_struct * tsk, unsigned long addr, int count)
count38fs/proc/mem.cwhile ((retval = vma->vm_end - addr) < count) {
count48fs/proc/mem.cif (retval > count)
count49fs/proc/mem.cretval = count;
count53fs/proc/mem.cstatic int mem_read(struct inode * inode, struct file * file,char * buf, int count)
count64fs/proc/mem.cif (count < 0)
count77fs/proc/mem.ccount = check_range(tsk, addr, count);
count78fs/proc/mem.cif (count < 0)
count79fs/proc/mem.creturn count;
count81fs/proc/mem.cwhile (count > 0) {
count105fs/proc/mem.cif (i > count)
count106fs/proc/mem.ci = count;
count110fs/proc/mem.ccount -= i;
count118fs/proc/mem.cstatic int mem_write(struct inode * inode, struct file * file,char * buf, int count)
count129fs/proc/mem.cif (count < 0)
count143fs/proc/mem.cwhile (count > 0) {
count169fs/proc/mem.cif (i > count)
count170fs/proc/mem.ci = count;
count174fs/proc/mem.ccount -= i;
count294fs/proc/mem.cmem_map[MAP_NR(pte_page(*src_table))].count++;
count41fs/proc/net.cchar * buf, int count)
count44fs/proc/net.cint bytes=count;
count49fs/proc/net.cif (count < 0)
count33fs/proc/scsi.cchar * buf, int count);
count35fs/proc/scsi.cconst char * buf, int count);
count103fs/proc/scsi.cchar * buf, int count)
count106fs/proc/scsi.cint bytes = count;
count112fs/proc/scsi.cif (count < -1)      /* Normally I wouldn't do this, */ 
count119fs/proc/scsi.cwhile(bytes > 0 || count == -1) {  
count121fs/proc/scsi.cif(bytes > PROC_BLOCK_SIZE || count == -1)
count145fs/proc/scsi.cif (count != -1)
count162fs/proc/scsi.cconst char * buf, int count)
count167fs/proc/scsi.cif(count > PROC_BLOCK_SIZE) {
count174fs/proc/scsi.cmemcpy_fromfs(page, buf, count);
count175fs/proc/scsi.cret = dispatch_scsi_info_ptr(inode->i_ino, page, 0, 0, count, 1);
count103fs/read_write.casmlinkage int sys_read(unsigned int fd,char * buf,unsigned int count)
count115fs/read_write.cif (!count)
count117fs/read_write.cerror = verify_area(VERIFY_WRITE,buf,count);
count120fs/read_write.creturn file->f_op->read(inode,file,buf,count);
count123fs/read_write.casmlinkage int sys_write(unsigned int fd,char * buf,unsigned int count)
count136fs/read_write.cif (!count)
count138fs/read_write.cerror = verify_area(VERIFY_READ,buf,count);
count142fs/read_write.cwritten = file->f_op->write(inode,file,buf,count);
count158fs/read_write.cconst struct iovec * iov, long count, long size)
count170fs/read_write.cmsg.msg_iovlen = count;
count188fs/read_write.cconst struct iovec * vector, unsigned long count)
count199fs/read_write.cif (!count)
count201fs/read_write.cif (count > MAX_IOVEC)
count203fs/read_write.cretval = verify_area(VERIFY_READ, vector, count*sizeof(*vector));
count206fs/read_write.cmemcpy_fromfs(iov, vector, count*sizeof(*vector));
count208fs/read_write.cfor (i = 0 ; i < count ; i++) {
count221fs/read_write.creturn sock_readv_writev(type, inode, file, iov, count, tot_len);
count230fs/read_write.cwhile (count > 0) {
count237fs/read_write.ccount--;
count252fs/read_write.casmlinkage int sys_readv(unsigned long fd, const struct iovec * vector, long count)
count261fs/read_write.creturn do_readv_writev(VERIFY_WRITE, inode, file, vector, count);
count264fs/read_write.casmlinkage int sys_writev(unsigned long fd, const struct iovec * vector, long count)
count273fs/read_write.creturn do_readv_writev(VERIFY_READ, inode, file, vector, count);
count36fs/readdir.cint count;
count44fs/readdir.cif (buf->count)
count46fs/readdir.cbuf->count++;
count56fs/readdir.casmlinkage int old_readdir(unsigned int fd, void * dirent, unsigned int count)
count69fs/readdir.cbuf.count = 0;
count74fs/readdir.creturn buf.count;
count91fs/readdir.cint count;
count102fs/readdir.cif (reclen > buf->count)
count115fs/readdir.cbuf->count -= reclen;
count119fs/readdir.casmlinkage int sys_getdents(unsigned int fd, void * dirent, unsigned int count)
count130fs/readdir.cerror = verify_area(VERIFY_WRITE, dirent, count);
count135fs/readdir.cbuf.count = count;
count144fs/readdir.creturn count - buf.count;
count88fs/select.cint count;
count119fs/select.ccount = 0;
count128fs/select.ccount++;
count133fs/select.ccount++;
count138fs/select.ccount++;
count143fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
count150fs/select.creturn count;
count22fs/smbfs/dir.csmb_dir_read(struct inode *inode, struct file *filp, char *buf, int count);
count119fs/smbfs/dir.csmb_dir_read(struct inode *inode, struct file *filp, char *buf, int count)
count63fs/smbfs/file.csmb_file_read(struct inode *inode, struct file *file, char *buf, int count)
count87fs/smbfs/file.cif (pos + count > inode->i_size)
count88fs/smbfs/file.ccount = inode->i_size - pos;
count90fs/smbfs/file.cif (count <= 0)
count97fs/smbfs/file.cwhile (already_read < count) {
count103fs/smbfs/file.cto_read = min(65535, count - already_read);
count112fs/smbfs/file.cto_read = min(bufsize, count - already_read);
count140fs/smbfs/file.csmb_file_write(struct inode *inode, struct file *file, const char *buf, int count)
count159fs/smbfs/file.cif (count <= 0)
count178fs/smbfs/file.cwhile (already_written < count) {
count184fs/smbfs/file.cto_write = min(65535, count - already_written);
count193fs/smbfs/file.cto_write = min(bufsize, count - already_written);
count610fs/smbfs/proc.coff_t offset, long count, char *data, int fs)
count619fs/smbfs/proc.cWSET(buf, smb_vwv1, count);
count648fs/smbfs/proc.coff_t offset, long count, char *data)
count653fs/smbfs/proc.cif ((count <= 0) || (count > 65535)) {
count661fs/smbfs/proc.cWSET(buf, smb_vwv3, count);
count665fs/smbfs/proc.cresult = smb_request_read_raw(server, data, count);
count672fs/smbfs/proc.coff_t offset, int count, const char *data)
count678fs/smbfs/proc.cp = smb_setup_header_exclusive(server, SMBwrite, 5, count + 3);
count680fs/smbfs/proc.cWSET(buf, smb_vwv1, count);
count685fs/smbfs/proc.cWSET(p, 0, count);
count686fs/smbfs/proc.cmemcpy_fromfs(p+2, data, count);
count700fs/smbfs/proc.coff_t offset, long count, const char *data)
count705fs/smbfs/proc.cif ((count <= 0) || (count > 65535)) {
count712fs/smbfs/proc.cWSET(buf, smb_vwv1, count);
count730fs/smbfs/proc.cresult = smb_request_write_raw(server, data, count);
count946fs/smbfs/proc.cword count;
count1002fs/smbfs/proc.cp = smb_decode_word(p, &count); /* vwv[0] = count-returned */
count1007fs/smbfs/proc.cif (count <= 0) {
count1011fs/smbfs/proc.cif (bcc != count * SMB_DIRINFO_SIZE + 3) {
count1021fs/smbfs/proc.c(count - 1) * SMB_DIRINFO_SIZE, 
count1026fs/smbfs/proc.cfor (i = 0; i < count; i ++) {
count228fs/sysv/balloc.cint count, old_count;
count235fs/sysv/balloc.ccount = 0;
count244fs/sysv/balloc.ccount++;
count296fs/sysv/balloc.ccount++;
count310fs/sysv/balloc.cif (count != old_count) {
count311fs/sysv/balloc.cprintk("sysv_count_free_blocks: free block count was %d, correcting to %d\n",old_count,count);
count313fs/sysv/balloc.c*sb->sv_sb_total_free_blocks = (sb->sv_convert ? to_coh_ulong(count) : count);
count319fs/sysv/balloc.creturn count;
count321fs/sysv/balloc.cint count;
count323fs/sysv/balloc.ccount = *sb->sv_sb_total_free_blocks;
count325fs/sysv/balloc.ccount = from_coh_ulong(count);
count326fs/sysv/balloc.creturn count;
count24fs/sysv/dir.cstatic int sysv_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count72fs/sysv/file.cint sysv_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count98fs/sysv/file.cif (left > count)
count99fs/sysv/file.cleft = count;
count199fs/sysv/file.cstatic int sysv_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
count227fs/sysv/file.cwhile (written<count) {
count235fs/sysv/file.cif (c > count-written)
count236fs/sysv/file.cc = count-written;
count182fs/sysv/ialloc.cint j,block,count;
count185fs/sysv/ialloc.ccount = 0;
count202fs/sysv/ialloc.ccount++;
count205fs/sysv/ialloc.cif (count != *sb->sv_sb_total_free_inodes) {
count206fs/sysv/ialloc.cprintk("sysv_count_free_inodes: free inode count was %d, correcting to %d\n",(short)(*sb->sv_sb_total_free_inodes),count);
count208fs/sysv/ialloc.c*sb->sv_sb_total_free_inodes = count;
count214fs/sysv/ialloc.creturn count;
count31fs/umsdos/dir.cint count)
count39fs/umsdos/dir.cint count;
count56fs/umsdos/dir.cif (d->count == 0){
count65fs/umsdos/dir.cd->count = 1;
count154fs/umsdos/dir.cbufk.count = 0;
count268fs/umsdos/dir.cint count = 0;
count276fs/umsdos/dir.cbufk.count = 0;
count278fs/umsdos/dir.cif (bufk.count == 0) break;
count279fs/umsdos/dir.ccount += bufk.count;
count281fs/umsdos/dir.cPRINTK (("UMSDOS_readdir out %d count %d pos %Ld\n",ret,count
count283fs/umsdos/dir.creturn count?:ret;
count30fs/umsdos/emd.cint count)
count35fs/umsdos/emd.cret = msdos_file_read(inode,filp,buf,count);
count46fs/umsdos/emd.cint count)
count51fs/umsdos/emd.cret = msdos_file_write(inode,filp,buf,count);
count67fs/umsdos/emd.cint count)
count71fs/umsdos/emd.cwritten = umsdos_file_write_kmem (emd_dir,filp,buf,count);
count72fs/umsdos/emd.creturn written != count ? -EIO : 0;
count83fs/umsdos/emd.cint count)
count88fs/umsdos/emd.csizeread = umsdos_file_read_kmem (emd_dir,filp,buf,count);
count89fs/umsdos/emd.cif (sizeread != count){
count91fs/umsdos/emd.c,filp->f_pos,sizeread,count);
count31fs/umsdos/file.cint count)
count34fs/umsdos/file.cint ret = msdos_file_read(inode,filp,buf,count);
count48fs/umsdos/file.cint count)
count50fs/umsdos/file.creturn msdos_file_write(inode,filp,buf,count);
count23fs/umsdos/ioctl.cint count;
count39fs/umsdos/ioctl.cif (d->count == 0){
count45fs/umsdos/ioctl.cd->count = 1;
count119fs/umsdos/ioctl.cbufk.count = 0;
count122fs/umsdos/ioctl.cret = bufk.count == 1 ? 1 : 0;
count61fs/xiafs/dir.cstruct file * filp, char * buf, int count)
count70fs/xiafs/file.cxiafs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count89fs/xiafs/file.cif (left > count)
count90fs/xiafs/file.cleft = count;
count190fs/xiafs/file.cxiafs_file_write(struct inode * inode, struct file * filp, const char * buf, int count)
count214fs/xiafs/file.cwhile (written < count) {
count222fs/xiafs/file.cif (c > count-written)
count223fs/xiafs/file.cc = count-written;
count260include/asm-alpha/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count262include/asm-alpha/dma.hcount--;
count264include/asm-alpha/dma.hdma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count265include/asm-alpha/dma.hdma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count267include/asm-alpha/dma.hdma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count268include/asm-alpha/dma.hdma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count287include/asm-alpha/dma.hunsigned short count;
count289include/asm-alpha/dma.hcount = 1 + dma_inb(io_port);
count290include/asm-alpha/dma.hcount += dma_inb(io_port) << 8;
count292include/asm-alpha/dma.hreturn (dmanr<=3)? count : (count<<1);
count23include/asm-alpha/floppy.h#define fd_set_dma_count(count) set_dma_count(FLOPPY_DMA,count)
count87include/asm-alpha/hwrpb.hunsigned long count;
count184include/asm-alpha/io.hextern void insb (unsigned long port, void *dst, unsigned long count);
count185include/asm-alpha/io.hextern void insw (unsigned long port, void *dst, unsigned long count);
count186include/asm-alpha/io.hextern void insl (unsigned long port, void *dst, unsigned long count);
count187include/asm-alpha/io.hextern void outsb (unsigned long port, const void *src, unsigned long count);
count188include/asm-alpha/io.hextern void outsw (unsigned long port, const void *src, unsigned long count);
count189include/asm-alpha/io.hextern void outsl (unsigned long port, const void *src, unsigned long count);
count174include/asm-alpha/pgtable.hextern inline int pte_inuse(pte_t *ptep)  { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
count179include/asm-alpha/pgtable.hmem_map[MAP_NR(ptep)].count++;
count185include/asm-alpha/pgtable.hextern inline int pmd_inuse(pmd_t *pmdp)  { return mem_map[MAP_NR(pmdp)].reserved || mem_map[MAP_NR(pmdp)].count != 1; }
count190include/asm-alpha/pgtable.hmem_map[MAP_NR(pmdp)].count++;
count25include/asm-alpha/string.h#define memset(s, c, count) \
count27include/asm-alpha/string.h__constant_c_memset((s),(0x0101010101010101UL*(unsigned char)c),(count)) : \
count28include/asm-alpha/string.h__memset((s),(c),(count)))
count230include/asm-i386/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count232include/asm-i386/dma.hcount--;
count234include/asm-i386/dma.hdma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count235include/asm-i386/dma.hdma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count237include/asm-i386/dma.hdma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count238include/asm-i386/dma.hdma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count257include/asm-i386/dma.hunsigned short count;
count259include/asm-i386/dma.hcount = 1 + dma_inb(io_port);
count260include/asm-i386/dma.hcount += dma_inb(io_port) << 8;
count262include/asm-i386/dma.hreturn (dmanr<=3)? count : (count<<1);
count23include/asm-i386/floppy.h#define fd_set_dma_count(count) set_dma_count(FLOPPY_DMA,count)
count115include/asm-i386/io.hextern inline void ins##s(unsigned short port, void * addr, unsigned long count) \
count117include/asm-i386/io.h: "=D" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
count120include/asm-i386/io.hextern inline void outs##s(unsigned short port, const void * addr, unsigned long count) \
count122include/asm-i386/io.h: "=S" (addr), "=c" (count) : "d" (port),"0" (addr),"1" (count)); }
count146include/asm-i386/pgtable.hextern inline int pte_inuse(pte_t *ptep)  { return mem_map[MAP_NR(ptep)].reserved || mem_map[MAP_NR(ptep)].count != 1; }
count151include/asm-i386/pgtable.hmem_map[MAP_NR(ptep)].count++;
count31include/asm-i386/string.hextern inline char * strncpy(char * dest,const char *src,size_t count)
count45include/asm-i386/string.h:"S" (src),"D" (dest),"c" (count):"si","di","ax","cx","memory");
count67include/asm-i386/string.hextern inline char * strncat(char * dest,const char * src,size_t count)
count84include/asm-i386/string.h:"S" (src),"D" (dest),"a" (0),"c" (0xffffffff),"g" (count)
count110include/asm-i386/string.hextern inline int strncmp(const char * cs,const char * ct,size_t count)
count127include/asm-i386/string.h:"=a" (__res):"S" (cs),"D" (ct),"c" (count):"si","di","cx");
count444include/asm-i386/string.hextern inline void * memchr(const void * cs,int c,size_t count)
count447include/asm-i386/string.hif (!count)
count456include/asm-i386/string.h:"=D" (__res):"a" (c),"D" (cs),"c" (count)
count461include/asm-i386/string.hextern inline void * __memset_generic(void * s, char c,size_t count)
count468include/asm-i386/string.h:"a" (c),"D" (s),"c" (count)
count474include/asm-i386/string.h#define __constant_count_memset(s,c,count) __memset_generic((s),(c),(count))
count481include/asm-i386/string.hextern inline void * __constant_c_memset(void * s, unsigned long c, size_t count)
count494include/asm-i386/string.h:"a" (c), "q" (count), "c" (count/4), "D" ((long) s)
count501include/asm-i386/string.hextern inline size_t strnlen(const char * s, size_t count)
count514include/asm-i386/string.h:"=a" (__res):"c" (s),"d" (count));
count523include/asm-i386/string.hextern inline void * __constant_c_and_count_memset(void * s, unsigned long pattern, size_t count)
count525include/asm-i386/string.hswitch (count) {
count547include/asm-i386/string.h: "a" (pattern),"c" (count/4),"D" ((long) s) \
count550include/asm-i386/string.hswitch (count % 4) {
count559include/asm-i386/string.h#define __constant_c_x_memset(s, c, count) \
count560include/asm-i386/string.h(__builtin_constant_p(count) ? \
count561include/asm-i386/string.h__constant_c_and_count_memset((s),(c),(count)) : \
count562include/asm-i386/string.h__constant_c_memset((s),(c),(count)))
count564include/asm-i386/string.h#define __memset(s, c, count) \
count565include/asm-i386/string.h(__builtin_constant_p(count) ? \
count566include/asm-i386/string.h__constant_count_memset((s),(c),(count)) : \
count567include/asm-i386/string.h__memset_generic((s),(c),(count)))
count570include/asm-i386/string.h#define memset(s, c, count) \
count572include/asm-i386/string.h__constant_c_x_memset((s),(0x01010101UL*(unsigned char)c),(count)) : \
count573include/asm-i386/string.h__memset((s),(c),(count)))
count267include/asm-i386/unistd.hstatic inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
count59include/asm-m68k/string.hextern inline int strncmp(const char * cs,const char * ct,size_t count)
count63include/asm-m68k/string.hif (!count)
count77include/asm-m68k/string.h: "=a" (cs), "=a" (ct), "=d" (count), "=d" (__res)
count78include/asm-m68k/string.h: "0" (cs), "1" (ct), "2" (count));
count92include/asm-m68k/string.hextern inline void * memset(void * s,char c,size_t count)
count96include/asm-m68k/string.hif (!count)
count102include/asm-m68k/string.h: "=a" (s), "=d" (count)
count103include/asm-m68k/string.h: "0" (s), "d" (c), "1" (count)
count233include/asm-mips/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count235include/asm-mips/dma.hcount--;
count237include/asm-mips/dma.hdma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count238include/asm-mips/dma.hdma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count240include/asm-mips/dma.hdma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count241include/asm-mips/dma.hdma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count260include/asm-mips/dma.hunsigned short count;
count262include/asm-mips/dma.hcount = 1 + dma_inb(io_port);
count263include/asm-mips/dma.hcount += dma_inb(io_port) << 8;
count265include/asm-mips/dma.hreturn (dmanr<=3)? count : (count<<1);
count29include/asm-mips/floppy.h#define fd_set_dma_count(count)    feature->fd_set_dma_count(count)
count80include/asm-mips/io.hextern inline void __ins##s(unsigned int port, void * addr, unsigned long count) {
count96include/asm-mips/io.h: "=r" (addr), "=r" (count) \
count97include/asm-mips/io.h: "0" (addr), "1" (count), "i" (0), "r" (PORT_BASE+port), "I" (i) \
count100include/asm-mips/io.h: "=r" (addr), "=r" (count) \
count101include/asm-mips/io.h: "0" (addr), "1" (count), "i" (port), "r" (PORT_BASE), "I" (i) \
count105include/asm-mips/io.hextern inline void __outs##s(unsigned int port, const void * addr, unsigned long count) {
count121include/asm-mips/io.h: "=r" (addr), "=r" (count) \
count122include/asm-mips/io.h: "0" (addr), "1" (count), "i" (0), "r" (PORT_BASE+port), "I" (i) \
count125include/asm-mips/io.h: "=r" (addr), "=r" (count) \
count126include/asm-mips/io.h: "0" (addr), "1" (count), "i" (port), "r" (PORT_BASE), "I" (i) \
count211include/asm-mips/io.h#define outsb(port,addr,count) \
count213include/asm-mips/io.h__outsbc((port),(addr),(count)) : \
count214include/asm-mips/io.h__outsb ((port),(addr),(count)))
count216include/asm-mips/io.h#define insb(port,addr,count) \
count218include/asm-mips/io.h__insbc((port),(addr),(count)) : \
count219include/asm-mips/io.h__insb((port),(addr),(count)))
count221include/asm-mips/io.h#define outsw(port,addr,count) \
count223include/asm-mips/io.h__outswc((port),(addr),(count)) : \
count224include/asm-mips/io.h__outsw ((port),(addr),(count)))
count226include/asm-mips/io.h#define insw(port,addr,count) \
count228include/asm-mips/io.h__inswc((port),(addr),(count)) : \
count229include/asm-mips/io.h__insw((port),(addr),(count)))
count231include/asm-mips/io.h#define outsl(port,addr,count) \
count233include/asm-mips/io.h__outslc((port),(addr),(count)) : \
count234include/asm-mips/io.h__outsl ((port),(addr),(count)))
count236include/asm-mips/io.h#define insl(port,addr,count) \
count238include/asm-mips/io.h__inslc((port),(addr),(count)) : \
count239include/asm-mips/io.h__insl((port),(addr),(count)))
count91include/asm-mips/string.hextern __inline__ int strncmp(const char * cs, const char * ct, size_t count)
count110include/asm-mips/string.h: "=d" (cs), "=d" (ct), "=d" (count), "=d" (__res)
count111include/asm-mips/string.h: "0" (cs), "1" (ct), "2" (count)
count117include/asm-mips/string.hextern __inline__ void * memset(void * s, int c, size_t count)
count121include/asm-mips/string.hif (!count)
count129include/asm-mips/string.h: "=r" (s), "=r" (count)
count130include/asm-mips/string.h: "0" (s), "r" (c), "1" (s + count - 1)
count230include/asm-ppc/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count232include/asm-ppc/dma.hcount--;
count234include/asm-ppc/dma.hdma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count235include/asm-ppc/dma.hdma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count237include/asm-ppc/dma.hdma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count238include/asm-ppc/dma.hdma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count257include/asm-ppc/dma.hunsigned short count;
count259include/asm-ppc/dma.hcount = 1 + dma_inb(io_port);
count260include/asm-ppc/dma.hcount += dma_inb(io_port) << 8;
count262include/asm-ppc/dma.hreturn (dmanr<=3)? count : (count<<1);
count74include/asm-ppc/page.hunsigned count:30,
count207include/asm-ppc/pgtable.hmem_map[MAP_NR(ptep)].count++;
count13include/asm-ppc/string.hextern inline void * memset(void * s,int c,size_t count)
count17include/asm-ppc/string.hwhile (count--)
count272include/asm-ppc/unistd.hstatic /*inline*/ _syscall3(int,write,int,fd,const char *,buf,off_t,count)
count27include/asm-sparc/checksum.hint odd, count;
count38include/asm-sparc/checksum.hcount = len >> 1;    /* nr of 16-bit words.. */
count39include/asm-sparc/checksum.hif (count) {
count42include/asm-sparc/checksum.hcount--;
count46include/asm-sparc/checksum.hcount >>= 1;    /* nr of 32-bit words.. */
count47include/asm-sparc/checksum.hif (count) {
count51include/asm-sparc/checksum.hcount--;
count57include/asm-sparc/checksum.h} while (count);
count63include/asm-sparc/floppy.h#define fd_set_dma_count(count)   sun_fd_set_dma_count(count)
count405include/asm-sparc/unistd.hstatic inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
count44include/linux/binfmts.hchar * addr, unsigned long count, int to_kmem);
count90include/linux/cyclades.hint      count;  /* # of fd on device */
count26include/linux/ext_fs.hunsigned long count;
count32include/linux/ext_fs.hunsigned long count;
count72include/linux/if_pppvar.hint      count;    /* Count of characters in bufr  */
count110include/linux/mm.hunsigned count:24,
count190include/linux/mm.hextern int vread(char *buf, char *addr, int count);
count63include/linux/nfs_fs.hint offset, int count, char *data,
count66include/linux/nfs_fs.hint offset, int count, const char *data,
count86include/linux/nfs_fs.hint cookie, int count, struct nfs_entry *entry);
count110include/linux/sched.hint count;
count122include/linux/sched.hint count;
count134include/linux/sched.hint count;
count156include/linux/sched.hint count;
count435include/linux/sched.hif (sem->count <= 0)
count437include/linux/sched.hsem->count--;
count442include/linux/sched.hsem->count++;
count137include/linux/serial.hint      count;      /* # of fd on device */
count91include/linux/skbuff.hint        count;      /* reference count        */
count132include/linux/smb_fs.hoff_t offset, long count, char *data, int fs);
count134include/linux/smb_fs.hoff_t offset, long count, char *data);
count136include/linux/smb_fs.hoff_t offset, int count, const char *data);
count138include/linux/smb_fs.hoff_t offset, long count, const char *data);
count91include/linux/tty.hint    count;
count208include/linux/tty.hint count;
count127include/linux/tty_driver.hconst unsigned char *buf, int count);
count13include/linux/tty_flip.hif (tty->flip.count++ >= TTY_FLIPBUF_SIZE)
count37include/linux/tty_ldisc.hchar *fp, int count);
count17include/linux/wait.hint count;
count117include/linux/xd.hstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count);
count121include/linux/xd.hstatic u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
count122include/linux/xd.hstatic u_char *xd_build (u_char *cmdblk,u_char command,u_char drive,u_char head,u_short cylinder,u_char sector,u_char count,u_char control);
count77include/net/netrom.hunsigned char   count;
count88include/net/netrom.hunsigned short  count;
count666ipc/shm.cmem_map[MAP_NR(pte_page(pte))].count++;
count766ipc/shm.cmem_map[MAP_NR(pte_page(pte))].count--;
count776ipc/shm.cif (mem_map[MAP_NR(pte_page(page))].count != 1)
count290kernel/exit.cint err, retval = 0, count = 0;
count298kernel/exit.c++count;
count303kernel/exit.creturn(count ? retval : -ESRCH);
count367kernel/exit.cif (!--files->count) {
count392kernel/exit.cif (!--fs->count) {
count411kernel/exit.cif (!--sig->count) {
count428kernel/exit.cif (!--mm->count) {
count118kernel/fork.ccurrent->mm->count++;
count125kernel/fork.ctsk->mm->count = 1;
count142kernel/fork.ccurrent->fs->count++;
count148kernel/fork.ctsk->fs->count = 1;
count162kernel/fork.ccurrent->files->count++;
count168kernel/fork.ctsk->files->count = 1;
count183kernel/fork.ccurrent->sig->count++;
count189kernel/fork.ctsk->sig->count = 1;
count61kernel/printk.cunsigned long i, j, count;
count114kernel/printk.ccount = len;
count115kernel/printk.cif (count > LOG_BUF_LEN)
count116kernel/printk.ccount = LOG_BUF_LEN;
count117kernel/printk.cif (count > logged_chars)
count118kernel/printk.ccount = logged_chars;
count119kernel/printk.cj = log_start + log_size - count;
count120kernel/printk.cfor (i = 0; i < count; i++) {
count416kernel/sched.cwhile (sem->count <= 0) {
count555kernel/sched.cstatic int count = LOAD_FREQ;
count557kernel/sched.cif (count-- > 0)
count559kernel/sched.ccount = LOAD_FREQ;
count31lib/string.cchar * strncpy(char * dest,const char *src,size_t count)
count35lib/string.cwhile (count-- && (*dest++ = *src++) != '\0')
count57lib/string.cchar * strncat(char *dest, const char *src, size_t count)
count61lib/string.cif (count) {
count65lib/string.cif (--count == 0) {
count91lib/string.cint strncmp(const char * cs,const char * ct,size_t count)
count95lib/string.cwhile (count) {
count98lib/string.ccount--;
count127lib/string.csize_t strnlen(const char * s, size_t count)
count131lib/string.cfor (sc = s; count-- && *sc != '\0'; ++sc)
count142lib/string.csize_t count = 0;
count150lib/string.creturn count;
count151lib/string.c++count;
count154lib/string.creturn count;
count196lib/string.cvoid * memset(void * s,char c,size_t count)
count200lib/string.cwhile (count--)
count208lib/string.cchar * bcopy(const char * src, char * dest, int count)
count212lib/string.cwhile (count--)
count220lib/string.cvoid * memcpy(void * dest,const void *src,size_t count)
count224lib/string.cwhile (count--)
count232lib/string.cvoid * memmove(void * dest,const void *src,size_t count)
count239lib/string.cwhile (count--)
count243lib/string.ctmp = (char *) dest + count;
count244lib/string.cs = (char *) src + count;
count245lib/string.cwhile (count--)
count254lib/string.cint memcmp(const void * cs,const void * ct,size_t count)
count259lib/string.cfor( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
count11lib/write.c_syscall3(int,write,int,fd,const char *,buf,off_t,count)
count163mm/filemap.cmem_map[page].count++;
count183mm/filemap.cmem_map[MAP_NR(page)].count++;
count201mm/kmalloc.cstatic int count = 0;
count202mm/kmalloc.cif (++count < 5) {
count200mm/memory.cmem_map[MAP_NR(pte_page(pte))].count++;
count532mm/memory.cif (mem_map[MAP_NR(page)].count != 1)
count606mm/memory.cif (mem_map[MAP_NR(old_page)].count != 1) {
count836mm/memory.cmem_map[MAP_NR(pte_page(from))].count++;
count1048mm/memory.cif (mem_map[MAP_NR(pte_page(page))].count > 1 && !(vma->vm_flags & VM_SHARED))
count1123mm/memory.c} else if (mem_map[MAP_NR(page)].count > 1 && !(vma->vm_flags & VM_SHARED))
count303mm/mmap.cstatic inline void avl_rebalance (struct vm_area_struct *** nodeplaces_ptr, int count)
count305mm/mmap.cfor ( ; count > 0 ; count--) {
count454mm/swap.cif (mem_map[MAP_NR(page)].count != 1)
count468mm/swap.cif (mem_map[MAP_NR(page)].count != 1) {
count482mm/swap.centry = mem_map[MAP_NR(page)].count;
count773mm/swap.cif (map->count) {
count776mm/swap.cif (!--map->count) {
count781mm/swap.cif (map->count == 1)
count826mm/swap.c} mem_map[MAP_NR((unsigned long) addr)].count = 1; \
count838mm/swap.cstatic int count = 0;
count839mm/swap.cif (++count < 5) {
count1324mm/swap.cp->count = 0;
count324mm/vmalloc.cint vread(char *buf, char *addr, int count)
count333mm/vmalloc.cif (count == 0)
count335mm/vmalloc.cput_user('\0', buf++), addr++, count--;
count341mm/vmalloc.cif (count == 0)
count343mm/vmalloc.cput_user(*addr++, buf++), count--;
count79net/ax25/ax25_route.cint count;
count81net/ax25/ax25_route.ccount  = 0;
count85net/ax25/ax25_route.cif (count == 0 || (ax25_rt->stamp.tv_sec != 0 && ax25_rt->stamp.tv_sec < oldest->stamp.tv_sec))
count95net/ax25/ax25_route.ccount++;
count98net/ax25/ax25_route.cif (count > AX25_ROUTE_MAX) {
count510net/core/skbuff.cstatic int count = 0;
count511net/core/skbuff.cif (++count < 5) {
count546net/core/skbuff.cskb->count = 1;    /* only one reference to this */
count591net/core/skbuff.cif (--skb->count <= 0) {
count618net/core/skbuff.cn->count = 1;
count623net/core/skbuff.cskb->count++;
count347net/ipv4/arp.cint count = 0;
count358net/ipv4/arp.ccount += hh->hh_refcnt-1;
count362net/ipv4/arp.creturn count;
count347net/ipv4/ip_fragment.cint count, len;
count372net/ipv4/ip_fragment.ccount = 0;
count378net/ipv4/ip_fragment.cif(count+fp->len > skb->len)
count387net/ipv4/ip_fragment.ccount += fp->len;
count397net/ipv4/ip_fragment.ciph->tot_len = htons((iph->ihl * 4) + count);
count70net/netlink.cstatic int netlink_write(struct inode * inode, struct file * file, const char * buf, int count)
count74net/netlink.cskb=alloc_skb(count, GFP_KERNEL);
count75net/netlink.cmemcpy_fromfs(skb_put(skb,count),buf, count);
count83net/netlink.cstatic int netlink_read(struct inode * inode, struct file * file, char * buf, int count)
count104net/netlink.cif(skb->len<count)
count105net/netlink.ccount=skb->len;
count106net/netlink.cmemcpy_tofs(buf,skb->data,count);
count108net/netlink.creturn count;
count97net/netrom/nr_route.cnr_neigh->count   = 0;
count125net/netrom/nr_route.cnr_node->count = 1;
count139net/netrom/nr_route.cnr_neigh->count++;
count144net/netrom/nr_route.cfor (found = 0, i = 0; i < nr_node->count; i++) {
count155net/netrom/nr_route.cif (nr_node->count < 3) {
count163net/netrom/nr_route.cnr_node->count++;
count164net/netrom/nr_route.cnr_neigh->count++;
count172net/netrom/nr_route.cnr_neigh->count++;
count178net/netrom/nr_route.cswitch (nr_node->count) {
count215net/netrom/nr_route.cfor (i = 0; i < nr_node->count; i++) {
count310net/netrom/nr_route.cfor (i = 0; i < nr_node->count; i++) {
count312net/netrom/nr_route.cnr_neigh->count--;
count314net/netrom/nr_route.cif (nr_neigh->count == 0 && !nr_neigh->locked)
count317net/netrom/nr_route.cnr_node->count--;
count319net/netrom/nr_route.cif (nr_node->count == 0) {
count364net/netrom/nr_route.cnr_neigh->count   = 0;
count395net/netrom/nr_route.cif (nr_neigh->count == 0)
count418net/netrom/nr_route.cfor (i = 0; i < s->count; i++) {
count432net/netrom/nr_route.ct->count--;
count434net/netrom/nr_route.cif (t->count == 0 && !t->locked)
count441net/netrom/nr_route.cs->count--;
count460net/netrom/nr_route.cif (s->count <= 0)
count487net/netrom/nr_route.cfor (i = 0; i < t->count; i++) {
count489net/netrom/nr_route.ct->count--;
count502net/netrom/nr_route.cif (t->count <= 0)
count641net/netrom/nr_route.cif (nr_node->which >= nr_node->count && nr_node->routes[nr_node->which].neighbour == nr_neigh->number)
count685net/netrom/nr_route.cif (nr_node == NULL || nr_node->which >= nr_node->count)
count729net/netrom/nr_route.cnr_node->count);      
count731net/netrom/nr_route.cfor (i = 0; i < nr_node->count; i++) {
count780net/netrom/nr_route.cnr_neigh->count);