taglinefilesource code
count16fs/block_dev.cint block_write(struct inode * inode, struct file * filp, char * buf, int count)
count32fs/block_dev.cwhile (count>0) {
count36fs/block_dev.cif (chars > count)
count37fs/block_dev.cchars=count;
count49fs/block_dev.ccount -= chars;
count62fs/block_dev.cint block_read(struct inode * inode, struct file * filp, char * buf, int count)
count87fs/block_dev.cif (left > count)
count88fs/block_dev.cleft = count;
count385fs/exec.cchar * addr, unsigned long count)
count409fs/exec.cresult = file.f_op->read(inode, &file, addr, count);
count445fs/exec.cargc = count(argv);
count446fs/exec.cenvc = count(envp);
count23fs/ext/dir.cstatic int ext_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count65fs/ext/dir.cstruct dirent * dirent, 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;
count193fs/ext/file.cstatic int ext_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count217fs/ext/file.cwhile (written<count) {
count225fs/ext/file.cif (c > count-written)
count226fs/ext/file.cc = count-written;
count67fs/ext/freelists.cif (!sb->u.ext_sb.s_firstfreeblock || efb->count == 254) {
count78fs/ext/freelists.cefb->count = 0;
count81fs/ext/freelists.cefb->free[efb->count++] = block;
count104fs/ext/freelists.cif (efb->count) {
count105fs/ext/freelists.cj = efb->free[--efb->count];
count151fs/ext/freelists.cunsigned long count, block;
count155fs/ext/freelists.ccount = 0;
count158fs/ext/freelists.ccount = efb->count + 1;
count166fs/ext/freelists.ccount += efb->count + 1;
count173fs/ext/freelists.csb->u.ext_sb.s_freeblockscount, count);
count175fs/ext/freelists.creturn count;
count214fs/ext/freelists.cif (!inode->i_sb->u.ext_sb.s_firstfreeinodeblock || efi->count == 14) {
count226fs/ext/freelists.cefi->count = 0;
count230fs/ext/freelists.cefi->free[efi->count++] = inode->i_ino;
count257fs/ext/freelists.cif (efi->count) {
count258fs/ext/freelists.cj = efi->free[--efi->count];
count304fs/ext/freelists.cunsigned long count, block, ino;
count308fs/ext/freelists.ccount = 0;
count312fs/ext/freelists.ccount = efi->count + 1;
count327fs/ext/freelists.ccount += efi->count + 1;
count334fs/ext/freelists.csb->u.ext_sb.s_freeinodescount, count);
count336fs/ext/freelists.creturn count;
count25fs/ext2/dir.cchar * buf, int count)
count94fs/ext2/dir.cstruct dirent * dirent, int count)
count73fs/ext2/file.cchar * buf, int count)
count99fs/ext2/file.cif (left > count)
count100fs/ext2/file.cleft = count;
count199fs/ext2/file.cchar * buf, int count)
count226fs/ext2/file.cwhile (written < count) {
count237fs/ext2/file.cif (c > count-written)
count238fs/ext2/file.cc = count - written;
count64fs/isofs/dir.cstruct dirent * dirent, int count)
count113fs/isofs/file.cstatic int isofs_file_read(struct inode * inode, struct file * filp, char * buf, int count)
count137fs/isofs/file.cif (left > count)
count138fs/isofs/file.cleft = count;
count16fs/minix/dir.cstatic int minix_dir_read(struct inode * inode, struct file * filp, char * buf, int count)
count58fs/minix/dir.cstruct dirent * dirent, 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;
count187fs/minix/file.cstatic int minix_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count211fs/minix/file.cwhile (written<count) {
count219fs/minix/file.cif (c > count-written)
count220fs/minix/file.cc = count-written;
count17fs/msdos/dir.cstatic int msdos_dir_read(struct inode * inode,struct file * filp, char * buf,int count)
count23fs/msdos/dir.cstruct dirent *dirent,int count);
count58fs/msdos/dir.cstruct dirent *dirent,int count)
count107fs/msdos/fat.cint count;
count111fs/msdos/fat.cfor (count = 0; count < FAT_CACHE; count++) {
count112fs/msdos/fat.ccache[count].device = 0;
count113fs/msdos/fat.ccache[count].next = count == FAT_CACHE-1 ? NULL :
count114fs/msdos/fat.c&cache[count+1];
count223fs/msdos/fat.cint this,count;
count227fs/msdos/fat.ccount = 0;
count228fs/msdos/fat.cfor (cache_lookup(inode,cluster,&count,&this); count < cluster;
count229fs/msdos/fat.ccount++) {
count23fs/msdos/file.cint count);
count25fs/msdos/file.cint count);
count81fs/msdos/file.cint count)
count98fs/msdos/file.cif (filp->f_pos >= inode->i_size || count <= 0) return 0;
count100fs/msdos/file.cwhile ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
count130fs/msdos/file.cint count)
count151fs/msdos/file.cif (count <= 0) return 0;
count153fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
count161fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
count179fs/msdos/file.cfor (size = 0; size < count && left; size++) {
count111fs/msdos/misc.cint count,this,limit,last,current,sector;
count120fs/msdos/misc.cfor (count = 0; count < limit; count++) {
count121fs/msdos/misc.cthis = ((count+MSDOS_SB(inode->i_sb)->prev_free) % limit)+2;
count127fs/msdos/misc.cMSDOS_SB(inode->i_sb)->prev_free = (count+MSDOS_SB(inode->i_sb)->
count129fs/msdos/misc.cif (count >= limit) {
count389fs/msdos/misc.cint count,cluster;
count391fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->dir_entries/MSDOS_DPS; count++) {
count392fs/msdos/misc.cif ((cluster = raw_scan_sector(sb,MSDOS_SB(sb)->dir_start+count,
count408fs/msdos/misc.cint count,cluster;
count414fs/msdos/misc.cfor (count = 0; count < MSDOS_SB(sb)->cluster_size; count++) {
count417fs/msdos/misc.ccount,name,number,ino,res_bh,res_de)) >= 0)
count493fs/msdos/misc.cint count;
count495fs/msdos/misc.ccount = 0;
count497fs/msdos/misc.c(void) raw_scan_root(dir->i_sb,NULL,&count,NULL,NULL,NULL);
count501fs/msdos/misc.cNULL,&count,NULL,NULL,NULL);
count503fs/msdos/misc.creturn count;
count21fs/nfs/dir.cint count);
count72fs/nfs/dir.cint count)
count86fs/nfs/dir.cstruct dirent *dirent, int count)
count54fs/nfs/file.cint count)
count74fs/nfs/file.cif (file->f_pos + count > inode->i_size)
count75fs/nfs/file.ccount = inode->i_size - pos;
count76fs/nfs/file.cif (count <= 0)
count80fs/nfs/file.cfor (i = 0; i < count; i += n) {
count81fs/nfs/file.chunk = count - i;
count105fs/nfs/file.cint count)
count124fs/nfs/file.cif (count <= 0)
count131fs/nfs/file.cfor (i = 0; i < count; i += n) {
count132fs/nfs/file.chunk = count - i;
count281fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
count287fs/nfs/proc.cPRINTK("NFS call  read %d @ %d\n", count, offset);
count292fs/nfs/proc.c*p++ = htonl(count);
count293fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count302fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
count316fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
count321fs/nfs/proc.cPRINTK("NFS call  write %d @ %d\n", count, offset);
count327fs/nfs/proc.c*p++ = htonl(count); /* traditional, could be any value */
count328fs/nfs/proc.cp = xdr_encode_data(p, data, count);
count540fs/nfs/proc.cint cookie, int count, struct nfs_entry *entry)
count548fs/nfs/proc.cPRINTK("NFS call  readdir %d @ %d\n", count, cookie);
count562fs/nfs/proc.cfor (i = 0; i < count && *p++; i++) {
count571fs/nfs/proc.ceof = (i == count && !*p++ && *p++)
count572fs/nfs/proc.c|| (i < count && *p++);
count16fs/pipe.cstatic int pipe_read(struct inode * inode, struct file * filp, char * buf, int count)
count29fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
count31fs/pipe.cif (chars > count)
count32fs/pipe.cchars = count;
count39fs/pipe.ccount -= chars;
count50fs/pipe.cstatic int pipe_write(struct inode * inode, struct file * filp, char * buf, int count)
count59fs/pipe.cif (count < PAGE_SIZE)
count60fs/pipe.csize = PAGE_SIZE-count;
count63fs/pipe.cwhile (count>0) {
count76fs/pipe.cwhile (count>0 && (size = (PAGE_SIZE-1)-PIPE_SIZE(*inode))) {
count78fs/pipe.cif (chars > count)
count79fs/pipe.cchars = count;
count86fs/pipe.ccount -= chars;
count100fs/pipe.cstatic int pipe_readdir(struct inode * inode, struct file * file, struct dirent * de, int count)
count105fs/pipe.cstatic int bad_pipe_rw(struct inode * inode, struct file * filp, char * buf, int count)
count162fs/proc/array.cint count = 0;
count176fs/proc/array.c} while (count++ < 16);
count295fs/proc/array.cstatic int array_read(struct inode * inode, struct file * file,char * buf, int count)
count302fs/proc/array.cif (count < 0)
count343fs/proc/array.cif (count + file->f_pos > length)
count344fs/proc/array.ccount = length - file->f_pos;
count345fs/proc/array.cend = count + file->f_pos;
count346fs/proc/array.cmemcpy_tofs(buf, page + file->f_pos, count);
count349fs/proc/array.creturn count;
count132fs/proc/base.cstruct dirent * dirent, int count)
count122fs/proc/fd.cstruct dirent * dirent, int count)
count20fs/proc/kmsg.cextern int sys_syslog(int type, char * bug, int count);
count32fs/proc/kmsg.cstatic int kmsg_read(struct inode * inode, struct file * file,char * buf, int count)
count34fs/proc/kmsg.creturn sys_syslog(2,buf,count);
count23fs/proc/mem.cstatic int mem_read(struct inode * inode, struct file * file,char * buf, int count)
count30fs/proc/mem.cif (count < 0)
count44fs/proc/mem.cwhile (count > 0) {
count59fs/proc/mem.cif (i > count)
count60fs/proc/mem.ci = count;
count64fs/proc/mem.ccount -= i;
count72fs/proc/mem.cstatic int mem_write(struct inode * inode, struct file * file,char * buf, int count)
count79fs/proc/mem.cif (count < 0)
count93fs/proc/mem.cwhile (count > 0) {
count112fs/proc/mem.cif (i > count)
count113fs/proc/mem.ci = count;
count117fs/proc/mem.ccount -= i;
count124fs/proc/root.cstruct dirent * dirent, int count)
count19fs/read_write.cint sys_readdir(unsigned int fd, struct dirent * dirent, unsigned int count)
count32fs/read_write.cerror = file->f_op->readdir(inode,file,dirent,count);
count70fs/read_write.cint sys_read(unsigned int fd,char * buf,unsigned int count)
count82fs/read_write.cif (!count)
count84fs/read_write.cerror = verify_area(VERIFY_WRITE,buf,count);
count87fs/read_write.creturn file->f_op->read(inode,file,buf,count);
count90fs/read_write.cint sys_write(unsigned int fd,char * buf,unsigned int count)
count102fs/read_write.cif (!count)
count104fs/read_write.cerror = verify_area(VERIFY_READ,buf,count);
count107fs/read_write.creturn file->f_op->write(inode,file,buf,count);
count81fs/select.cint count;
count113fs/select.ccount = 0;
count122fs/select.ccount++;
count127fs/select.ccount++;
count132fs/select.ccount++;
count137fs/select.cif (!count && current->timeout && !(current->signal & ~current->blocked)) {
count144fs/select.creturn count;
count60fs/xiafs/dir.cstruct file * filp, char * buf, int count)
count66fs/xiafs/dir.cstruct file * filp, struct dirent * dirent, 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;
count186fs/xiafs/file.cxiafs_file_write(struct inode * inode, struct file * filp, char * buf, int count)
count210fs/xiafs/file.cwhile (written < count) {
count218fs/xiafs/file.cif (c > count-written)
count219fs/xiafs/file.cc = count-written;
count223include/asm/dma.hstatic __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
count225include/asm/dma.hcount--;
count227include/asm/dma.houtb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count228include/asm/dma.houtb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
count230include/asm/dma.houtb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count231include/asm/dma.houtb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
count250include/asm/dma.hunsigned short count;
count252include/asm/dma.hcount = 1 + inb(io_port);
count253include/asm/dma.hcount += inb(io_port) << 8;
count255include/asm/dma.hreturn (dmanr<=3)? count : (count<<1);
count26include/linux/ext_fs.hunsigned long count;
count32include/linux/ext_fs.hunsigned long count;
count11include/linux/kernel.hint verify_area(int type, void * addr, unsigned long count);
count68include/linux/nfs_fs.hint offset, int count, char *data,
count71include/linux/nfs_fs.hint offset, int count, char *data,
count91include/linux/nfs_fs.hint cookie, int count, struct nfs_entry *entry);
count34include/linux/serial.hint      count;      /* # of fd on device */
count33include/linux/string.hextern inline char * strncpy(char * dest,const char *src,size_t count)
count45include/linux/string.h::"S" (src),"D" (dest),"c" (count):"si","di","ax","cx");
count63include/linux/string.hextern inline char * strncat(char * dest,const char * src,size_t count)
count78include/linux/string.h::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff),"g" (count)
count102include/linux/string.hextern inline int strncmp(const char * cs,const char * ct,size_t count)
count119include/linux/string.h:"=a" (__res):"D" (cs),"S" (ct),"c" (count):"si","di","cx");
count367include/linux/string.hextern inline int memcmp(const void * cs,const void * ct,size_t count)
count378include/linux/string.h:"=a" (__res):"0" (0),"D" (cs),"S" (ct),"c" (count)
count383include/linux/string.hextern inline void * memchr(const void * cs,char c,size_t count)
count386include/linux/string.hif (!count)
count394include/linux/string.h:"=D" (__res):"a" (c),"D" (cs),"c" (count)
count399include/linux/string.hextern inline void * memset(void * s,char c,size_t count)
count404include/linux/string.h::"a" (c),"D" (s),"c" (count)
count211include/linux/tty.hint count;
count120include/linux/xd.hstatic int xd_readwrite (u_char operation,u_char drive,u_char *buffer,u_int block,u_int count);
count124include/linux/xd.hstatic u_char xd_setup_dma (u_char opcode,u_char *buffer,u_int count);
count125include/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);
count47init/main.cstatic inline _syscall3(int,write,int,fd,const char *,buf,off_t,count)
count358kernel/blk_drv/floppy.cunsigned long addr,count;
count366kernel/blk_drv/floppy.ccount = floppy->sect*4;
count369kernel/blk_drv/floppy.ccount = 1024;
count374kernel/blk_drv/floppy.ccount = floppy->sect*2*512;
count386kernel/blk_drv/floppy.cset_dma_count(FLOPPY_DMA, count);
count903kernel/blk_drv/floppy.cint count,head_shift,track_shift,total_shift;
count914kernel/blk_drv/floppy.cfor (count = 0; count < floppy->sect; count++) {
count917kernel/blk_drv/floppy.c*here++ = 1 + (( count + total_shift ) % floppy->sect);
count126kernel/blk_drv/ll_rw_blk.cunsigned int sector, count;
count145kernel/blk_drv/ll_rw_blk.ccount = bh->b_size >> 9;
count146kernel/blk_drv/ll_rw_blk.csector = bh->b_blocknr * count;
count148kernel/blk_drv/ll_rw_blk.cif (blk_size[major][MINOR(bh->b_dev)] < (sector + count)>>1) {
count173kernel/blk_drv/ll_rw_blk.creq->nr_sectors += count;
count210kernel/blk_drv/ll_rw_blk.creq->nr_sectors = count;
count211kernel/blk_drv/ll_rw_blk.creq->current_nr_sectors = count;
count264kernel/blk_drv/scsi/fdomain.c#define insw( buf, count, port ) \
count266kernel/blk_drv/scsi/fdomain.c( "cld;rep;insw"::"d" (port),"D" (buf),"c" (count):"cx","di" )
count268kernel/blk_drv/scsi/fdomain.c#define outsw( buf, count, port ) \
count270kernel/blk_drv/scsi/fdomain.c("cld;rep;outsw"::"d" (port),"S" (buf),"c" (count):"cx","si")
count123kernel/blk_drv/scsi/hosts.cint i, count;  
count127kernel/blk_drv/scsi/hosts.cfor (count = i = 0; i < MAX_SCSI_HOSTS; ++i)
count140kernel/blk_drv/scsi/hosts.ccount, scsi_hosts[i].name);
count142kernel/blk_drv/scsi/hosts.c++count;
count145kernel/blk_drv/scsi/hosts.cprintk ("scsi : %d hosts.\n", count);
count482kernel/blk_drv/scsi/sd.cint count, this_count_max;
count486kernel/blk_drv/scsi/sd.ccount = 0;
count487kernel/blk_drv/scsi/sd.cwhile(bh && count < scsi_hosts[SCpnt->host].sg_tablesize) {
count490kernel/blk_drv/scsi/sd.ccount++;
count493kernel/blk_drv/scsi/sd.cSCpnt->use_sg = count;  /* Number of chains */
count494kernel/blk_drv/scsi/sd.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
count495kernel/blk_drv/scsi/sd.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count496kernel/blk_drv/scsi/sd.ccount = count << 1;
count497kernel/blk_drv/scsi/sd.cSCpnt->sglist_len = count;
count498kernel/blk_drv/scsi/sd.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count506kernel/blk_drv/scsi/sd.ccount = 0;
count508kernel/blk_drv/scsi/sd.cfor(count = 0, bh = SCpnt->request.bh; count < SCpnt->use_sg; 
count509kernel/blk_drv/scsi/sd.ccount++, bh = bh->b_reqnext) {
count510kernel/blk_drv/scsi/sd.csgpnt[count].address = bh->b_data;
count511kernel/blk_drv/scsi/sd.csgpnt[count].alt_address = NULL;
count512kernel/blk_drv/scsi/sd.csgpnt[count].length = bh->b_size;
count513kernel/blk_drv/scsi/sd.cif (((int) sgpnt[count].address) + sgpnt[count].length > 
count515kernel/blk_drv/scsi/sd.csgpnt[count].alt_address = sgpnt[count].address;
count520kernel/blk_drv/scsi/sd.csgpnt[count].address = NULL;
count522kernel/blk_drv/scsi/sd.csgpnt[count].address = scsi_malloc(sgpnt[count].length);
count528kernel/blk_drv/scsi/sd.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count531kernel/blk_drv/scsi/sd.cwhile(--count){
count532kernel/blk_drv/scsi/sd.cif(sgpnt[count].alt_address) 
count533kernel/blk_drv/scsi/sd.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count543kernel/blk_drv/scsi/sd.cmemcpy(sgpnt[count].address, sgpnt[count].alt_address, 
count544kernel/blk_drv/scsi/sd.csgpnt[count].length);
count418kernel/blk_drv/scsi/sr.cint count, this_count_max;
count421kernel/blk_drv/scsi/sr.ccount = 0;
count426kernel/blk_drv/scsi/sr.cif(this_count) count++;
count427kernel/blk_drv/scsi/sr.cwhile(bh && count < scsi_hosts[SCpnt->host].sg_tablesize) {
count430kernel/blk_drv/scsi/sr.ccount++;
count436kernel/blk_drv/scsi/sr.cif (count < scsi_hosts[SCpnt->host].sg_tablesize) {
count437kernel/blk_drv/scsi/sr.ccount++;
count441kernel/blk_drv/scsi/sr.ccount--;
count445kernel/blk_drv/scsi/sr.cSCpnt->use_sg = count;  /* Number of chains */
count446kernel/blk_drv/scsi/sr.ccount = 512;/* scsi_malloc can only allocate in chunks of 512 bytes*/
count447kernel/blk_drv/scsi/sr.cwhile( count < (SCpnt->use_sg * sizeof(struct scatterlist))) 
count448kernel/blk_drv/scsi/sr.ccount = count << 1;
count449kernel/blk_drv/scsi/sr.cSCpnt->sglist_len = count;
count450kernel/blk_drv/scsi/sr.csgpnt = (struct scatterlist * ) scsi_malloc(count);
count456kernel/blk_drv/scsi/sr.ccount = 0;
count459kernel/blk_drv/scsi/sr.csgpnt[count].length = (SCpnt->request.sector % 4) << 9;
count460kernel/blk_drv/scsi/sr.csgpnt[count].address = scsi_malloc(sgpnt[count].length);
count461kernel/blk_drv/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count462kernel/blk_drv/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address; /* Flag to delete
count464kernel/blk_drv/scsi/sr.ccount++;
count466kernel/blk_drv/scsi/sr.cfor(bh = SCpnt->request.bh; count < SCpnt->use_sg; 
count467kernel/blk_drv/scsi/sr.ccount++, bh = bh->b_reqnext) {
count469kernel/blk_drv/scsi/sr.csgpnt[count].address = bh->b_data;
count470kernel/blk_drv/scsi/sr.csgpnt[count].length = bh->b_size;
count471kernel/blk_drv/scsi/sr.csgpnt[count].alt_address = NULL;
count473kernel/blk_drv/scsi/sr.csgpnt[count].address = scsi_malloc(end_rec);
count474kernel/blk_drv/scsi/sr.cif(!sgpnt[count].address) panic("SCSI DMA pool exhausted.");
count475kernel/blk_drv/scsi/sr.csgpnt[count].length = end_rec;
count476kernel/blk_drv/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count477kernel/blk_drv/scsi/sr.cif (count+1 != SCpnt->use_sg) panic("Bad sr request list");
count480kernel/blk_drv/scsi/sr.cif (((int) sgpnt[count].address) + sgpnt[count].length > 
count482kernel/blk_drv/scsi/sr.csgpnt[count].alt_address = sgpnt[count].address;
count486kernel/blk_drv/scsi/sr.cif(dma_free_sectors < (sgpnt[count].length >> 9) + 5) {
count487kernel/blk_drv/scsi/sr.csgpnt[count].address = NULL;
count489kernel/blk_drv/scsi/sr.csgpnt[count].address = scsi_malloc(sgpnt[count].length);
count495kernel/blk_drv/scsi/sr.cif(sgpnt[count].address == NULL){ /* Out of dma memory */
count498kernel/blk_drv/scsi/sr.cwhile(--count){
count499kernel/blk_drv/scsi/sr.cif(sgpnt[count].alt_address) 
count500kernel/blk_drv/scsi/sr.cscsi_free(sgpnt[count].address, sgpnt[count].length);
count513kernel/blk_drv/scsi/sr.cfor(count=0; count<SCpnt->use_sg; count++)
count514kernel/blk_drv/scsi/sr.cprintk("SGlist: %d %x %x %x\n", count,
count515kernel/blk_drv/scsi/sr.csgpnt[count].address, 
count516kernel/blk_drv/scsi/sr.csgpnt[count].alt_address, 
count517kernel/blk_drv/scsi/sr.csgpnt[count].length);
count546kernel/blk_drv/scsi/st.cint st_write(struct inode * inode, struct file * filp, char * buf, int count)
count591kernel/blk_drv/scsi/st.ctotal = count;
count600kernel/blk_drv/scsi/st.cwhile((scsi_tapes[dev].buffer->buffer_bytes + count) >=
count631kernel/blk_drv/scsi/st.cif (count < total)
count632kernel/blk_drv/scsi/st.creturn total - count;
count638kernel/blk_drv/scsi/st.ccount -= do_count;
count642kernel/blk_drv/scsi/st.cif (count != 0) {
count645kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes,b_point,count);
count646kernel/blk_drv/scsi/st.cfilp->f_pos += count;
count647kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes += count;
count648kernel/blk_drv/scsi/st.ccount = 0;
count685kernel/blk_drv/scsi/st.cint st_read(struct inode * inode, struct file * filp, char * buf, int count)
count721kernel/blk_drv/scsi/st.cfor (total = 0; total < count; ) {
count816kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes, count - total);
count818kernel/blk_drv/scsi/st.ctransfer = scsi_tapes[dev].buffer->buffer_bytes < count - total ?
count819kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes : count - total;
count169kernel/blk_drv/xd.cu_int block,count,retry;
count178kernel/blk_drv/xd.ccount = CURRENT->nr_sectors;
count183kernel/blk_drv/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
count265kernel/blk_drv/xd.cstatic int xd_readwrite (u_char operation,u_char drive,u_char *buffer,u_int block,u_int count)
count272kernel/blk_drv/xd.cprintk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
count276kernel/blk_drv/xd.cwhile (count) {
count277kernel/blk_drv/xd.ctemp = count < xd_maxsectors ? count : xd_maxsectors;
count310kernel/blk_drv/xd.ccount -= temp, buffer += temp * 0x200, block += temp;
count342kernel/blk_drv/xd.cstatic u_char xd_setup_dma (u_char mode,u_char *buffer,u_int count)
count344kernel/blk_drv/xd.cif (buffer < ((u_char *) 0x1000000 - count)) {    /* transfer to address < 16M? */
count345kernel/blk_drv/xd.cif (((u_int) buffer & 0xFFFF0000) != ((u_int) buffer + count) & 0xFFFF0000) {
count355kernel/blk_drv/xd.cset_dma_count(xd_dma,count);
count366kernel/blk_drv/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)
count372kernel/blk_drv/xd.ccmdblk[4] = count;
count452kernel/blk_drv/xd.cu_char cmdblk[6],i,count = 0;
count457kernel/blk_drv/xd.cinit_drive(count);
count458kernel/blk_drv/xd.ccount++;
count461kernel/blk_drv/xd.creturn (count);
count108kernel/chr_drv/atixlmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count113kernel/chr_drv/atixlmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count115kernel/chr_drv/atixlmouse.cif (count < 3)
count89kernel/chr_drv/busmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count94kernel/chr_drv/busmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count98kernel/chr_drv/busmouse.cif (count < 3)
count114kernel/chr_drv/busmouse.cfor (i = 3; i < count; i++)
count424kernel/chr_drv/console.cunsigned long count;
count429kernel/chr_drv/console.ccount = (scr_end-pos)>>1;
count433kernel/chr_drv/console.ccount = ((pos-origin)>>1)+1;
count437kernel/chr_drv/console.ccount = video_num_columns * video_num_lines;
count446kernel/chr_drv/console.c::"c" (count),
count454kernel/chr_drv/console.clong count;
count459kernel/chr_drv/console.ccount = video_num_columns-x;
count464kernel/chr_drv/console.ccount = x+1;
count468kernel/chr_drv/console.ccount = video_num_columns;
count476kernel/chr_drv/console.c::"c" (count),
count1221kernel/chr_drv/console.cvoid * memsetw(void * s,unsigned short c,int count)
count1226kernel/chr_drv/console.c::"a" (c),"D" (s),"c" (count)
count47kernel/chr_drv/lp.cunsigned long count  = 0; 
count52kernel/chr_drv/lp.ccount ++;
count55kernel/chr_drv/lp.c} while(!(status & LP_PBUSY) && count < LP_CHAR(minor));
count57kernel/chr_drv/lp.cif (count == LP_CHAR(minor)) {
count62kernel/chr_drv/lp.cif (count > lp_max_count) {
count63kernel/chr_drv/lp.cprintk("lp success after %d counts.\n",count);
count64kernel/chr_drv/lp.clp_max_count=count;
count122kernel/chr_drv/lp.cstatic int lp_write_interrupt(struct inode * inode, struct file * file, char * buf, int count)
count133kernel/chr_drv/lp.ccopy_size = (count <= LP_BUFFER_SIZE ? count : LP_BUFFER_SIZE);
count182kernel/chr_drv/lp.ccount -= bytes_written;
count184kernel/chr_drv/lp.c} while (count > 0);
count190kernel/chr_drv/lp.cchar * buf, int count)
count205kernel/chr_drv/lp.cwhile (count > 0) {
count209kernel/chr_drv/lp.cif (retval) { count--; temp++;
count263kernel/chr_drv/lp.cstatic int lp_write(struct inode * inode, struct file * file, char * buf, int count)
count266kernel/chr_drv/lp.creturn lp_write_interrupt(inode, file, buf, count);
count268kernel/chr_drv/lp.creturn lp_write_polled(inode, file, buf, count);
count429kernel/chr_drv/lp.cint count = 0;
count450kernel/chr_drv/lp.ccount++;
count453kernel/chr_drv/lp.cif (count == 0)
count22kernel/chr_drv/mem.cstatic int read_ram(struct inode * inode, struct file * file,char * buf, int count)
count27kernel/chr_drv/mem.cstatic int write_ram(struct inode * inode, struct file * file,char * buf, int count)
count32kernel/chr_drv/mem.cstatic int read_core(struct inode * inode, struct file * file,char * buf, int count)
count44kernel/chr_drv/mem.cif (count < 0)
count48kernel/chr_drv/mem.cif (count > high_memory - p)
count49kernel/chr_drv/mem.ccount = high_memory - p;
count52kernel/chr_drv/mem.cif (p < sizeof(struct user) && count > 0) {
count53kernel/chr_drv/mem.ccount1 = count;
count60kernel/chr_drv/mem.ccount -= count1;
count64kernel/chr_drv/mem.cwhile (p < (4096 + 4096) && count > 0) {
count68kernel/chr_drv/mem.ccount--;
count71kernel/chr_drv/mem.cmemcpy_tofs(buf,(void *) (p - 4096),count);
count72kernel/chr_drv/mem.cread += count;
count77kernel/chr_drv/mem.cstatic int read_mem(struct inode * inode, struct file * file,char * buf, int count)
count82kernel/chr_drv/mem.cif (count < 0)
count86kernel/chr_drv/mem.cif (count > high_memory - p)
count87kernel/chr_drv/mem.ccount = high_memory - p;
count89kernel/chr_drv/mem.cwhile (p < 4096 && count > 0) {
count93kernel/chr_drv/mem.ccount--;
count96kernel/chr_drv/mem.cmemcpy_tofs(buf,(void *) p,count);
count97kernel/chr_drv/mem.cread += count;
count102kernel/chr_drv/mem.cstatic int write_mem(struct inode * inode, struct file * file,char * buf, int count)
count107kernel/chr_drv/mem.cif (count < 0)
count111kernel/chr_drv/mem.cif (count > high_memory - p)
count112kernel/chr_drv/mem.ccount = high_memory - p;
count114kernel/chr_drv/mem.cwhile (p < 4096 && count > 0) {
count118kernel/chr_drv/mem.ccount--;
count121kernel/chr_drv/mem.cmemcpy_fromfs((void *) p,buf,count);
count122kernel/chr_drv/mem.cwritten += count;
count124kernel/chr_drv/mem.creturn count;
count139kernel/chr_drv/mem.cstatic int read_port(struct inode * inode,struct file * file,char * buf, int count)
count144kernel/chr_drv/mem.cwhile (count-- > 0 && i < 65536) {
count153kernel/chr_drv/mem.cstatic int write_port(struct inode * inode,struct file * file,char * buf, int count)
count158kernel/chr_drv/mem.cwhile (count-- > 0 && i < 65536) {
count167kernel/chr_drv/mem.cstatic int read_null(struct inode * node,struct file * file,char * buf,int count)
count172kernel/chr_drv/mem.cstatic int write_null(struct inode * inode,struct file * file,char * buf, int count)
count174kernel/chr_drv/mem.creturn count;
count177kernel/chr_drv/mem.cstatic int read_zero(struct inode * node,struct file * file,char * buf,int count)
count181kernel/chr_drv/mem.cfor (left = count; left > 0; left--) {
count185kernel/chr_drv/mem.creturn count;
count188kernel/chr_drv/mem.cstatic int write_zero(struct inode * inode,struct file * file,char * buf, int count)
count190kernel/chr_drv/mem.creturn count;
count95kernel/chr_drv/msbusmouse.cstatic int write_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count100kernel/chr_drv/msbusmouse.cstatic int read_mouse(struct inode * inode, struct file * file, char * buffer, int count)
count104kernel/chr_drv/msbusmouse.cif (count < 3)
count119kernel/chr_drv/msbusmouse.cfor (i = 3; i < count; i++)
count201kernel/chr_drv/psaux.cstatic int write_aux(struct inode * inode, struct file * file, char * buffer, int count)
count203kernel/chr_drv/psaux.cint i = count;
count214kernel/chr_drv/psaux.creturn count;
count222kernel/chr_drv/psaux.cstatic int read_aux(struct inode * inode, struct file * file, char * buffer, int count)
count225kernel/chr_drv/psaux.cint i = count;
count247kernel/chr_drv/psaux.cif (count-i) {
count249kernel/chr_drv/psaux.creturn count-i;
count26kernel/chr_drv/pty.cif (!tty || (tty->count > 1))
count83kernel/chr_drv/pty.cwhile (!tty->link->count && !(current->signal & ~current->blocked))
count85kernel/chr_drv/pty.cif (!tty->link->count)
count248kernel/chr_drv/serial.cint head, tail, count;
count255kernel/chr_drv/serial.ccount = info->xmit_fifo_size;
count259kernel/chr_drv/serial.ccount--;
count261kernel/chr_drv/serial.cwhile (count-- && (tail != head)) {
count690kernel/chr_drv/serial.cint head, tail, count;
count700kernel/chr_drv/serial.ccount = info->xmit_fifo_size;
count701kernel/chr_drv/serial.cwhile (count--) {
count1080kernel/chr_drv/serial.cprintk("rs_close ttys%d, count = %d\n", info->line, info->count);
count1082kernel/chr_drv/serial.cif (--info->count > 0)
count1088kernel/chr_drv/serial.cinfo->count = 0;
count1162kernel/chr_drv/serial.cinfo->line, info->count);
count1164kernel/chr_drv/serial.cinfo->count--;
count1187kernel/chr_drv/serial.cinfo->line, info->count);
count1193kernel/chr_drv/serial.cinfo->count++;
count1197kernel/chr_drv/serial.cinfo->line, info->count);
count1222kernel/chr_drv/serial.cprintk("rs_open ttys%d, count = %d\n", info->line, info->count);
count1224kernel/chr_drv/serial.cinfo->count++;
count1542kernel/chr_drv/serial.cinfo->count = 0;
count169kernel/chr_drv/tty_io.cstatic int hung_up_tty_read(struct inode * inode, struct file * file, char * buf, int count)
count174kernel/chr_drv/tty_io.cstatic int hung_up_tty_write(struct inode * inode, struct file * file, char * buf, int count)
count790kernel/chr_drv/tty_io.cif (tty->link && !tty->link->count)
count848kernel/chr_drv/tty_io.cif (tty->link->count)
count874kernel/chr_drv/tty_io.cif (tty->link && !tty->link->count) {
count913kernel/chr_drv/tty_io.cif (tty->link && !tty->link->count)
count920kernel/chr_drv/tty_io.cstatic int tty_read(struct inode * inode, struct file * file, char * buf, int count)
count945kernel/chr_drv/tty_io.ci = (ldiscs[tty->disc].read)(tty,file,buf,count);
count953kernel/chr_drv/tty_io.cstatic int tty_write(struct inode * inode, struct file * file, char * buf, int count)
count981kernel/chr_drv/tty_io.ci = (ldiscs[tty->disc].write)(tty,file,buf,count);
count1006kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev) && tty_table[dev] && tty_table[dev]->count)
count1062kernel/chr_drv/tty_io.ctty_table[dev]->count++;
count1064kernel/chr_drv/tty_io.ctty_table[o_dev]->count++;
count1121kernel/chr_drv/tty_io.cif (--tty->link->count < 0) {
count1123kernel/chr_drv/tty_io.cdev, tty->count);
count1124kernel/chr_drv/tty_io.ctty->link->count = 0;
count1127kernel/chr_drv/tty_io.cif (--tty->count < 0) {
count1129kernel/chr_drv/tty_io.cdev, tty->count);
count1130kernel/chr_drv/tty_io.ctty->count = 0;
count1132kernel/chr_drv/tty_io.cif (tty->count)
count1148kernel/chr_drv/tty_io.cif (o_tty->count)
count1292kernel/chr_drv/tty_io.cif (tty->link && !tty->link->count)
count1308kernel/chr_drv/tty_io.cif (tty->link && !tty->link->count)
count1374kernel/chr_drv/tty_io.cint head, tail, count;
count1388kernel/chr_drv/tty_io.ccount = buflen;
count1391kernel/chr_drv/tty_io.cwhile (count && VLEFT > 0) {
count1396kernel/chr_drv/tty_io.cif (count) {
count1397kernel/chr_drv/tty_io.ctty->write_data_cnt = count;
count1403kernel/chr_drv/tty_io.creturn count;
count1417kernel/chr_drv/tty_io.cint  head, tail, count;
count1434kernel/chr_drv/tty_io.ccount = tty->write_data_cnt;
count1437kernel/chr_drv/tty_io.cwhile (count && VLEFT > 0) {
count1443kernel/chr_drv/tty_io.ctty->write_data_cnt = count;
count1445kernel/chr_drv/tty_io.cif (!count)
count74kernel/chr_drv/vt.ckd_mksound(unsigned int count, unsigned int ticks)
count76kernel/chr_drv/vt.cif (count)
count83kernel/chr_drv/vt.coutb_p(count & 0xff, 0x42);
count84kernel/chr_drv/vt.coutb((count >> 8) & 0xff, 0x42);
count310kernel/chr_drv/vt.cif (tty_table[i] && tty_table[i]->count > 0)
count324kernel/chr_drv/vt.cif (!tty_table[i] || tty_table[i]->count == 0)
count259kernel/exit.cint err, retval = 0, count = 0;
count266kernel/exit.c++count;
count270kernel/exit.creturn(count ? retval : -ESRCH);
count50kernel/printk.cunsigned long i, j, count;
count94kernel/printk.ccount = len;
count95kernel/printk.cif (count > 4096)
count96kernel/printk.ccount = 4096;
count97kernel/printk.cif (count > logged_chars)
count98kernel/printk.ccount = logged_chars;
count99kernel/printk.cj = log_start + log_size - count;
count100kernel/printk.cfor (i = 0; i < count; i++) {
count375kernel/sched.cstatic int count = LOAD_FREQ;
count377kernel/sched.cif (count-- > 0)
count379kernel/sched.ccount = LOAD_FREQ;
count708kernel/sys.clong count;
count715kernel/sys.ccount = inb_p(0x40);  /* read the latched count */
count716kernel/sys.ccount |= inb_p(0x40) << 8;
count718kernel/sys.cif (count < (LATCH - LATCH/100))
count731kernel/sys.c+ ((LATCH - 1) - count)*(1000000/HZ)/LATCH;
count11lib/write.c_syscall3(int,write,int,fd,const char *,buf,off_t,count)
count55net/socket.cstruct dirent *dirent, int count);
count276net/socket.cint count)
count521net/tcp/ip.cstatic int count = 0;
count579net/tcp/ip.ciph->id = net16(count++);
count259net/tcp/tcp.cint count=0;
count272net/tcp/tcp.ccount ++;
count273net/tcp/tcp.cif (count > 20)
count206net/tcp/we.clen = ring->count-4;
count209net/tcp/we.cring->count);
count388net/tcp/we.cbnd, pkt, cur, ring->status, ring->count,
count411net/tcp/we.cring->count, ring->status, bnd, pkt,
count525net/tcp/we.cint count = 0;
count620net/tcp/we.cif( ++count > max_pages + 1 ){
count621net/tcp/we.cprintk("\nwd8013_interrupt - infinite loop detected, isr = x%x, count = %d", isr, count );
count52net/tcp/wereg.hunsigned short count; /*packet lenght in bytes + 4 */