taglinefilesource code
size179drivers/block/cdu31a.cstatic void size_to_buf(unsigned int size,
size1114drivers/block/cdu31a.csize_to_buf(unsigned int size,
size1117drivers/block/cdu31a.cbuf[0] = size / 65536;
size1118drivers/block/cdu31a.csize = size % 65536;
size1119drivers/block/cdu31a.cbuf[1] = size / 256;
size1120drivers/block/cdu31a.cbuf[2] = size % 256;
size797drivers/block/floppy.cfloppy_sizes[drive] = floppy->size >> 1;
size1163drivers/block/floppy.cif (block+2 > floppy->size) {
size1317drivers/block/floppy.cfloppy_sizes[drive] = user_params[drive].size >> 1;
size700drivers/char/tpqic02.cstatic int send_qic02_data(char sb[], unsigned size, int ignore_ex)
size704drivers/char/tpqic02.cfor (i=0; i<size; i++) {
size765drivers/char/tpqic02.cstatic int rdstatus(char *stp, unsigned size, char qcmd)
size799drivers/char/tpqic02.cfor (q=stp; q<stp+size; q++)
size2503drivers/char/tpqic02.cstatic inline unsigned long const align_buffer(unsigned long a, unsigned size)
size2505drivers/char/tpqic02.cif (a & (size-1))      /* if not aligned */
size2506drivers/char/tpqic02.creturn (a | (size-1)) + 1;
size171drivers/net/3c505.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size81drivers/net/3c505dta.hword size,
size372drivers/net/3c507.cint size;
size375drivers/net/3c507.csize = 64*1024;
size379drivers/net/3c507.csize = ((mem_config & 3) + 1) << 14;
size383drivers/net/3c507.cdev->mem_end = base + size;
size40drivers/net/apricot.c#define check_region(addr, size)  0
size41drivers/net/apricot.c#define snarf_region(addr, size)  do ; while(0)
size45drivers/net/apricot.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size46drivers/net/apricot.c#define kfree_skbmem(buff, size) kfree_s(buff,size)
size96drivers/net/apricot.cunsigned short size;
size105drivers/net/apricot.cunsigned short size;
size115drivers/net/apricot.cunsigned short size;
size229drivers/net/apricot.clp->rx[i].size = 1532;
size589drivers/net/apricot.ctx_cmd->size = 0;
size591drivers/net/apricot.ctx_cmd->tbd->size = EOF | length;
size111drivers/net/atp.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size112drivers/net/atp.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size116drivers/net/atp.c#define check_region(ioaddr, size)    0
size117drivers/net/atp.c#define snarf_region(ioaddr, size);    do ; while (0)
size588drivers/net/de600.cint    size;
size593drivers/net/de600.csize = de600_read_byte(RX_LEN, dev);  /* low byte */
size594drivers/net/de600.csize += (de600_read_byte(RX_LEN, dev) << 8);  /* high byte */
size595drivers/net/de600.csize -= 4;  /* Ignore trailing 4 CRC-bytes */
size603drivers/net/de600.cif ((size < 32)  ||  (size > 1535)) {
size604drivers/net/de600.cprintk("%s: Bogus packet size %d.\n", dev->name, size);
size605drivers/net/de600.cif (size > 10000)
size610drivers/net/de600.cskb = alloc_skb(size, GFP_ATOMIC);
size614drivers/net/de600.cdev->name, size);
size625drivers/net/de600.cfor (i = size; i > 0; --i, ++buffer)
size630drivers/net/de600.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
size620drivers/net/de620.cint size;
size669drivers/net/de620.csize = header_buf.Rx_ByteCount - 4;
size670drivers/net/de620.cif ((size < RUNT) || (GIANT < size)) {
size671drivers/net/de620.cprintk("%s: Illegal packet size: %d!\n", dev->name, size);
size674drivers/net/de620.cskb = alloc_skb(size, GFP_ATOMIC);
size677drivers/net/de620.cdev->name, size);
size681drivers/net/de620.cskb->len = size; skb->dev = dev; skb->free = 1;
size685drivers/net/de620.cde620_read_block(buffer, size);
size686drivers/net/de620.cPRINTK(("Read %d bytes\n", size));
size51drivers/net/e2100.c#define check_region(ioaddr, size)              0
size52drivers/net/e2100.c#define snarf_region(ioaddr, size);             do ; while (0)
size30drivers/net/hp.c#define check_region(ioaddr, size)        0
size31drivers/net/hp.c#define snarf_region(ioaddr, size);        do ; while (0)
size37drivers/net/lance.c#define check_region(addr, size)  0
size38drivers/net/lance.c#define snarf_region(addr, size)  do ; while(0)
size332drivers/net/sk_g16.c#define check_region(ioaddr, size)              0
size333drivers/net/sk_g16.c#define snarf_region(ioaddr, size);             do ; while (0)
size73drivers/net/skeleton.c#define check_region(ioaddr, size)     0
size74drivers/net/skeleton.c#define  snarf_region(ioaddr, size);    do ; while (0)
size454drivers/net/slip.cint size;
size474drivers/net/slip.csize=skb->len;
size475drivers/net/slip.csl_encaps(sl, skb->data, size);
size32drivers/net/smc-ultra.c#define check_region(ioaddr, size)              0
size33drivers/net/smc-ultra.c#define snarf_region(ioaddr, size);             do ; while (0)
size33drivers/net/wd.c#define check_region(ioaddr, size)    0
size34drivers/net/wd.c#define snarf_region(ioaddr, size)    do ; while (0)
size996drivers/scsi/aha152x.cint size = disk->capacity;
size998drivers/scsi/aha152x.cprintk("aha152x_biosparam: dev=%x, size=%d, ", dev, size);
size1005drivers/scsi/aha152x.cinfo_array[2]=size>>11;
size1070drivers/scsi/aha1542.cint size = disk->capacity;
size1074drivers/scsi/aha1542.cif((size>>11) > 1024 && translation_algorithm == 2) {
size1078drivers/scsi/aha1542.cip[2] = size /255/63;
size1082drivers/scsi/aha1542.cip[2] = size >> 11;
size495drivers/scsi/aha1740.cint size = disk->capacity;
size499drivers/scsi/aha1740.cip[2] = size >> 11;
size1183drivers/scsi/buslogic.cint size = disk->capacity;
size1193drivers/scsi/buslogic.cif ((size >> 11) > 1024
size1198drivers/scsi/buslogic.cip[2] = size / 255 / 63;
size1202drivers/scsi/buslogic.cip[2] = size >> 11;
size691drivers/scsi/fdomain.cunsigned long blocks, size, capacity;
size695drivers/scsi/fdomain.csize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
size696drivers/scsi/fdomain.ccapacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
size699drivers/scsi/fdomain.c((capacity + 5L) / 10L), size );
size1459drivers/scsi/fdomain.cint        size = disk->capacity;
size1565drivers/scsi/fdomain.cif ((unsigned int)size >= 0x7e0000U) {
size1568drivers/scsi/fdomain.c} else if ((unsigned int)size >= 0x200000U) {
size1577drivers/scsi/fdomain.cinfo_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
size270drivers/scsi/hosts.hextern void * scsi_init_malloc(unsigned int size);
size271drivers/scsi/hosts.hextern void scsi_init_free(char * ptr, unsigned int size);
size397drivers/scsi/pas16.cint size = disk->capacity;
size400drivers/scsi/pas16.cip[2] = size >> 11;
size1724drivers/scsi/scsi.cvoid * scsi_init_malloc(unsigned int size)
size1728drivers/scsi/scsi.cretval = (unsigned int) kmalloc(size, GFP_ATOMIC);
size1731drivers/scsi/scsi.cscsi_init_memory_start += size;
size1737drivers/scsi/scsi.cvoid scsi_init_free(char * ptr, unsigned int size)
size1743drivers/scsi/scsi.cif(((unsigned int) ptr) + size == scsi_init_memory_start)
size545drivers/scsi/scsi_debug.cint size = disk->capacity;
size548drivers/scsi/scsi_debug.cinfo[2] = (size + 2047) >> 11;
size120drivers/scsi/sg.cstatic char *sg_malloc(int size)
size122drivers/scsi/sg.cif (size<=4096)
size123drivers/scsi/sg.creturn (char *) scsi_malloc(size);
size125drivers/scsi/sg.cif (size<SG_BIG_BUFF)
size140drivers/scsi/sg.cstatic void sg_free(char *buff,int size) 
size150drivers/scsi/sg.cscsi_free(buff,size);
size214drivers/scsi/sg.cint bsize,size,amt,i;
size268drivers/scsi/sg.csize=COMMAND_SIZE(get_fs_byte(buf));
size269drivers/scsi/sg.cmemcpy_fromfs(cmnd,buf,size);
size270drivers/scsi/sg.cbuf+=size;
size271drivers/scsi/sg.cmemcpy_fromfs(device->buff,buf,device->header.pack_len-size-sizeof(struct sg_header));
size296drivers/scsi/t128.cint size = disk->capacity;
size299drivers/scsi/t128.cip[2] = size >> 11;
size997drivers/scsi/ultrastor.cint size = disk->capacity;
size1002drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
size1230drivers/scsi/wd7000.cint size = disk->capacity;
size1233drivers/scsi/wd7000.cip[2] = size >> 11;
size521drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size)
size585drivers/sound/dmabuf.c*size = dmap->fragment_size;
size891drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size)
size132drivers/sound/os.h#define PERMANENT_MALLOC(typecast, mem_ptr, size, linux_ptr) \
size134drivers/sound/os.hlinux_ptr += (size);}
size100drivers/sound/pss.cstatic int      pss_download_boot (unsigned char *block, int size);
size643drivers/sound/pss.cpss_download_boot (unsigned char *block, int size)
size678drivers/sound/pss.cif (count >= size)
size683drivers/sound/pss.ccount, size);
size7drivers/sound/sound_calls.hint DMAbuf_getwrbuffer(int dev, char **buf, int *size);
size29fs/block_dev.cunsigned int size;
size52fs/block_dev.csize = (blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits;
size54fs/block_dev.csize = INT_MAX;
size56fs/block_dev.cif (block >= size)
size83fs/block_dev.cif (block + blocks > size) blocks = size - block;
size138fs/block_dev.cunsigned int size;
size155fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
size157fs/block_dev.csize = INT_MAX;
size161fs/block_dev.cif (offset > size)
size164fs/block_dev.cleft = size - offset;
size172fs/block_dev.csize >>= blocksize_bits;
size178fs/block_dev.cif (block + blocks > size)
size179fs/block_dev.cblocks = size - block;
size38fs/buffer.cstatic int grow_buffers(int pri, int size);
size39fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size);
size407fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
size413fs/buffer.cif (tmp->b_size == size)
size430fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
size435fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
size439fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
size445fs/buffer.cvoid set_blocksize(dev_t dev, int size)
size453fs/buffer.cswitch(size) {
size458fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
size459fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size462fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
size465fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size477fs/buffer.cif (bh->b_size == size)
size481fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
size492fs/buffer.cvoid refill_freelist(int size)
size497fs/buffer.cint isize = BUFSIZE_INDEX(size);
size514fs/buffer.cneeded =bdf_prm.b_un.nrefill * size;  
size517fs/buffer.cgrow_buffers(GFP_BUFFER, size)) {
size526fs/buffer.cwhile(maybe_shrink_lav_buffers(size))
size528fs/buffer.cif(!grow_buffers(GFP_BUFFER, size)) break;
size560fs/buffer.cif (bh->b_count || bh->b_size != size)
size600fs/buffer.cif (bh->b_count || bh->b_size != size)
size631fs/buffer.cif (bh->b_count || bh->b_size != size)
size660fs/buffer.cif (grow_buffers(GFP_BUFFER, size)) {
size667fs/buffer.cif (!grow_buffers(GFP_ATOMIC, size))
size683fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
size686fs/buffer.cint isize = BUFSIZE_INDEX(size);
size695fs/buffer.cbh = get_hash_table(dev, block, size);
size703fs/buffer.cwhile(!free_list[isize]) refill_freelist(size);
size705fs/buffer.cif (find_buffer(dev,block,size))
size795fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
size799fs/buffer.cif (!(bh = getblk(dev, block, size))) {
size928fs/buffer.cstatic struct buffer_head * create_buffers(unsigned long page, unsigned long size)
size935fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
size942fs/buffer.cbh->b_size = size;
size979fs/buffer.cdev_t dev, int *b, int size)
size995fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
size999fs/buffer.cfirst = get_hash_table(dev, block, size);
size1020fs/buffer.cdev_t dev, int b[], int size)
size1024fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1028fs/buffer.cbh = create_buffers(address, size);
size1033fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1037fs/buffer.cif (find_buffer(dev, block, size))
size1090fs/buffer.cdev_t dev, int *b, int size)
size1098fs/buffer.cbh = get_hash_table(dev, block, size);
size1100fs/buffer.creturn check_aligned(bh, address, dev, b, size);
size1101fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
size1104fs/buffer.c#define COPYBLK(size,from,to) \
size1106fs/buffer.c:"c" (((unsigned long) size) >> 2),"S" (from),"D" (to) \
size1116fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int share)
size1123fs/buffer.cwhere = try_to_share_buffers(address,dev,b,size);
size1128fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j+= size) {
size1131fs/buffer.cbh[i] = getblk(dev, b[i], size);
size1135fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size,address += size) {
size1138fs/buffer.cCOPYBLK(size, (unsigned long) bh[i]->b_data,address);
size1149fs/buffer.cstatic int grow_buffers(int pri, int size)
size1156fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
size1157fs/buffer.cprintk("VFS: grow_buffers: size = %d\n",size);
size1161fs/buffer.cisize = BUFSIZE_INDEX(size);
size1165fs/buffer.cbh = create_buffers(page, size);
size1255fs/buffer.cstatic int maybe_shrink_lav_buffers(int size)
size1278fs/buffer.cisize = (size ? BUFSIZE_INDEX(size) : -1);
size1313fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size)
size1320fs/buffer.cif(size) printk("Shrinking buffers of size %d\n", size);
size1324fs/buffer.cisize1 = (size ? BUFSIZE_INDEX(size) : -1);
size1353fs/buffer.cif(size && bh->b_size != size) continue;
size1472fs/buffer.cunsigned int starting_block, int size)
size1475fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1482fs/buffer.cwhile(nr_free[isize] < 32) refill_freelist(size);
size1498fs/buffer.cstatic unsigned long try_to_generate_cluster(dev_t dev, int block, int size)
size1501fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1509fs/buffer.cbh = create_buffers(page, size);
size1515fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1516fs/buffer.cif (find_buffer(dev, nblock++, size))
size1555fs/buffer.cunsigned long generate_cluster(dev_t dev, int b[], int size)
size1559fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
size1561fs/buffer.cif(find_buffer(dev, b[i], size)) return 0;
size1568fs/buffer.cif(maybe_shrink_lav_buffers(size))
size1571fs/buffer.cretval = try_to_generate_cluster(dev, b[0], size);
size1576fs/buffer.creturn try_to_generate_cluster(dev, b[0], size);
size1578fs/buffer.creturn reassign_cluster(dev, b[0], size);
size80fs/ext/file.cunsigned int size;
size91fs/ext/file.csize = inode->i_size;
size92fs/ext/file.cif (offset > size)
size95fs/ext/file.cleft = size - offset;
size103fs/ext/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
size109fs/ext/file.cif (block + blocks > size)
size110fs/ext/file.cblocks = size - block;
size35fs/ext2/balloc.c#define clear_block(addr,size) \
size40fs/ext2/balloc.c:"a" (0), "c" (size / 4), "D" ((long) (addr)) \
size45fs/ext2/balloc.cstatic inline int find_first_zero_bit (unsigned long * addr, unsigned size)
size49fs/ext2/balloc.cif (!size)
size66fs/ext2/balloc.c:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size71fs/ext2/balloc.cstatic inline int find_next_zero_bit (unsigned long * addr, int size,
size96fs/ext2/balloc.cres = find_first_zero_bit (p, size - 32 * (p - addr));
size100fs/ext2/balloc.cstatic inline char * find_first_zero_byte (char * addr, int size)
size104fs/ext2/balloc.cif (!size)
size114fs/ext2/balloc.c: "0" (addr), "c" (size)
size86fs/ext2/file.cunsigned int size;
size100fs/ext2/file.csize = inode->i_size;
size101fs/ext2/file.cif (offset > size)
size104fs/ext2/file.cleft = size - offset;
size112fs/ext2/file.csize = (size + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
size118fs/ext2/file.cif (block + blocks > size)
size119fs/ext2/file.cblocks = size - block;
size36fs/ext2/ialloc.cstatic inline int find_first_zero_bit (unsigned long * addr, unsigned size)
size40fs/ext2/ialloc.cif (!size)
size57fs/ext2/ialloc.c: "c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size28fs/ext2/inode.c#define clear_block(addr,size) \
size33fs/ext2/inode.c:"a" (0), "c" (size / 4), "D" ((long) (addr)) \
size28fs/ext2/truncate.c#define clear_block(addr,size,value) \
size33fs/ext2/truncate.c:"a" (value), "c" (size / 4), "D" ((long) (addr)) \
size388fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
size663fs/isofs/inode.cvoid * leak_check_malloc(unsigned int size){
size666fs/isofs/inode.ctmp = kmalloc(size, GFP_KERNEL);
size670fs/isofs/inode.cvoid leak_check_free_s(void * obj, int size){
size672fs/isofs/inode.creturn kfree_s(obj, size);
size675fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
size677fs/isofs/inode.creturn bread(dev, block, size);
size45fs/isofs/rock.ccont_size = isonum_733(rr->u.CE.size);}
size14fs/isofs/rock.hchar size[8];
size74fs/minix/file.cunsigned int size;
size85fs/minix/file.csize = inode->i_size;
size86fs/minix/file.cif (offset > size)
size89fs/minix/file.cleft = size - offset;
size97fs/minix/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
size103fs/minix/file.cif (block + blocks > size)
size104fs/minix/file.cblocks = size - block;
size84fs/msdos/file.cint left,offset,size,sector,cnt;
size105fs/msdos/file.cfilp->f_pos += (size = MIN(SECTOR_SIZE-offset,left));
size107fs/msdos/file.cmemcpy_tofs(buf,data+offset,size);
size108fs/msdos/file.cbuf += size;
size110fs/msdos/file.celse for (cnt = size; cnt; cnt--) {
size112fs/msdos/file.csize--;
size138fs/msdos/file.cint sector,offset,size,left,written;
size159fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
size167fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
size174fs/msdos/file.cbuf,written = size);
size175fs/msdos/file.cbuf += size;
size185fs/msdos/file.cfor (size = 0; size < count && left; size++) {
size375fs/msdos/inode.cinode->i_size = CF_LE_L(raw_entry->size);
size406fs/msdos/inode.craw_entry->size = 0;
size410fs/msdos/inode.craw_entry->size = CT_LE_L(inode->i_size);
size183fs/msdos/namei.cde->size = 0;
size230fs/nfs/dir.cif (fattr->size == -1 || fattr->uid == -1 || fattr->gid == -1
size347fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size383fs/nfs/dir.csattr.size = rdev; /* get out your barf bag */
size385fs/nfs/dir.csattr.size = (unsigned) -1;
size412fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size482fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size578fs/nfs/dir.cinode->i_size = fattr->size;
size213fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? inode->i_size : -1;
size215fs/nfs/inode.csattr.size = (unsigned) -1;
size65fs/nfs/proc.cstatic inline int *nfs_rpc_alloc(int size)
size67fs/nfs/proc.csize+=NFS_SLACK_SPACE;    /* Allow for the NFS crap as well as buffer */
size68fs/nfs/proc.creturn (int *)kmalloc(size,GFP_KERNEL);
size152fs/nfs/proc.cfattr->size = ntohl(*p++);
size172fs/nfs/proc.c*p++ = htonl(sattr->size);
size689fs/nfs/proc.cint size;
size693fs/nfs/proc.csize = server->rsize;
size700fs/nfs/proc.c*p++ = htonl(size);
size26fs/pipe.cint chars = 0, size = 0, read = 0;
size47fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
size51fs/pipe.cif (chars > size)
size52fs/pipe.cchars = size;
size203fs/proc/array.cint size = 0, result = 0;
size215fs/proc/array.cresult = size;
size216fs/proc/array.cif (size < PAGE_SIZE)
size217fs/proc/array.cbuffer[size++] = c;
size359fs/proc/array.cint size=0, resident=0, share=0, trs=0, lrs=0, drs=0, dt=0;
size375fs/proc/array.c++size;
size399fs/proc/array.csize, resident, share, trs, lrs, drs, dt);
size119fs/sysv/file.cunsigned int size;
size130fs/sysv/file.csize = inode->i_size;
size131fs/sysv/file.cif (offset > size)
size134fs/sysv/file.cleft = size - offset;
size142fs/sysv/file.csize = (size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
size147fs/sysv/file.cif (block + blocks > size)
size148fs/sysv/file.cblocks = size - block;
size81ibcs/binfmt_coff.cint clear_memory (unsigned long addr, unsigned long size)
size85ibcs/binfmt_coff.csize = (PAGE_SIZE - (addr & ~PAGE_MASK)) & ~PAGE_MASK;
size86ibcs/binfmt_coff.cif (size == 0)
size91ibcs/binfmt_coff.cprintk ("un-initialized storage in last page %d\n", size);
size95ibcs/binfmt_coff.c(void *) addr, size);
size101ibcs/binfmt_coff.cwhile (size-- != 0)
size103include/asm/system.h#define set_ldt_desc(n,addr,size) \
size104include/asm/system.h_set_tssldt_desc(((char *) (n)),((int)(addr)),((size << 3) - 1),"0x82")
size27include/linux/fd.hunsigned int  size,    /* nr of 512-byte sectors total */
size384include/linux/fs.hextern void refill_freelist(int size);
size439include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
size440include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
size445include/linux/fs.hextern void set_blocksize(dev_t dev, int size);
size446include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
size447include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int share);
size448include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block, int size, 
size451include/linux/fs.hunsigned long generate_cluster(dev_t dev, int b[], int size);
size110include/linux/iso_fs.hchar size      [ISODCL (11, 18)]; /* 733 */
size209include/linux/iso_fs.hextern void * leak_check_malloc(unsigned int size);
size210include/linux/iso_fs.hextern void leak_check_free_s(void * obj, int size);
size211include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
size10include/linux/malloc.hvoid *deb_kmalloc(const char *deb_file, unsigned short deb_line,unsigned int size, int priority);
size11include/linux/malloc.hvoid deb_kfree_s (const char *deb_file, unsigned short deb_line,void * obj, int size);
size12include/linux/malloc.hvoid deb_kcheck_s(const char *deb_file, unsigned short deb_line,void * obj, int size);
size20include/linux/malloc.hvoid * kmalloc(unsigned int size, int priority);
size21include/linux/malloc.hvoid kfree_s(void * obj, int size);
size144include/linux/mm.hextern int unmap_page_range(unsigned long from, unsigned long size);
size145include/linux/mm.hextern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask);
size146include/linux/mm.hextern int zeromap_page_range(unsigned long from, unsigned long size, int mask);
size162include/linux/mm.hextern void * vmalloc(unsigned long size);
size37include/linux/module.hint size; /* total, including string table!!! */
size52include/linux/module.hint size;      /* size of module in pages */
size88include/linux/msdos_fs.hunsigned long size;  /* file size (in bytes) */
size99include/linux/net.hint  (*read)    (struct socket *sock, char *ubuf, int size,
size101include/linux/net.hint  (*write)  (struct socket *sock, char *ubuf, int size,
size134include/linux/nfs.hu_int size;
size149include/linux/nfs.hu_int size;
size110include/linux/skbuff.hextern struct sk_buff *    alloc_skb(unsigned int size, int priority);
size111include/linux/skbuff.hextern void      kfree_skbmem(struct sk_buff *skb, unsigned size);
size140include/linux/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
size59ipc/sem.cint size;
size72ipc/sem.csize = sizeof (*sma) + nsems * sizeof (struct sem);
size74ipc/sem.csma = (struct semid_ds *) kmalloc (size, GFP_KERNEL);
size82ipc/sem.cmemset (sma, 0, size);
size19ipc/shm.cstatic int newseg (key_t key, int shmflg, int size);
size67ipc/shm.cstatic int newseg (key_t key, int shmflg, int size)
size70ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
size73ipc/shm.cif (size < SHMMIN)
size109ipc/shm.cshp->shm_segsz = size;
size126ipc/shm.cint sys_shmget (key_t key, int size, int shmflg)
size131ipc/shm.cif (size < 0 || size > SHMMAX)
size134ipc/shm.creturn newseg(key, shmflg, size);
size138ipc/shm.creturn newseg(key, shmflg, size);
size145ipc/shm.cif (size > shp->shm_segsz)
size31ipc/util.cextern int sys_shmget (key_t key, int size, int flag);
size19kernel/ldt.cunsigned long size;
size23kernel/ldt.csize = LDT_ENTRIES*LDT_ENTRY_SIZE;
size26kernel/ldt.csize = sizeof(default_ldt);
size28kernel/ldt.cif (size > bytecount)
size29kernel/ldt.csize = bytecount;
size30kernel/ldt.cerror = verify_area(VERIFY_WRITE, ptr, size);
size33kernel/ldt.cmemcpy_tofs(ptr, address, size);
size34kernel/ldt.creturn size;
size117kernel/module.csys_create_module(char *module_name, unsigned long size)
size128kernel/module.cif (module_name == NULL || size == 0)
size141kernel/module.cnpages = (size + sizeof (int) + 4095) / 4096;
size151kernel/module.cmp->size = npages;
size160kernel/module.cmp->name, (unsigned long) mp->size, (unsigned long) mp->addr));
size201kernel/module.cif ((codesize + sizeof (int) + 4095) / 4096 > mp->size)
size205kernel/module.cmp->size * 4096 - (codesize + sizeof (int)));
size214kernel/module.cint size;
size219kernel/module.cmemcpy_fromfs((char *)(&(size)), symtab, sizeof(int));
size221kernel/module.cif ((newtab = (struct symbol_table*) kmalloc(size, GFP_KERNEL)) == NULL) {
size225kernel/module.cif ((error = verify_area(VERIFY_READ, symtab, size)))
size227kernel/module.cmemcpy_fromfs((char *)(newtab), symtab, size);
size434kernel/module.cif (mp->symtab->size)
size435kernel/module.ckfree_s(mp->symtab, mp->symtab->size);
size457kernel/module.cchar size[32];
size470kernel/module.csprintf(size, "%d", mp->size);
size471kernel/module.ci -= strlen(size);
size476kernel/module.cq = size;
size67kernel/vsprintf.cstatic char * number(char * str, int num, int base, int size, int precision
size84kernel/vsprintf.cif (sign) size--;
size86kernel/vsprintf.cif (base==16) size -= 2;
size87kernel/vsprintf.celse if (base==8) size--;
size94kernel/vsprintf.csize -= precision;
size96kernel/vsprintf.cwhile(size-->0)
size108kernel/vsprintf.cwhile(size-->0)
size114kernel/vsprintf.cwhile(size-->0)
size87mm/kmalloc.cint size;
size121mm/kmalloc.c#define BLOCKSIZE(order)        (sizes[order].size)
size151mm/kmalloc.cint get_order (int size)
size156mm/kmalloc.csize += sizeof (struct block_header); 
size158mm/kmalloc.cif (size <= BLOCKSIZE (order))
size163mm/kmalloc.cvoid * kmalloc (size_t size, int priority)
size175mm/kmalloc.c((unsigned long *)&size)[-1]);
size180mm/kmalloc.corder = get_order (size);
size183mm/kmalloc.cprintk ("kmalloc of too large a block (%d bytes).\n",size);
size211mm/kmalloc.csizes [order].nbytesmalloced += size;
size213mm/kmalloc.cp->bh_length = size;
size279mm/kmalloc.csize);
size284mm/kmalloc.cvoid kfree_s (void *ptr,int size)
size302mm/kmalloc.cif (size &&
size303mm/kmalloc.csize != p->bh_length)
size306mm/kmalloc.cp,size,p->bh_length);
size309mm/kmalloc.csize = p->bh_length;
size361mm/kmalloc.csizes[order].nbytesmalloced -= size;
size284mm/memory.cint unmap_page_range(unsigned long from, unsigned long size)
size294mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size297mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size298mm/memory.cpcnt = size;
size300mm/memory.cfor ( ; size > 0; ++dir, size -= pcnt,
size301mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size)) {
size336mm/memory.cint zeromap_page_range(unsigned long from, unsigned long size, int mask)
size354mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size356mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size357mm/memory.cpcnt = size;
size359mm/memory.cwhile (size > 0) {
size375mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size388mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size399mm/memory.cint remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask)
size416mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size418mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size419mm/memory.cpcnt = size;
size421mm/memory.cwhile (size > 0) {
size437mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size470mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size666mm/memory.cstatic int __verify_write(unsigned long start, unsigned long size)
size668mm/memory.csize--;
size669mm/memory.csize += start & ~PAGE_MASK;
size670mm/memory.csize >>= PAGE_SHIFT;
size675mm/memory.c} while (size--);
size679mm/memory.cint verify_area(int type, const void * addr, unsigned long size)
size703mm/memory.cwhile (vma->vm_end - (unsigned long) addr < size) {
size711mm/memory.cif (wp_works_ok || type == VERIFY_READ || !size)
size713mm/memory.creturn __verify_write((unsigned long) addr,size);
size582mm/swap.cdo { unsigned long size = PAGE_SIZE << high; \
size584mm/swap.chigh--; size >>= 1; cli(); \
size588mm/swap.caddr = (struct mem_list *) (size + (unsigned long) addr); \
size22mm/vmalloc.cunsigned long size;
size106mm/vmalloc.cstatic int do_area(void * addr, unsigned long size,
size111mm/vmalloc.cnr = size >> PAGE_SHIFT;
size141mm/vmalloc.cdo_area(tmp->addr, tmp->size, free_area_pages);
size149mm/vmalloc.cvoid * vmalloc(unsigned long size)
size154mm/vmalloc.csize = PAGE_ALIGN(size);
size155mm/vmalloc.cif (!size || size > high_memory)
size161mm/vmalloc.carea->size = size + PAGE_SIZE;
size164mm/vmalloc.cif (size + (unsigned long) addr < (unsigned long) tmp->addr)
size166mm/vmalloc.caddr = (void *) (tmp->size + (unsigned long) tmp->addr);
size171mm/vmalloc.cif (do_area(addr, size, alloc_area_pages)) {
size191mm/vmalloc.cn = tmp->size - PAGE_SIZE;
size96net/inet/af_inet.cint size = 32767; /* a big num. */
size121net/inet/af_inet.cif (j < size) 
size124net/inet/af_inet.csize = j;
size1028net/inet/af_inet.cstatic int inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, 
size1040net/inet/af_inet.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
size1045net/inet/af_inet.cstatic int inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
size1049net/inet/af_inet.creturn inet_recvfrom(sock,ubuf,size,noblock,flags,NULL,NULL);
size1052net/inet/af_inet.cstatic int inet_read(struct socket *sock, char *ubuf, int size, int noblock)
size1061net/inet/af_inet.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
size1064net/inet/af_inet.cstatic int inet_send(struct socket *sock, void *ubuf, int size, int noblock, 
size1078net/inet/af_inet.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
size1081net/inet/af_inet.cstatic int inet_write(struct socket *sock, char *ubuf, int size, int noblock)
size1083net/inet/af_inet.creturn inet_send(sock,ubuf,size,noblock,0);
size1086net/inet/af_inet.cstatic int inet_sendto(struct socket *sock, void *ubuf, int size, int noblock, 
size1102net/inet/af_inet.creturn(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, 
size882net/inet/arp.cint size;
size888net/inet/arp.csize = sprintf(buffer,"IP address       HW type     Flags       HW address\n");
size889net/inet/arp.cpos+=size;
size890net/inet/arp.clen+=size;
size918net/inet/arp.csize = sprintf(buffer+len,
size925net/inet/arp.clen+=size;
size162net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
size166net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
size934net/inet/dev.cint size;
size937net/inet/dev.csize = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
size949net/inet/dev.csize = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
size951net/inet/dev.creturn size;
size964net/inet/dev.cint size;
size969net/inet/dev.csize = sprintf(buffer, "Inter-|   Receive                  |  Transmit\n"
size972net/inet/dev.cpos+=size;
size973net/inet/dev.clen+=size;
size978net/inet/dev.csize = sprintf_stats(buffer+len, dev);
size979net/inet/dev.clen+=size;
size358net/inet/icmp.cint size, offset;
size363net/inet/icmp.csize = dev->hard_header_len + 64 + len;
size364net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size424net/inet/icmp.cint size, offset;
size429net/inet/icmp.csize = dev->hard_header_len + 64 + len;
size431net/inet/icmp.cif (! (skb2 = alloc_skb(size, GFP_ATOMIC))) 
size514net/inet/icmp.cint size, offset;
size520net/inet/icmp.csize = dev->hard_header_len + 64 + len;
size521net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size1826net/inet/ip.cint size;
size1830net/inet/ip.csize = skb->len - (((unsigned char *) th) - skb->data);
size1837net/inet/ip.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size963net/inet/ipx.cint size;
size1020net/inet/ipx.csize=sizeof(ipx_packet)+len;  /* For mac headers */
size1038net/inet/ipx.csize += dev->hard_header_len;
size1039net/inet/ipx.csize += dl->header_length;
size1042net/inet/ipx.cprintk("IPX: sendto: allocating buffer (%d)\n",size);
size1044net/inet/ipx.cif(size+sk->wmem_alloc>sk->sndbuf) {
size1048net/inet/ipx.cskb=alloc_skb(size,GFP_KERNEL);
size1056net/inet/ipx.cskb->len=size;
size1129net/inet/ipx.cstatic int ipx_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
size1131net/inet/ipx.creturn ipx_sendto(sock,ubuf,size,noblock,flags,NULL,0);
size1134net/inet/ipx.cstatic int ipx_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
size1176net/inet/ipx.cstatic int ipx_write(struct socket *sock, char *ubuf, int size, int noblock)
size1178net/inet/ipx.creturn ipx_send(sock,ubuf,size,noblock,0);
size1182net/inet/ipx.cstatic int ipx_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1188net/inet/ipx.creturn ipx_recvfrom(sock,ubuf,size,noblock,flags,NULL, NULL);
size1191net/inet/ipx.cstatic int ipx_read(struct socket *sock, char *ubuf, int size, int noblock)
size1193net/inet/ipx.creturn ipx_recv(sock,ubuf,size,noblock,0);
size453net/inet/rarp.cint size;
size459net/inet/rarp.csize = sprintf(buffer,"RARP disabled until entries added to cache.\n");
size460net/inet/rarp.cpos+=size;
size461net/inet/rarp.clen+=size;
size465net/inet/rarp.csize = sprintf(buffer,
size467net/inet/rarp.cpos+=size;
size468net/inet/rarp.clen+=size;
size480net/inet/rarp.csize = sprintf(buffer+len,
size491net/inet/rarp.clen+=size;
size487net/inet/route.cint size;
size499net/inet/route.csize = sprintf(buffer+len, "%s\t%08lX\t%08lX\t%02X\t%d\t%lu\t%d\t%08lX\t%d\t%lu\n",
size503net/inet/route.clen+=size;
size504net/inet/route.cpos+=size;
size403net/inet/skbuff.cstruct sk_buff *alloc_skb(unsigned int size,int priority)
size412net/inet/skbuff.c((unsigned long *)&size)[-1]);
size417net/inet/skbuff.csize+=sizeof(struct sk_buff);
size418net/inet/skbuff.cskb=(struct sk_buff *)kmalloc(size,priority);
size434net/inet/skbuff.cskb->truesize = size;
size435net/inet/skbuff.cskb->mem_len = size;
size449net/inet/skbuff.cnet_memory += size;
size463net/inet/skbuff.cvoid kfree_skbmem(struct sk_buff *skb,unsigned size)
size474net/inet/skbuff.cif(size!=skb->truesize)
size483net/inet/skbuff.ckfree_s((void *)skb,size);
size485net/inet/skbuff.cnet_memory -= size;
size311net/inet/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
size315net/inet/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) 
size317net/inet/sock.cstruct sk_buff * c = alloc_skb(size, priority);
size328net/inet/sock.creturn(alloc_skb(size, priority));
size332net/inet/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
size336net/inet/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) 
size338net/inet/sock.cstruct sk_buff *c = alloc_skb(size, priority);
size349net/inet/sock.creturn(alloc_skb(size, priority));
size384net/inet/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
size387net/inet/sock.ckfree_skbmem(skb, size);
size390net/inet/sock.csk->wmem_alloc -= size;
size399net/inet/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
size402net/inet/sock.ckfree_skbmem(skb, size);
size405net/inet/sock.csk->rmem_alloc -= size;
size179net/inet/sock.hunsigned long size, int force,
size182net/inet/sock.hunsigned long size, int force,
size185net/inet/sock.hunsigned long size);
size187net/inet/sock.hunsigned long size);
size261net/inet/sock.hunsigned long size, int force,
size264net/inet/sock.hunsigned long size, int force,
size267net/inet/sock.hunsigned long size);
size269net/inet/sock.hunsigned long size);
size616net/inet/tcp.cint size;
size620net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
size623net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
size632net/inet/tcp.cif (size == sizeof(struct tcphdr)) 
size645net/inet/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
size669net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size2398net/inet/tcp.cint size;
size2409net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
size2414net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size257net/inet/udp.cint size, tmp;
size263net/inet/udp.csize = sk->prot->max_header + len;
size264net/inet/udp.cskb = sk->prot->wmalloc(sk, size, 0, GFP_KERNEL);
size55net/socket.cint size);
size57net/socket.cint size);
size369net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *ubuf, int size)
size382net/socket.cif(size<0)
size384net/socket.cif(size==0)
size386net/socket.cif ((err=verify_area(VERIFY_WRITE,ubuf,size))<0)
size388net/socket.creturn(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));
size396net/socket.cstatic int sock_write(struct inode *inode, struct file *file, char *ubuf, int size)
size410net/socket.cif(size<0)
size412net/socket.cif(size==0)
size415net/socket.cif ((err=verify_area(VERIFY_READ,ubuf,size))<0)
size417net/socket.creturn(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
size73net/unix/sock.cstatic int unix_proto_read(struct socket *sock, char *ubuf, int size,
size75net/unix/sock.cstatic int unix_proto_write(struct socket *sock, char *ubuf, int size,
size608net/unix/sock.cstatic int unix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
size613net/unix/sock.cif ((todo = size) <= 0) 
size663net/unix/sock.creturn(size - todo);
size673net/unix/sock.cstatic int unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
size678net/unix/sock.cif ((todo = size) <= 0)
size754net/unix/sock.creturn(size - todo);
size83zBoot/gzip.h#  define DECLARE(type, array, size)  type * near array
size84zBoot/gzip.h#  define ALLOC(type, array, size) { \
size85zBoot/gzip.harray = (type*)fcalloc((unsigned)(((size)+1L)/2), 2*sizeof(type)); \
size91zBoot/gzip.h#  define DECLARE(type, array, size)  type array[size]
size92zBoot/gzip.h#  define ALLOC(type, array, size)
size238zBoot/gzip.hextern int file_read  OF((char *buf,  unsigned size));
size265zBoot/gzip.hextern   int (*read_buf) OF((char *buf, unsigned size));
size281zBoot/gzip.hextern voidp xmalloc      OF((unsigned int size));
size83zBoot/misc.cvoid *malloc(int size)
size87zBoot/misc.cif (size <0) error("Malloc error\n");
size94zBoot/misc.cfree_mem_ptr += size;