taglinefilesource code
size827drivers/block/cdu31a.csize_to_buf(unsigned int size,
size830drivers/block/cdu31a.cbuf[0] = size / 65536;
size831drivers/block/cdu31a.csize = size % 65536;
size832drivers/block/cdu31a.cbuf[1] = size / 256;
size833drivers/block/cdu31a.cbuf[2] = size % 256;
size688drivers/block/floppy.cfloppy_sizes[drive] = floppy->size >> 1;
size1045drivers/block/floppy.cif (block+2 > floppy->size) {
size1199drivers/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;
size57drivers/net/3c501.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size58drivers/net/3c501.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size59drivers/net/3c507.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size60drivers/net/3c507.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size363drivers/net/3c507.cint size;
size366drivers/net/3c507.csize = 64*1024;
size370drivers/net/3c507.csize = ((mem_config & 3) + 1) << 14;
size373drivers/net/3c507.cif (size != 0x10000)
size377drivers/net/3c507.cdev->mem_end = base + size;
size47drivers/net/3c509.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size64drivers/net/8390.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size65drivers/net/8390.c#define kfree_skbmem(addr, size) kfree_s(addr,size)
size56drivers/net/at1700.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size57drivers/net/at1700.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size93drivers/net/d_link.c#define alloc_skb(size,pri)  (struct sk_buff *)kmalloc(size,pri)
size561drivers/net/d_link.cint    size;
size567drivers/net/d_link.csize = d_link_read_byte(RX_LEN, dev);  /* low byte */
size568drivers/net/d_link.csize += (d_link_read_byte(RX_LEN, dev) << 8);  /* high byte */
size569drivers/net/d_link.csize -= 4;  /* Ignore trailing 4 CRC-bytes */
size577drivers/net/d_link.cif ((size < 32)  ||  (size > 1535))
size578drivers/net/d_link.cprintk("%s: Bogus packet size %d.\n", dev->name, size);
size580drivers/net/d_link.csksize = sizeof(struct sk_buff) + size;
size598drivers/net/d_link.cfor (i = size; i > 0; --i, ++buffer)
size603drivers/net/d_link.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
size59drivers/net/eexpress.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size39drivers/net/lance.c#define check_region(addr, size)  0
size40drivers/net/lance.c#define snarf_region(addr, size)  do ; while(0)
size44drivers/net/lance.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size45drivers/net/lance.c#define kfree_skbmem(buff, size) kfree_s(buff,size)
size75drivers/net/skeleton.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size76drivers/net/skeleton.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size80drivers/net/skeleton.c#define check_region(ioaddr, size)     0
size81drivers/net/skeleton.c#define  snarf_region(ioaddr, size);    do ; while (0)
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)
size964drivers/scsi/aha152x.cint aha152x_biosparam( int size, int dev, int *info_array )
size975drivers/scsi/aha152x.cprintk("dev=%x, size=%d, ", dev, size);
size982drivers/scsi/aha152x.cinfo_array[2]=size>>11;
size850drivers/scsi/aha1542.cint aha1542_biosparam(int size, int dev, int * ip)
size854drivers/scsi/aha1542.cip[2] = size >> 11;
size494drivers/scsi/aha1740.cint aha1740_biosparam(int size, int dev, int* ip)
size499drivers/scsi/aha1740.cip[2] = size >> 11;
size663drivers/scsi/fdomain.cunsigned long blocks, size, capacity;
size667drivers/scsi/fdomain.csize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
size668drivers/scsi/fdomain.ccapacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
size671drivers/scsi/fdomain.c((capacity + 5L) / 10L), size );
size1429drivers/scsi/fdomain.cint fdomain_16x0_biosparam( int size, int dev, int *info_array )
size396drivers/scsi/pas16.cint pas16_biosparam(int size, int dev, int * ip)
size400drivers/scsi/pas16.cip[2] = size >> 11;
size482drivers/scsi/scsi_debug.cint scsi_debug_biosparam(int size, int* info){
size485drivers/scsi/scsi_debug.cinfo[2] = (size + 2047) >> 11;
size1603drivers/scsi/seagate.cint seagate_st0x_biosparam(int size, int dev, int* ip) {
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);
size211drivers/scsi/sg.cint bsize,size,amt,i;
size264drivers/scsi/sg.csize=COMMAND_SIZE(get_fs_byte(buf));
size265drivers/scsi/sg.cmemcpy_fromfs(cmnd,buf,size);
size266drivers/scsi/sg.cbuf+=size;
size267drivers/scsi/sg.cmemcpy_fromfs(device->buff,buf,device->header.pack_len-size-sizeof(struct sg_header));
size295drivers/scsi/t128.cint t128_biosparam(int size, int dev, int * ip)
size299drivers/scsi/t128.cip[2] = size >> 11;
size987drivers/scsi/ultrastor.cint ultrastor_biosparam(int size, int dev, int * dkinfo)
size993drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
size609drivers/scsi/wd7000.cint wd7000_biosparam(int size, int dev, int* ip)
size617drivers/scsi/wd7000.cip[2] = size >> 11;
size397drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size)
size448drivers/sound/dmabuf.c*size = dev_buffsize[dev];
size718drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size)
size8drivers/sound/sound_calls.hint DMAbuf_getwrbuffer(int dev, char **buf, int *size);
size24fs/block_dev.cunsigned int size;
size45fs/block_dev.csize = (blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits;
size47fs/block_dev.csize = INT_MAX;
size49fs/block_dev.cif (block >= size)
size91fs/block_dev.cunsigned int size;
size108fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
size110fs/block_dev.csize = INT_MAX;
size112fs/block_dev.cif (offset > size)
size115fs/block_dev.cleft = size - offset;
size123fs/block_dev.csize >>= blocksize_bits;
size128fs/block_dev.cif (block + blocks > size)
size129fs/block_dev.cblocks = size - block;
size49fs/buffer.cstatic int grow_buffers(int pri, int size);
size357fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
size363fs/buffer.cif (tmp->b_size == size)
size380fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
size385fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
size389fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
size395fs/buffer.cvoid set_blocksize(dev_t dev, int size)
size403fs/buffer.cswitch(size) {
size408fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
size409fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size412fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
size415fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size425fs/buffer.cif (bh->b_size == size)
size429fs/buffer.cif (bh->b_dev == dev && bh->b_size != size)
size447fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
size454fs/buffer.cbh = get_hash_table(dev, block, size);
size460fs/buffer.cgrow_size -= size;
size462fs/buffer.cif (grow_buffers(GFP_BUFFER, size))
size469fs/buffer.cif (tmp->b_count || tmp->b_size != size)
size488fs/buffer.cif (grow_buffers(GFP_BUFFER, size))
size494fs/buffer.cif (!grow_buffers(GFP_ATOMIC, size))
size499fs/buffer.cif (bh->b_count || bh->b_size != size)
size507fs/buffer.cif (find_buffer(dev,block,size))
size540fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
size544fs/buffer.cif (!(bh = getblk(dev, block, size))) {
size652fs/buffer.cstatic struct buffer_head * create_buffers(unsigned long page, unsigned long size)
size659fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
size666fs/buffer.cbh->b_size = size;
size702fs/buffer.cdev_t dev, int *b, int size)
size718fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
size722fs/buffer.cfirst = get_hash_table(dev, block, size);
size743fs/buffer.cdev_t dev, int b[], int size)
size750fs/buffer.cbh = create_buffers(address, size);
size754fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size758fs/buffer.ctmp = get_hash_table(dev, block, size);
size809fs/buffer.cdev_t dev, int *b, int size)
size817fs/buffer.cbh = get_hash_table(dev, block, size);
size819fs/buffer.creturn check_aligned(bh, address, dev, b, size);
size820fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
size823fs/buffer.c#define COPYBLK(size,from,to) \
size825fs/buffer.c:"c" (((unsigned long) size) >> 2),"S" (from),"D" (to) \
size835fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int prot)
size842fs/buffer.cwhere = try_to_share_buffers(address,dev,b,size);
size847fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j+= size) {
size850fs/buffer.cbh[i] = getblk(dev, b[i], size);
size854fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size,address += size) {
size857fs/buffer.cCOPYBLK(size, (unsigned long) bh[i]->b_data,address);
size868fs/buffer.cstatic int grow_buffers(int pri, int size)
size873fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
size874fs/buffer.cprintk("VFS: grow_buffers: size = %d\n",size);
size879fs/buffer.cbh = create_buffers(page, 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;
size108fs/ext/file.cif (block + blocks > size)
size109fs/ext/file.cblocks = size - block;
size34fs/ext2/balloc.c#define clear_block(addr,size) \
size39fs/ext2/balloc.c:"a" (0), "c" (size / 4), "D" ((long) (addr)) \
size42fs/ext2/balloc.cstatic inline int find_first_zero_bit (unsigned long * addr, unsigned size)
size46fs/ext2/balloc.cif (!size)
size63fs/ext2/balloc.c:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size68fs/ext2/balloc.cstatic inline int find_next_zero_bit (unsigned long * addr, int size,
size89fs/ext2/balloc.cres = find_first_zero_bit (p, size - 32 * (p - addr));
size93fs/ext2/balloc.cstatic inline char * find_first_zero_byte (char * addr, int size)
size97fs/ext2/balloc.cif (!size)
size107fs/ext2/balloc.c: "0" (addr), "c" (size)
size83fs/ext2/file.cunsigned int size;
size97fs/ext2/file.csize = inode->i_size;
size98fs/ext2/file.cif (offset > size)
size101fs/ext2/file.cleft = size - offset;
size109fs/ext2/file.csize = (size + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
size115fs/ext2/file.cif (block + blocks > size)
size116fs/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)
size21fs/ext2/truncate.c#define clear_block(addr,size,value) \
size26fs/ext2/truncate.c:"a" (value), "c" (size / 4), "D" ((long) (addr)) \
size374fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
size633fs/isofs/inode.cvoid * leak_check_malloc(unsigned int size){
size636fs/isofs/inode.ctmp = kmalloc(size, GFP_KERNEL);
size640fs/isofs/inode.cvoid leak_check_free_s(void * obj, int size){
size642fs/isofs/inode.creturn kfree_s(obj, size);
size645fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
size647fs/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;
size102fs/minix/file.cif (block + blocks > size)
size103fs/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;
size121fs/nfs/proc.cfattr->size = ntohl(*p++);
size141fs/nfs/proc.c*p++ = htonl(sattr->size);
size536fs/nfs/proc.cint size;
size540fs/nfs/proc.csize = server->rsize;
size544fs/nfs/proc.c*p++ = htonl(size);
size18fs/pipe.cint chars, size, read = 0;
size29fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
size33fs/pipe.cif (chars > size)
size34fs/pipe.cchars = size;
size52fs/pipe.cint chars, size, written = 0;
size60fs/pipe.csize = PAGE_SIZE-count;
size62fs/pipe.csize = PAGE_SIZE-1;
size64fs/pipe.cwhile (PIPE_SIZE(*inode) >= size) {
size76fs/pipe.cwhile (count>0 && (size = (PAGE_SIZE-1)-PIPE_SIZE(*inode))) {
size80fs/pipe.cif (chars > size)
size81fs/pipe.cchars = size;
size90fs/pipe.csize = PAGE_SIZE-1;
size157fs/proc/array.cint size = 0, result = 0;
size169fs/proc/array.cresult = size;
size170fs/proc/array.cif (size < PAGE_SIZE)
size171fs/proc/array.cbuffer[size++] = c;
size309fs/proc/array.cint size=0, resident=0, share=0, trs=0, lrs=0, drs=0, dt=0;
size325fs/proc/array.c++size;
size349fs/proc/array.csize, resident, share, trs, lrs, drs, dt);
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 */
size374include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
size375include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
size380include/linux/fs.hextern void set_blocksize(dev_t dev, int size);
size381include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
size382include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int prot);
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);
size97include/linux/mm.hextern int unmap_page_range(unsigned long from, unsigned long size);
size98include/linux/mm.hextern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask);
size99include/linux/mm.hextern int zeromap_page_range(unsigned long from, unsigned long size, int mask);
size115include/linux/mm.hextern void * vmalloc(unsigned long size);
size88include/linux/msdos_fs.hunsigned long size;  /* file size (in bytes) */
size101include/linux/net.hint  (*read)    (struct socket *sock, char *ubuf, int size,
size103include/linux/net.hint  (*write)  (struct socket *sock, char *ubuf, int size,
size134include/linux/nfs.hu_int size;
size149include/linux/nfs.hu_int size;
size58ipc/sem.cint size;
size71ipc/sem.csize = sizeof (*sma) + nsems * sizeof (struct sem);
size73ipc/sem.csma = (struct semid_ds *) kmalloc (size, GFP_KERNEL);
size81ipc/sem.cmemset (sma, 0, size);
size19ipc/shm.cstatic int newseg (key_t key, int shmflg, int size);
size66ipc/shm.cstatic int newseg (key_t key, int shmflg, int size)
size69ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
size72ipc/shm.cif (size < SHMMIN)
size108ipc/shm.cshp->shm_segsz = size;
size125ipc/shm.cint sys_shmget (key_t key, int size, int shmflg)
size130ipc/shm.cif (size < 0 || size > SHMMAX)
size133ipc/shm.creturn newseg(key, shmflg, size);
size137ipc/shm.creturn newseg(key, shmflg, size);
size144ipc/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 = PAGE_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;
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)
size80lib/malloc.cunsigned int    size;
size91lib/malloc.cunsigned short size;
size191lib/malloc.cfor (bdir = bucket_dir ; bdir->size < len ; bdir++) {
size192lib/malloc.cif (!bdir->size)
size237lib/malloc.cbdesc->bucket_size = bdir->size;
size241lib/malloc.cfor (i=PAGE_SIZE/bdir->size; i > 0 ; i--) {
size246lib/malloc.che = (struct hdr_end *)(page+(bdir->size-sizeof(struct hdr_end)));
size250lib/malloc.chd->size = bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end);
size253lib/malloc.cmemset(hd+1,0xF8,hd->size);
size255lib/malloc.c*((void **) (hd+1)) = (i==1) ? NULL : (void *)(page + bdir->size);
size257lib/malloc.c*((void **) page) = (i==1) ? NULL : (void *)(page + bdir->size);
size259lib/malloc.cpage += bdir->size;
size292lib/malloc.cif(len > hd->size || len > bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end)) {
size294lib/malloc.chd->size,bdir->size,len,hd->file,hd->line,deb_file,deb_line);
size301lib/malloc.cwhile(pos < hd->size) {
size304lib/malloc.cretval,pos,hd->size,hd->file,hd->line);
size310lib/malloc.che = (struct hdr_end *)(((char *)retval)+hd->size);
size312lib/malloc.cprintk("DEB_MALLOC overran 0x%x:%d while free, from %s:%d\n",retval,hd->size,hd->file,hd->line);
size318lib/malloc.chd->size = len;
size333lib/malloc.cvoid *obj, int size)
size352lib/malloc.cif(hd->size != size) {
size353lib/malloc.cif(size != 0) {
size355lib/malloc.cobj,size,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
size357lib/malloc.csize = hd->size;
size359lib/malloc.che = (struct hdr_end *)(((char *)obj)+size);
size362lib/malloc.cobj,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
size380lib/malloc.cvoid *obj, int size)
size382lib/malloc.cvoid kfree_s(void *obj, int size)
size404lib/malloc.cif(hd->size != size) {
size405lib/malloc.cif(size != 0) {
size408lib/malloc.cobj,size,hd->size,deb_file,deb_line,hd->ok_file,hd->ok_line);
size410lib/malloc.csize = hd->size;
size412lib/malloc.che = (struct hdr_end *)(((char *)obj)+size);
size416lib/malloc.cobj,hd->size,deb_file,deb_line,hd->file,hd->line,hd->ok_file,hd->ok_line);
size418lib/malloc.csize += sizeof(struct hdr_start)+sizeof(struct hdr_end);
size426lib/malloc.cfor (bdir = bucket_dir; bdir->size; bdir++) {
size429lib/malloc.cif (bdir->size >= size) {
size446lib/malloc.cprintk("Bad address passed to kernel kfree_s(%p, %d)\n",obj, size);
size467lib/malloc.chd->size = bdir->size-sizeof(struct hdr_start)-sizeof(struct hdr_end);
size468lib/malloc.che = (struct hdr_end *)(((char *)obj)+hd->size);
size469lib/malloc.cmemset(obj, 0xf8, hd->size);
size517lib/malloc.cfor (bdir = bucket_dir; bdir->size; bdir++) {
size520lib/malloc.cfor (i=PAGE_SIZE/bdir->size; i > 0 ; i--) {
size530lib/malloc.c(long)(page+sizeof(struct hdr_start)),hd->size,hd->file,hd->line,hd->ok_file,hd->ok_line);
size532lib/malloc.cpage += bdir->size;
size82mm/kmalloc.cint size;
size106mm/kmalloc.c#define BLOCKSIZE(order)        (sizes[order].size)
size136mm/kmalloc.cint get_order (int size)
size141mm/kmalloc.csize += sizeof (struct block_header); 
size143mm/kmalloc.cif (size <= BLOCKSIZE (order))
size148mm/kmalloc.cvoid * kmalloc (size_t size, int priority)
size156mm/kmalloc.cif (size > MAX_KMALLOC_K * 1024) 
size159mm/kmalloc.csize,MAX_KMALLOC_K*1024);
size163mm/kmalloc.corder = get_order (size);
size166mm/kmalloc.cprintk ("kmalloc of too large a block (%d bytes).\n",size);
size194mm/kmalloc.csizes [order].nbytesmalloced += size;
size196mm/kmalloc.cp->bh_length = size;
size259mm/kmalloc.csize);
size264mm/kmalloc.cvoid kfree_s (void *ptr,int size)
size282mm/kmalloc.cif (size &&
size283mm/kmalloc.csize != p->bh_length)
size286mm/kmalloc.cp,size,p->bh_length);
size289mm/kmalloc.csize = p->bh_length;
size337mm/kmalloc.csizes[order].nbytesmalloced -= size;
size272mm/memory.cint unmap_page_range(unsigned long from, unsigned long size)
size282mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size285mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size286mm/memory.cpcnt = size;
size288mm/memory.cfor ( ; size > 0; ++dir, size -= pcnt,
size289mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size)) {
size324mm/memory.cint zeromap_page_range(unsigned long from, unsigned long size, int mask)
size342mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size344mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size345mm/memory.cpcnt = size;
size347mm/memory.cwhile (size > 0) {
size363mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size376mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size387mm/memory.cint remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask)
size404mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size406mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size407mm/memory.cpcnt = size;
size409mm/memory.cwhile (size > 0) {
size425mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size458mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size652mm/memory.cint verify_area(int type, void * addr, unsigned long size)
size659mm/memory.cif (size > TASK_SIZE - start)
size661mm/memory.cif (wp_works_ok || type == VERIFY_READ || !size)
size663mm/memory.cif (!size)
size665mm/memory.csize--;
size666mm/memory.csize += start & ~PAGE_MASK;
size667mm/memory.csize >>= PAGE_SHIFT;
size672mm/memory.c} while (size--);
size22mm/vmalloc.cunsigned long size;
size96mm/vmalloc.cstatic int do_area(void * addr, unsigned long size,
size101mm/vmalloc.cnr = size >> PAGE_SHIFT;
size131mm/vmalloc.cdo_area(tmp->addr, tmp->size, free_area_pages);
size139mm/vmalloc.cvoid * vmalloc(unsigned long size)
size144mm/vmalloc.csize = PAGE_ALIGN(size);
size145mm/vmalloc.cif (!size || size > high_memory)
size151mm/vmalloc.carea->size = size + PAGE_SIZE;
size154mm/vmalloc.cif (size + (unsigned long) addr <= (unsigned long) tmp->addr)
size156mm/vmalloc.caddr = (void *) (tmp->size + (unsigned long) tmp->addr);
size161mm/vmalloc.cif (do_area(addr, size, alloc_area_pages)) {
size181mm/vmalloc.cn = tmp->size - PAGE_SIZE;
size139net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
size143net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
size241net/inet/icmp.cint size, offset;
size243net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
size244net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size252net/inet/icmp.cskb2->mem_len = size;
size305net/inet/icmp.cint size, offset;
size307net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
size308net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size316net/inet/icmp.cskb2->mem_len = size;
size403net/inet/skbuff.cstruct sk_buff *alloc_skb(unsigned int size,int priority)
size405net/inet/skbuff.cstruct sk_buff *skb=(struct sk_buff *)kmalloc(size,priority);
size410net/inet/skbuff.cskb->truesize=size;
size411net/inet/skbuff.cskb->mem_len=size;
size414net/inet/skbuff.cnet_memory+=size;
size425net/inet/skbuff.cvoid kfree_skbmem(void *mem,unsigned size)
size432net/inet/skbuff.ckfree_s(mem,size);
size434net/inet/skbuff.cnet_memory-=size;
size97net/inet/skbuff.hextern struct sk_buff *    alloc_skb(unsigned int size, int priority);
size98net/inet/skbuff.hextern void      kfree_skbmem(void *mem, unsigned size);
size105net/inet/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
size171net/inet/sock.cint size = 32767; /* a big num. */
size193net/inet/sock.cif (j < size) {
size195net/inet/sock.csize = j;
size1216net/inet/sock.cinet_read(struct socket *sock, char *ubuf, int size, int noblock)
size1233net/inet/sock.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock,0));
size1238net/inet/sock.cinet_recv(struct socket *sock, void *ubuf, int size, int noblock,
size1256net/inet/sock.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, flags));
size1261net/inet/sock.cinet_write(struct socket *sock, char *ubuf, int size, int noblock)
size1283net/inet/sock.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, 0));
size1288net/inet/sock.cinet_send(struct socket *sock, void *ubuf, int size, int noblock, 
size1311net/inet/sock.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
size1316net/inet/sock.cinet_sendto(struct socket *sock, void *ubuf, int size, int noblock, 
size1341net/inet/sock.creturn(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, 
size1347net/inet/sock.cinet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, 
size1368net/inet/sock.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
size1501net/inet/sock.csock_wmalloc(struct sock *sk, unsigned long size, int force,
size1505net/inet/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) {
size1507net/inet/sock.csk->wmem_alloc+= size;
size1509net/inet/sock.creturn(alloc_skb(size, priority));
size1512net/inet/sock.csk, size, force, priority));
size1515net/inet/sock.creturn(alloc_skb(size, priority));
size1520net/inet/sock.csock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
size1523net/inet/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) {
size1524net/inet/sock.cvoid *c = alloc_skb(size, priority);
size1526net/inet/sock.cif (c) sk->rmem_alloc += size;
size1531net/inet/sock.csk,size,force, priority));
size1534net/inet/sock.creturn(alloc_skb(size, priority));
size1566net/inet/sock.csock_wfree(struct sock *sk, void *mem, unsigned long size)
size1568net/inet/sock.cDPRINTF((DBG_INET, "sock_wfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
size1571net/inet/sock.ckfree_skbmem(mem, size);
size1573net/inet/sock.csk->wmem_alloc -= size;
size1587net/inet/sock.csock_rfree(struct sock *sk, void *mem, unsigned long size)
size1589net/inet/sock.cDPRINTF((DBG_INET, "sock_rfree(sk=%X, mem=%X, size=%d)\n", sk, mem, size));
size1591net/inet/sock.ckfree_skbmem(mem, size);
size1593net/inet/sock.csk->rmem_alloc -= size;
size130net/inet/sock.hunsigned long size, int force,
size133net/inet/sock.hunsigned long size, int force,
size136net/inet/sock.hunsigned long size);
size138net/inet/sock.hunsigned long size);
size207net/inet/sock.hunsigned long size, int force,
size210net/inet/sock.hunsigned long size, int force,
size213net/inet/sock.hunsigned long size);
size215net/inet/sock.hunsigned long size);
size223net/inet/udp.cint size, tmp;
size235net/inet/udp.csize = sizeof(struct sk_buff) + sk->prot->max_header + len;
size236net/inet/udp.cskb = (struct sk_buff *) sk->prot->wmalloc(sk, size, 0, GFP_KERNEL);
size240net/inet/udp.cskb->mem_len  = size;
size50net/socket.cint size);
size52net/socket.cint size);
size260net/socket.csock_read(struct inode *inode, struct file *file, char *ubuf, int size)
size264net/socket.cDPRINTF((net_debug, "NET: sock_read: buf=0x%x, size=%d\n", ubuf, size));
size270net/socket.creturn(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));
size275net/socket.csock_write(struct inode *inode, struct file *file, char *ubuf, int size)
size279net/socket.cDPRINTF((net_debug, "NET: sock_write: buf=0x%x, size=%d\n", ubuf, size));
size285net/socket.creturn(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
size69net/unix/sock.cstatic int unix_proto_read(struct socket *sock, char *ubuf, int size,
size71net/unix/sock.cstatic int unix_proto_write(struct socket *sock, char *ubuf, int size,
size575net/unix/sock.cunix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
size581net/unix/sock.cif ((todo = size) <= 0) return(0);
size623net/unix/sock.creturn(size - todo);
size633net/unix/sock.cunix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
size639net/unix/sock.cif ((todo = size) <= 0) return(0);
size700net/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));
size81zBoot/misc.cvoid *malloc(int size)
size85zBoot/misc.cif (size <0) error("Malloc error\n");
size92zBoot/misc.cfree_mem_ptr += size;