taglinefilesource code
size122arch/alpha/boot/tools/build.cunsigned long size, offset;
size128arch/alpha/boot/tools/build.csize = shdr[i].s_size;
size129arch/alpha/boot/tools/build.cstart += size;
size133arch/alpha/boot/tools/build.cwhile (size > 0) {
size134arch/alpha/boot/tools/build.cunsigned long num = size;
size142arch/alpha/boot/tools/build.csize -= num;
size83arch/i386/boot/compressed/gzip.h#  define DECLARE(type, array, size)  type * near array
size84arch/i386/boot/compressed/gzip.h#  define ALLOC(type, array, size) { \
size85arch/i386/boot/compressed/gzip.harray = (type*)fcalloc((unsigned)(((size)+1L)/2), 2*sizeof(type)); \
size91arch/i386/boot/compressed/gzip.h#  define DECLARE(type, array, size)  type array[size]
size92arch/i386/boot/compressed/gzip.h#  define ALLOC(type, array, size)
size238arch/i386/boot/compressed/gzip.hextern int file_read  OF((char *buf,  unsigned size));
size265arch/i386/boot/compressed/gzip.hextern   int (*read_buf) OF((char *buf, unsigned size));
size281arch/i386/boot/compressed/gzip.hextern voidp xmalloc      OF((unsigned int size));
size83arch/i386/boot/compressed/misc.cvoid *malloc(int size)
size87arch/i386/boot/compressed/misc.cif (size <0) error("Malloc error\n");
size94arch/i386/boot/compressed/misc.cfree_mem_ptr += size;
size81arch/i386/ibcs/binfmt_coff.cint clear_memory (unsigned long addr, unsigned long size)
size85arch/i386/ibcs/binfmt_coff.csize = (PAGE_SIZE - (addr & ~PAGE_MASK)) & ~PAGE_MASK;
size86arch/i386/ibcs/binfmt_coff.cif (size == 0)
size91arch/i386/ibcs/binfmt_coff.cprintk ("un-initialized storage in last page %d\n", size);
size95arch/i386/ibcs/binfmt_coff.c(void *) addr, size);
size101arch/i386/ibcs/binfmt_coff.cwhile (size-- != 0)
size18arch/i386/kernel/ldt.cunsigned long size;
size22arch/i386/kernel/ldt.csize = LDT_ENTRIES*LDT_ENTRY_SIZE;
size25arch/i386/kernel/ldt.csize = sizeof(default_ldt);
size27arch/i386/kernel/ldt.cif (size > bytecount)
size28arch/i386/kernel/ldt.csize = bytecount;
size29arch/i386/kernel/ldt.cerror = verify_area(VERIFY_WRITE, ptr, size);
size32arch/i386/kernel/ldt.cmemcpy_tofs(ptr, address, size);
size33arch/i386/kernel/ldt.creturn size;
size236drivers/block/cdu31a.cstatic void size_to_buf(unsigned int size,
size985drivers/block/cdu31a.csize_to_buf(unsigned int size,
size988drivers/block/cdu31a.cbuf[0] = size / 65536;
size989drivers/block/cdu31a.csize = size % 65536;
size990drivers/block/cdu31a.cbuf[1] = size / 256;
size991drivers/block/cdu31a.cbuf[2] = size % 256;
size1598drivers/block/cdu31a.cint  size)
size1600drivers/block/cdu31a.csrc += (size - 1);
size1601drivers/block/cdu31a.cdst += (size - 1);
size1602drivers/block/cdu31a.cwhile (size > 0)
size1605drivers/block/cdu31a.csize--;
size1775drivers/block/floppy.cunsigned char track,head,sect,size;
size1814drivers/block/floppy.chere[count].size = F_SIZECODE;
size1984drivers/block/floppy.cfloppy->size >> 1;
size1994drivers/block/floppy.cfloppy->size >> 1;
size2014drivers/block/floppy.cint size;
size2018drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2023drivers/block/floppy.cwhile ( bh && bh->b_data == base + size ){
size2024drivers/block/floppy.csize += bh->b_size;
size2028drivers/block/floppy.creturn size >> 9;
size2054drivers/block/floppy.cint size;
size2088drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2092drivers/block/floppy.cif ( size > remaining )
size2093drivers/block/floppy.csize = remaining;
size2095drivers/block/floppy.cif (dma_buffer + size >
size2114drivers/block/floppy.cmemcpy( buffer, dma_buffer, size);
size2116drivers/block/floppy.cmemcpy( dma_buffer, buffer, size);
size2117drivers/block/floppy.cremaining -= size;
size2121drivers/block/floppy.cdma_buffer += size;
size2129drivers/block/floppy.csize = bh->b_size;
size2545drivers/block/floppy.cstatic int fd_copyout(void *param, volatile void *address, int size)
size2549drivers/block/floppy.ci = verify_area(VERIFY_WRITE,param,size);
size2552drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
size2788drivers/block/floppy.cfloppy_type[type].size>>1;
size2809drivers/block/floppy.cfloppy_sizes[drive] = user_params[drive].size >> 1;
size3079drivers/block/floppy.cint size = floppy_blocksizes[MINOR(dev)];
size3080drivers/block/floppy.cif (!size)
size3081drivers/block/floppy.csize = 1024;
size3082drivers/block/floppy.cif (!(bh = getblk(dev,0,size))){
size3232drivers/block/floppy.cfloppy_sizes[i] = floppy_type[TYPE(i)].size >> 1;
size31drivers/block/genhd.cstatic void add_partition (struct gendisk *hd, int minor, int start, int size)
size34drivers/block/genhd.chd->part[minor].nr_sects   = size;
size740drivers/char/n_tty.cint size;
size894drivers/char/n_tty.csize = b - buf;
size895drivers/char/n_tty.cif (size && nr)
size897drivers/char/n_tty.cif (!size && clear_bit(TTY_PUSH, &tty->flags))
size899drivers/char/n_tty.cif (!size && !retval)
size901drivers/char/n_tty.creturn (size ? size : retval);
size778drivers/char/tpqic02.cstatic int send_qic02_data(char sb[], unsigned size, int ignore_ex)
size782drivers/char/tpqic02.cfor (i=0; i<size; i++) {
size844drivers/char/tpqic02.cstatic int rdstatus(char *stp, unsigned size, char qcmd)
size878drivers/char/tpqic02.cfor (q=stp; q<stp+size; q++)
size2806drivers/char/tpqic02.cstatic inline unsigned long const align_buffer(unsigned long a, unsigned size)
size2808drivers/char/tpqic02.cif (a & (size-1))      /* if not aligned */
size2809drivers/char/tpqic02.creturn (a | (size-1)) + 1;
size170drivers/net/3c505.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size81drivers/net/3c505dta.hword size,
size391drivers/net/3c507.cint size;
size394drivers/net/3c507.csize = 64*1024;
size398drivers/net/3c507.csize = ((mem_config & 3) + 1) << 14;
size402drivers/net/3c507.cdev->mem_end = base + size;
size46drivers/net/apricot.c#define check_region(addr, size)  0
size47drivers/net/apricot.c#define request_region(addr, size,name)  do ; while(0)
size51drivers/net/apricot.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size52drivers/net/apricot.c#define kfree_skbmem(buff, size) kfree_s(buff,size)
size101drivers/net/apricot.cunsigned short size;
size110drivers/net/apricot.cunsigned short size;
size120drivers/net/apricot.cunsigned short size;
size218drivers/net/apricot.crfd->size = 1532;
size649drivers/net/apricot.ctx_cmd->size = 0;
size651drivers/net/apricot.ctx_cmd->tbd->size = EOF | length;
size145drivers/net/arcnet.c#define check_region(ioaddr, size)     0
size146drivers/net/arcnet.c#define  snarf_region(ioaddr, size);    do ; while (0)
size110drivers/net/atp.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size111drivers/net/atp.c#define kfree_skbmem(addr, size) kfree_s(addr,size);
size115drivers/net/atp.c#define check_region(ioaddr, size)    0
size116drivers/net/atp.c#define request_region(ioaddr, size,name)  do ; while (0)
size590drivers/net/de600.cint    size;
size595drivers/net/de600.csize = de600_read_byte(RX_LEN, dev);  /* low byte */
size596drivers/net/de600.csize += (de600_read_byte(RX_LEN, dev) << 8);  /* high byte */
size597drivers/net/de600.csize -= 4;  /* Ignore trailing 4 CRC-bytes */
size605drivers/net/de600.cif ((size < 32)  ||  (size > 1535)) {
size606drivers/net/de600.cprintk("%s: Bogus packet size %d.\n", dev->name, size);
size607drivers/net/de600.cif (size > 10000)
size612drivers/net/de600.cskb = alloc_skb(size, GFP_ATOMIC);
size616drivers/net/de600.cdev->name, size);
size627drivers/net/de600.cfor (i = size; i > 0; --i, ++buffer)
size632drivers/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));
size183drivers/net/ni52.c#define check_region(ioaddr, size)     0
size184drivers/net/ni52.c#define  request_region(ioaddr, size,name)  do ; while (0)
size202drivers/net/ni52.cstatic int     check586(struct device *dev,char *where,unsigned size);
size278drivers/net/ni52.cstatic int check586(struct device *dev,char *where,unsigned size)
size284drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
size285drivers/net/ni52.cp->memtop = where + size;
size380drivers/net/ni52.cint i,size;
size402drivers/net/ni52.csize = 0x4000;
size403drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size404drivers/net/ni52.csize = 0x2000;
size405drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size420drivers/net/ni52.csize = 0x2000;
size421drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 8K-check */
size423drivers/net/ni52.csize = 0x4000;
size424drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 16K-check */
size429drivers/net/ni52.c((struct priv *) (dev->priv))->base =  dev->mem_start + size - 0x01000000;
size432drivers/net/ni52.cprintk("Memaddr: 0x%lx, Memsize: %d, ",dev->mem_start,size);
size692drivers/net/ni52.crbd[i].size = RECV_BUFF_SIZE;
size696drivers/net/ni52.crbd[NUM_RECV_BUFFS-1].size |= RBD_LAST; /* set eol */
size822drivers/net/ni52.cprintk("S:%04x/%x/%02x >",(int) rbd1->status,(int) rbd1->size>>12,(int)((unsigned long) rbd1 & 0xff));
size828drivers/net/ni52.cprintk("%04x/%x-",(int) rbd1->status>>12,(int) rbd1->size>>12);
size882drivers/net/ni52.crbd->size |= RBD_LAST;
size883drivers/net/ni52.cp->rbd_last->size &= ~RBD_LAST;
size891drivers/net/ni52.crbd->size |= RBD_LAST;
size892drivers/net/ni52.cp->rbd_last->size &= ~RBD_LAST;
size1041drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1054drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1067drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
size144drivers/net/ni52.hunsigned short size;    /* size of this buffer */
size275drivers/net/ni52.hunsigned short size;    /* size + EOF-Flag(15) */
size56drivers/net/ni65.c#define check_region(ioaddr, size)              0
size57drivers/net/ni65.c#define request_region(ioaddr, size,name)       do ; while (0)
size331drivers/net/sk_g16.c#define check_region(ioaddr, size)              0
size332drivers/net/sk_g16.c#define request_region(ioaddr, size,name)       do ; while (0)
size690drivers/scsi/53c7,8xx.cint script_len = 0, size = 0;
size728drivers/scsi/53c7,8xx.csize = sizeof(struct NCR53c7x0_hostdata) + script_len;
size730drivers/scsi/53c7,8xx.cinstance = scsi_register (tpnt, size);
size733drivers/scsi/53c7,8xx.chostdata->size = size;
size1394drivers/scsi/53c7,8xx.cscsi_free ((void *) cmd->real, cmd->size);
size1396drivers/scsi/53c7,8xx.ckfree_s (cmd->real, cmd->size);
size2262drivers/scsi/53c7,8xx.cint size;      /* Size of *tmp */
size2355drivers/scsi/53c7,8xx.csize = ((sizeof (struct NCR53c7x0_cmd) + (hostdata->dsa_end - 
size2359drivers/scsi/53c7,8xx.csize = sizeof (struct NCR53c7x0_cmd) + (hostdata->dsa_end - 
size2366drivers/scsi/53c7,8xx.cif (size > 512) {
size2367drivers/scsi/53c7,8xx.cprintk("scsi%d : size = %d\n", host->host_no, size);
size2372drivers/scsi/53c7,8xx.creal = in_scan_scsis ? NULL : scsi_malloc (size);
size2374drivers/scsi/53c7,8xx.creal = kmalloc (size, GFP_ATOMIC);
size2378drivers/scsi/53c7,8xx.cif (!scan_scsis_buf_busy && size <= sizeof(scan_scsis_buf)) {
size2383drivers/scsi/53c7,8xx.chost->host_no, size);
size2402drivers/scsi/53c7,8xx.ctmp->size = size;      
size3058drivers/scsi/53c7,8xx.cscsi_free ((void *) cmd->real, cmd->size);
size3060drivers/scsi/53c7,8xx.ckfree_s ((void *) cmd->real, cmd->size);
size3615drivers/scsi/53c7,8xx.cint size;
size3623drivers/scsi/53c7,8xx.csize = 3;
size3626drivers/scsi/53c7,8xx.csize = 2;
size3637drivers/scsi/53c7,8xx.creturn size;
size3681drivers/scsi/53c7,8xx.cscsi_free ((void *) curr->real, curr->size);
size3683drivers/scsi/53c7,8xx.ckfree_s ((void *) curr->real, curr->size);
size3720drivers/scsi/53c7,8xx.cscsi_free ((void *) curr->real, curr->size);
size3722drivers/scsi/53c7,8xx.ckfree_s ((void *) curr->real, curr->size);
size940drivers/scsi/53c7,8xx.hint size;        /* scsi_malloc'd size of this 
size1010drivers/scsi/53c7,8xx.hint size;        /* Size of entire Scsi_Host
size1066drivers/scsi/aha152x.cint size = disk->capacity;
size1070drivers/scsi/aha152x.cprintk("aha152x_biosparam: dev=%x, size=%d, ", dev, size);
size1077drivers/scsi/aha152x.cinfo_array[2]=size>>11;
size1227drivers/scsi/aha1542.cint size = disk->capacity;
size1231drivers/scsi/aha1542.cif((size>>11) > 1024 && translation_algorithm == 2) {
size1235drivers/scsi/aha1542.cip[2] = size /255/63;
size1239drivers/scsi/aha1542.cip[2] = size >> 11;
size504drivers/scsi/aha1740.cint size = disk->capacity;
size508drivers/scsi/aha1740.cip[2] = size >> 11;
size69drivers/scsi/aic7770.cvoid *Malloc(size_t size)
size71drivers/scsi/aic7770.cvoid *p = malloc(size);
size77drivers/scsi/aic7770.cvoid *Realloc(void *ptr, size_t size)
size79drivers/scsi/aic7770.cvoid *p = realloc(ptr, size);
size1529drivers/scsi/buslogic.cunsigned int size = disk->capacity;
size1533drivers/scsi/buslogic.c&& size >= 0x200000) {    /* 1GB */
size1534drivers/scsi/buslogic.cif (size >= 0x400000) {    /* 2GB */
size1555drivers/scsi/buslogic.cip[2] = size / (ip[0] * ip[1]);
size638drivers/scsi/eata_dma.culong size = 0;
size688drivers/scsi/eata_dma.csize = sizeof(hostdata) + ((sizeof(struct eata_ccb) * ntohs(gc->queuesiz))/
size709drivers/scsi/eata_dma.csh = scsi_register(tpnt, size);
size765drivers/scsi/fdomain.cunsigned long blocks, size, capacity;
size769drivers/scsi/fdomain.csize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
size770drivers/scsi/fdomain.ccapacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
size773drivers/scsi/fdomain.c((capacity + 5L) / 10L), size );
size1549drivers/scsi/fdomain.cint        size      = disk->capacity;
size1671drivers/scsi/fdomain.cif ((unsigned int)size >= 0x7e0000U) {
size1674drivers/scsi/fdomain.c} else if ((unsigned int)size >= 0x200000U) {
size1683drivers/scsi/fdomain.cinfo_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
size295drivers/scsi/hosts.hextern void * scsi_init_malloc(unsigned int size, int priority);
size296drivers/scsi/hosts.hextern void scsi_init_free(char * ptr, unsigned int size);
size414drivers/scsi/in2000.cint timeout, size, loop;
size446drivers/scsi/in2000.csize = SCpnt->cmd_len;  /* CDB length */ 
size506drivers/scsi/in2000.cfor ( loop=0; loop < size; loop++ )
size682drivers/scsi/in2000.cint size = disk->capacity;
size686drivers/scsi/in2000.ciinfo[2] = size >> 11;
size448drivers/scsi/pas16.cint size = disk->capacity;
size451drivers/scsi/pas16.cip[2] = size >> 11;    /* I think I have it as /(32*64) */
size455drivers/scsi/pas16.cip[2]=size/(63*255);
size1945drivers/scsi/scsi.cvoid * scsi_init_malloc(unsigned int size, int priority)
size1949drivers/scsi/scsi.cretval = (unsigned long) kmalloc(size, priority);
size1952drivers/scsi/scsi.cscsi_init_memory_start += size;
size1958drivers/scsi/scsi.cvoid scsi_init_free(char * ptr, unsigned int size)
size1964drivers/scsi/scsi.cif(((unsigned long) ptr) + size == scsi_init_memory_start)
size552drivers/scsi/scsi_debug.cint size = disk->capacity;
size555drivers/scsi/scsi_debug.cinfo[2] = (size + 2047) >> 11;
size42drivers/scsi/scsicam.cint size = disk->capacity;
size50drivers/scsi/scsicam.cret_code = partsize (bh, (unsigned long) size, (unsigned int *) ip + 2, 
size58drivers/scsi/scsicam.cret_code = setsize ((unsigned long) size, (unsigned int *) ip + 2, 
size62drivers/scsi/sg.cstatic void sg_free(char *buff,int size);
size136drivers/scsi/sg.cstatic char *sg_malloc(int size)
size138drivers/scsi/sg.cif (size<=4096)
size139drivers/scsi/sg.creturn (char *) scsi_malloc(size);
size141drivers/scsi/sg.cif (size<SG_BIG_BUFF)
size156drivers/scsi/sg.cstatic void sg_free(char *buff,int size) 
size166drivers/scsi/sg.cscsi_free(buff,size);
size231drivers/scsi/sg.cint bsize,size,amt,i;
size292drivers/scsi/sg.csize=COMMAND_SIZE(opcode);
size293drivers/scsi/sg.cif (opcode >= 0xc0 && device->header.twelve_byte) size = 12;
size294drivers/scsi/sg.cSCpnt->cmd_len = size;
size298drivers/scsi/sg.cif (count<(sizeof(struct sg_header) + size))
size307drivers/scsi/sg.cmemcpy_fromfs(cmnd,buf,size);
size308drivers/scsi/sg.cbuf+=size;
size309drivers/scsi/sg.cmemcpy_fromfs(device->buff,buf,device->header.pack_len-size-sizeof(struct sg_header));
size315drivers/scsi/sg.c(void *) device->buff,device->header.pack_len-size-sizeof(struct sg_header),
size294drivers/scsi/t128.cint size = disk->capacity;
size297drivers/scsi/t128.cip[2] = size >> 11;
size709drivers/scsi/u14-34f.cint size = disk->capacity;
size713drivers/scsi/u14-34f.cdkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
size1004drivers/scsi/ultrastor.cint size = disk->capacity;
size1009drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
size1209drivers/scsi/wd7000.cint size = disk->capacity;
size1212drivers/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);
size30fs/block_dev.cunsigned int size;
size57fs/block_dev.csize = ((loff_t) blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits;
size59fs/block_dev.csize = INT_MAX;
size61fs/block_dev.cif (block >= size)
size88fs/block_dev.cif (block + blocks > size) blocks = size - block;
size171fs/block_dev.cloff_t size;
size189fs/block_dev.csize = (loff_t) blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
size191fs/block_dev.csize = INT_MAX;
size195fs/block_dev.cif (offset > size)
size198fs/block_dev.cleft = size - offset;
size206fs/block_dev.csize >>= blocksize_bits;
size219fs/block_dev.cif (block + blocks > size)
size220fs/block_dev.cblocks = size - block;
size37fs/buffer.cstatic int grow_buffers(int pri, int size);
size38fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size);
size410fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
size416fs/buffer.cif (tmp->b_size == size)
size433fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
size438fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
size442fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
size448fs/buffer.cvoid set_blocksize(dev_t dev, int size)
size456fs/buffer.cswitch(size) {
size461fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
size462fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size465fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
size468fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size480fs/buffer.cif (bh->b_size == size)
size484fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
size495fs/buffer.cvoid refill_freelist(int size)
size500fs/buffer.cint isize = BUFSIZE_INDEX(size);
size517fs/buffer.cneeded =bdf_prm.b_un.nrefill * size;  
size520fs/buffer.cgrow_buffers(GFP_BUFFER, size)) {
size529fs/buffer.cwhile(maybe_shrink_lav_buffers(size))
size531fs/buffer.cif(!grow_buffers(GFP_BUFFER, size)) break;
size563fs/buffer.cif (bh->b_count || bh->b_size != size)
size603fs/buffer.cif (bh->b_count || bh->b_size != size)
size634fs/buffer.cif (bh->b_count || bh->b_size != size)
size663fs/buffer.cif (grow_buffers(GFP_BUFFER, size)) {
size670fs/buffer.cif (!grow_buffers(GFP_ATOMIC, size))
size686fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
size689fs/buffer.cint isize = BUFSIZE_INDEX(size);
size698fs/buffer.cbh = get_hash_table(dev, block, size);
size706fs/buffer.cwhile(!free_list[isize]) refill_freelist(size);
size708fs/buffer.cif (find_buffer(dev,block,size))
size798fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
size802fs/buffer.cif (!(bh = getblk(dev, block, size))) {
size931fs/buffer.cstatic struct buffer_head * create_buffers(unsigned long page, unsigned long size)
size938fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
size945fs/buffer.cbh->b_size = size;
size998fs/buffer.cdev_t dev, int *b, int size)
size1012fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
size1016fs/buffer.cfirst = get_hash_table(dev, block, size);
size1039fs/buffer.cdev_t dev, int b[], int size)
size1043fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1047fs/buffer.cbh = create_buffers(address, size);
size1052fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1056fs/buffer.cif (find_buffer(dev, block, size))
size1109fs/buffer.cdev_t dev, int *b, int size)
size1117fs/buffer.cbh = get_hash_table(dev, block, size);
size1119fs/buffer.creturn check_aligned(bh, address, dev, b, size);
size1120fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
size1130fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int no_share)
size1137fs/buffer.cwhere = try_to_share_buffers(address, dev, b, size);
size1142fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j+= size) {
size1145fs/buffer.cbh[i] = getblk(dev, b[i], size);
size1149fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size, where += size) {
size1152fs/buffer.cmemcpy((void *) where, bh[i]->b_data, size);
size1163fs/buffer.cstatic int grow_buffers(int pri, int size)
size1170fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
size1171fs/buffer.cprintk("VFS: grow_buffers: size = %d\n",size);
size1175fs/buffer.cisize = BUFSIZE_INDEX(size);
size1179fs/buffer.cbh = create_buffers(page, size);
size1269fs/buffer.cstatic int maybe_shrink_lav_buffers(int size)
size1292fs/buffer.cisize = (size ? BUFSIZE_INDEX(size) : -1);
size1327fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size)
size1334fs/buffer.cif(size) printk("Shrinking buffers of size %d\n", size);
size1338fs/buffer.cisize1 = (size ? BUFSIZE_INDEX(size) : -1);
size1367fs/buffer.cif(size && bh->b_size != size) continue;
size1486fs/buffer.cunsigned int starting_block, int size)
size1489fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1496fs/buffer.cwhile(nr_free[isize] < 32) refill_freelist(size);
size1512fs/buffer.cstatic unsigned long try_to_generate_cluster(dev_t dev, int block, int size)
size1515fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1523fs/buffer.cbh = create_buffers(page, size);
size1529fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1530fs/buffer.cif (find_buffer(dev, nblock++, size))
size1569fs/buffer.cunsigned long generate_cluster(dev_t dev, int b[], int size)
size1573fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
size1575fs/buffer.cif(find_buffer(dev, b[i], size)) return 0;
size1582fs/buffer.cif(maybe_shrink_lav_buffers(size))
size1585fs/buffer.cretval = try_to_generate_cluster(dev, b[0], size);
size1590fs/buffer.creturn try_to_generate_cluster(dev, b[0], size);
size1592fs/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;
size90fs/ext2/file.cunsigned int size;
size104fs/ext2/file.csize = inode->i_size;
size105fs/ext2/file.cif (offset > size)
size108fs/ext2/file.cleft = size - offset;
size116fs/ext2/file.csize = (size + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
size122fs/ext2/file.cif (block + blocks > size)
size123fs/ext2/file.cblocks = size - block;
size453fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
size634fs/isofs/inode.cdirectory_size = isonum_733 (de->size);
size734fs/isofs/inode.cvoid * leak_check_malloc(unsigned int size){
size737fs/isofs/inode.ctmp = kmalloc(size, GFP_KERNEL);
size741fs/isofs/inode.cvoid leak_check_free_s(void * obj, int size){
size743fs/isofs/inode.creturn kfree_s(obj, size);
size746fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
size748fs/isofs/inode.creturn bread(dev, block, size);
size44fs/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;
size212fs/msdos/file.cint size,offset;
size232fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,left_in_file);
size234fs/msdos/file.csize = MIN(size,end-buf);
size235fs/msdos/file.cmemcpy_tofs(buf,data,size);
size236fs/msdos/file.cbuf += size;
size237fs/msdos/file.cfilp->f_pos += size;
size239fs/msdos/file.cfor (; size && buf < end; size--) {
size270fs/msdos/file.cint sector,offset,size,left,written;
size292fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
size300fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
size303fs/msdos/file.c&& (size == SECTOR_SIZE
size304fs/msdos/file.c|| filp->f_pos + size >= inode->i_size)){
size317fs/msdos/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
size318fs/msdos/file.cbuf += size;
size328fs/msdos/file.cfor (size = 0; size < count && left; size++) {
size424fs/msdos/inode.cinode->i_size = CF_LE_L(raw_entry->size);
size456fs/msdos/inode.craw_entry->size = 0;
size460fs/msdos/inode.craw_entry->size = CT_LE_L(inode->i_size);
size200fs/msdos/namei.cde->size = 0;
size233fs/nfs/dir.cif (fattr->size == -1 || fattr->uid == -1 || fattr->gid == -1
size350fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size386fs/nfs/dir.csattr.size = rdev; /* get out your barf bag */
size388fs/nfs/dir.csattr.size = (unsigned) -1;
size415fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size485fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size581fs/nfs/dir.cinode->i_size = fattr->size;
size235fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? attr->ia_size : -1;
size237fs/nfs/inode.csattr.size = (unsigned) -1;
size77fs/nfs/proc.cstatic inline int *nfs_rpc_alloc(int size)
size81fs/nfs/proc.cwhile (!(i = (int *)kmalloc(size+NFS_SLACK_SPACE,GFP_NFS))) {
size173fs/nfs/proc.cfattr->size = ntohl(*p++);
size193fs/nfs/proc.c*p++ = htonl(sattr->size);
size732fs/nfs/proc.cint size;
size736fs/nfs/proc.csize = server->rsize;
size743fs/nfs/proc.c*p++ = htonl(size);
size51fs/nfs/sock.cstatic int do_nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
size208fs/nfs/sock.csize + 1024, 1, 0, NULL,
size229fs/nfs/sock.cint nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
size236fs/nfs/sock.cresult = do_nfs_rpc_call(server, start, end, 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;
size351fs/proc/array.cint size = 0, result = 0;
size363fs/proc/array.cresult = size;
size364fs/proc/array.cif (size < PAGE_SIZE)
size365fs/proc/array.cbuffer[size++] = c;
size509fs/proc/array.cint size=0, resident=0, share=0, trs=0, lrs=0, drs=0, dt=0;
size525fs/proc/array.c++size;
size549fs/proc/array.csize, resident, share, trs, lrs, drs, dt);
size36fs/read_write.cint size = count;
size38fs/read_write.csize = sizeof(*dirent);
size39fs/read_write.cerror = verify_area(VERIFY_WRITE, dirent, size);
size82fs/sysv/file.cunsigned int size;
size93fs/sysv/file.csize = inode->i_size;
size94fs/sysv/file.cif (offset > size)
size97fs/sysv/file.cleft = size - offset;
size105fs/sysv/file.csize = (size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
size110fs/sysv/file.cif (block + blocks > size)
size111fs/sysv/file.cblocks = size - block;
size218fs/umsdos/emd.cint size;  /* Current size of buffer */
size233fs/umsdos/emd.cint mustmove = buf->size - buf->pos;
size246fs/umsdos/emd.cif (ret == 0) buf->size = mustmove + mustread;    
size248fs/umsdos/emd.cbuf->size = mustmove;
size301fs/umsdos/emd.cbuf.size = 0;
size310fs/umsdos/emd.cint file_pos = buf.filp.f_pos - buf.size + buf.pos;
size311fs/umsdos/emd.cif (buf.pos == buf.size){
size341fs/umsdos/emd.cif (buf.pos+entry_size > buf.size){
size122fs/umsdos/mangle.cint size = len + (dirent.name-(char*)&dirent);
size123fs/umsdos/mangle.cint nbrec = size / UMSDOS_REC_SIZE;
size124fs/umsdos/mangle.cint extra = size % UMSDOS_REC_SIZE;
size117include/asm-alpha/bitops.hextern inline unsigned long find_next_zero_bit(void * addr, unsigned long size, unsigned long offset)
size123include/asm-alpha/bitops.hif (offset >= size)
size124include/asm-alpha/bitops.hreturn size;
size125include/asm-alpha/bitops.hsize -= result;
size130include/asm-alpha/bitops.hif (size < 64)
size134include/asm-alpha/bitops.hsize -= 64;
size137include/asm-alpha/bitops.hwhile (size & ~63UL) {
size141include/asm-alpha/bitops.hsize -= 64;
size143include/asm-alpha/bitops.hif (!size)
size147include/asm-alpha/bitops.htmp |= ~0UL << size;
size155include/asm-alpha/bitops.h#define find_first_zero_bit(addr, size) \
size156include/asm-alpha/bitops.hfind_next_zero_bit((addr), (size), 0)
size87include/asm-alpha/hwrpb.hunsigned long size;    /* size of hwrpb */
size69include/asm-i386/bitops.hextern inline int find_first_zero_bit(void * addr, unsigned size)
size73include/asm-i386/bitops.hif (!size)
size90include/asm-i386/bitops.h:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size95include/asm-i386/bitops.hextern inline int find_next_zero_bit (void * addr, int size, int offset)
size119include/asm-i386/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
size536include/asm-i386/string.hextern inline void * memscan(void * addr, int c, size_t size)
size538include/asm-i386/string.hif (!size)
size545include/asm-i386/string.h: "=D" (addr), "=c" (size)
size546include/asm-i386/string.h: "0" (addr), "1" (size), "a" (c));
size243include/asm-i386/system.h#define set_ldt_desc(n,addr,size) \
size244include/asm-i386/system.h_set_tssldt_desc(((char *) (n)),((int)(addr)),((size << 3) - 1),"0x82")
size60include/asm-m68k/bitops.hextern inline int find_first_zero_bit(void * vaddr, unsigned size)
size66include/asm-m68k/bitops.hif (!size)
size81include/asm-m68k/bitops.h: "0" ((size + 31) >> 5), "1" (addr)
size86include/asm-m68k/bitops.hstatic inline int find_next_zero_bit (void *vaddr, int size,
size104include/asm-m68k/bitops.hres = find_first_zero_bit (p, size - 32 * (p - addr));
size65include/asm-mips/bitops.hextern __inline__ int find_first_zero_bit (void *addr, unsigned size)
size69include/asm-mips/bitops.hif (!size)
size91include/asm-mips/bitops.h"d" (size),
size121include/asm-mips/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
size152include/asm-mips/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
size199include/asm-mips/string.hextern __inline__ void * memscan(void * addr, int c, size_t size)
size201include/asm-mips/string.hif (!size)
size213include/asm-mips/string.h: "=r" (addr), "=r" (size)
size214include/asm-mips/string.h: "0" (addr), "1" (size), "r" (c)
size126include/asm-sparc/bitops.hextern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
size132include/asm-sparc/bitops.hif (offset >= size)
size133include/asm-sparc/bitops.hreturn size;
size134include/asm-sparc/bitops.hsize -= result;
size140include/asm-sparc/bitops.hif (size < 32)
size144include/asm-sparc/bitops.hsize -= 32;
size147include/asm-sparc/bitops.hwhile (size & ~32UL) 
size152include/asm-sparc/bitops.hsize -= 32;
size154include/asm-sparc/bitops.hif (!size)
size159include/asm-sparc/bitops.htmp |= ~0UL << size;
size168include/asm-sparc/bitops.h#define find_first_zero_bit(addr, size) \
size169include/asm-sparc/bitops.hfind_next_zero_bit((addr), (size), 0)
size72include/asm-sparc/openprom.hvoid  (*v2_dumb_munmap)(char*  virta, unsigned size);
size60include/linux/fd.hunsigned int  size,    /* nr of sectors total */
size426include/linux/fs.hextern void refill_freelist(int size);
size484include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
size485include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
size491include/linux/fs.hextern void set_blocksize(dev_t dev, int size);
size492include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
size493include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int no_share);
size494include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block, int size, 
size497include/linux/fs.hunsigned long generate_cluster(dev_t dev, int b[], int size);
size110include/linux/iso_fs.hchar size      [ISODCL (11, 18)]; /* 733 */
size199include/linux/iso_fs.hextern void * leak_check_malloc(unsigned int size);
size200include/linux/iso_fs.hextern void leak_check_free_s(void * obj, int size);
size201include/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);
size165include/linux/mm.hextern int unmap_page_range(unsigned long from, unsigned long size);
size166include/linux/mm.hextern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask);
size167include/linux/mm.hextern int zeromap_page_range(unsigned long from, unsigned long size, int mask);
size180include/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 */
size87include/linux/msdos_fs.hunsigned long size;  /* file size (in bytes) */
size103include/linux/net.hint  (*read)    (struct socket *sock, char *ubuf, int size,
size105include/linux/net.hint  (*write)  (struct socket *sock, char *ubuf, int size,
size134include/linux/nfs.hu_int size;
size149include/linux/nfs.hu_int size;
size92include/linux/nfs_fs.hextern int nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size);
size113include/linux/skbuff.hextern struct sk_buff *    alloc_skb(unsigned int size, int priority);
size114include/linux/skbuff.hextern void      kfree_skbmem(struct sk_buff *skb, unsigned size);
size281include/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);
size20ipc/shm.cstatic int newseg (key_t key, int shmflg, int size);
size71ipc/shm.cstatic int newseg (key_t key, int shmflg, int size)
size74ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
size77ipc/shm.cif (size < SHMMIN)
size113ipc/shm.cshp->shm_segsz = size;
size130ipc/shm.cint sys_shmget (key_t key, int size, int shmflg)
size135ipc/shm.cif (size < 0 || size > SHMMAX)
size138ipc/shm.creturn newseg(key, shmflg, size);
size142ipc/shm.creturn newseg(key, shmflg, size);
size149ipc/shm.cif (size > shp->shm_segsz)
size30ipc/util.cextern int sys_shmget (key_t key, int size, int flag);
size121kernel/module.csys_create_module(char *module_name, unsigned long size)
size132kernel/module.cif (module_name == NULL || size == 0)
size145kernel/module.cnpages = (size + sizeof (int) + 4095) / 4096;
size155kernel/module.cmp->size = npages;
size164kernel/module.cmp->name, (unsigned long) mp->size, (unsigned long) mp->addr));
size205kernel/module.cif ((codesize + sizeof (int) + 4095) / 4096 > mp->size)
size209kernel/module.cmp->size * 4096 - (codesize + sizeof (int)));
size218kernel/module.cint size;
size224kernel/module.cmemcpy_fromfs((char *)(&(size)), symtab, sizeof(int));
size226kernel/module.cif ((newtab = (struct symbol_table*) kmalloc(size, GFP_KERNEL)) == NULL) {
size230kernel/module.cif ((error = verify_area(VERIFY_READ, symtab, size))) {
size231kernel/module.ckfree_s(newtab, size);
size234kernel/module.cmemcpy_fromfs((char *)(newtab), symtab, size);
size242kernel/module.c(legal_start > size)) {
size244kernel/module.ckfree_s(newtab, size);
size251kernel/module.cif ((unsigned long)sym->name < legal_start || size <= (unsigned long)sym->name) {
size253kernel/module.ckfree_s(newtab, size);
size473kernel/module.cif (mp->symtab->size)
size474kernel/module.ckfree_s(mp->symtab, mp->symtab->size);
size496kernel/module.cchar size[32];
size509kernel/module.csprintf(size, "%d", mp->size);
size510kernel/module.ci -= strlen(size);
size515kernel/module.cq = size;
size214lib/string.cvoid * memscan(void * addr, unsigned char c, size_t size)
size218lib/string.cwhile (size) {
size222lib/string.csize--;
size68lib/vsprintf.cstatic char * number(char * str, long num, int base, int size, int precision
size87lib/vsprintf.csize--;
size90lib/vsprintf.csize--;
size93lib/vsprintf.csize--;
size98lib/vsprintf.csize -= 2;
size100lib/vsprintf.csize--;
size109lib/vsprintf.csize -= precision;
size111lib/vsprintf.cwhile(size-->0)
size123lib/vsprintf.cwhile (size-- > 0)
size129lib/vsprintf.cwhile (size-- > 0)
size86mm/filemap.csize_t size, unsigned int flags)
size92mm/filemap.csize = size >> PAGE_SHIFT;
size96mm/filemap.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size97mm/filemap.cpcnt = size;
size99mm/filemap.cfor ( ; size > 0; ++dir, size -= pcnt,
size100mm/filemap.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size)) {
size88mm/kmalloc.cint size;
size122mm/kmalloc.c#define BLOCKSIZE(order)        (sizes[order].size)
size152mm/kmalloc.cint get_order (int size)
size157mm/kmalloc.csize += sizeof (struct block_header); 
size159mm/kmalloc.cif (size <= BLOCKSIZE (order))
size164mm/kmalloc.cvoid * kmalloc (size_t size, int priority)
size185mm/kmalloc.corder = get_order (size);
size188mm/kmalloc.cprintk ("kmalloc of too large a block (%d bytes).\n",(int) size);
size216mm/kmalloc.csizes [order].nbytesmalloced += size;
size218mm/kmalloc.cp->bh_length = size;
size291mm/kmalloc.c(int) size);
size295mm/kmalloc.cvoid kfree_s (void *ptr,int size)
size313mm/kmalloc.cif (size &&
size314mm/kmalloc.csize != p->bh_length)
size317mm/kmalloc.cp,size,p->bh_length);
size320mm/kmalloc.csize = p->bh_length;
size382mm/kmalloc.csizes[order].nbytesmalloced -= size;
size266mm/memory.cint unmap_page_range(unsigned long from, unsigned long size)
size276mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size279mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size280mm/memory.cpcnt = size;
size282mm/memory.cfor ( ; size > 0; ++dir, size -= pcnt,
size283mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size)) {
size318mm/memory.cint zeromap_page_range(unsigned long from, unsigned long size, int mask)
size336mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size338mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size339mm/memory.cpcnt = size;
size341mm/memory.cwhile (size > 0) {
size357mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size370mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size381mm/memory.cint remap_page_range(unsigned long from, unsigned long to, unsigned long size, int mask)
size398mm/memory.csize = (size + ~PAGE_MASK) >> PAGE_SHIFT;
size400mm/memory.cif ((pcnt = PTRS_PER_PAGE - poff) > size)
size401mm/memory.cpcnt = size;
size403mm/memory.cwhile (size > 0) {
size419mm/memory.cfor (size -= pcnt; pcnt-- ;) {
size452mm/memory.cpcnt = (size > PTRS_PER_PAGE ? PTRS_PER_PAGE : size);
size606mm/memory.cint verify_area(int type, const void * addr, unsigned long size)
size640mm/memory.cif (vma->vm_end - start >= size)
size649mm/memory.csize--;
size650mm/memory.csize += start & ~PAGE_MASK;
size651mm/memory.csize >>= PAGE_SHIFT;
size658mm/memory.cif (!size)
size660mm/memory.csize--;
size631mm/swap.cdo { unsigned long size = PAGE_SIZE << high; \
size633mm/swap.chigh--; size >>= 1; cli(); \
size637mm/swap.caddr = (struct mem_list *) (size + (unsigned long) addr); \
size21mm/vmalloc.cunsigned long size;
size105mm/vmalloc.cstatic int do_area(void * addr, unsigned long size,
size110mm/vmalloc.cnr = size >> PAGE_SHIFT;
size140mm/vmalloc.cdo_area(tmp->addr, tmp->size, free_area_pages);
size148mm/vmalloc.cvoid * vmalloc(unsigned long size)
size153mm/vmalloc.csize = PAGE_ALIGN(size);
size154mm/vmalloc.cif (!size || size > high_memory)
size160mm/vmalloc.carea->size = size + PAGE_SIZE;
size163mm/vmalloc.cif (size + (unsigned long) addr < (unsigned long) tmp->addr)
size165mm/vmalloc.caddr = (void *) (tmp->size + (unsigned long) tmp->addr);
size170mm/vmalloc.cif (do_area(addr, size, alloc_area_pages)) {
size190mm/vmalloc.cn = tmp->size - PAGE_SIZE;
size107net/inet/af_inet.cint size = 32767; /* a big num. */
size132net/inet/af_inet.cif (j < size) 
size135net/inet/af_inet.csize = j;
size1105net/inet/af_inet.cstatic int inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, 
size1117net/inet/af_inet.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
size1122net/inet/af_inet.cstatic int inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
size1126net/inet/af_inet.creturn inet_recvfrom(sock,ubuf,size,noblock,flags,NULL,NULL);
size1129net/inet/af_inet.cstatic int inet_read(struct socket *sock, char *ubuf, int size, int noblock)
size1138net/inet/af_inet.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
size1141net/inet/af_inet.cstatic int inet_send(struct socket *sock, void *ubuf, int size, int noblock, 
size1155net/inet/af_inet.creturn(sk->prot->write(sk, (unsigned char *) ubuf, size, noblock, flags));
size1158net/inet/af_inet.cstatic int inet_write(struct socket *sock, char *ubuf, int size, int noblock)
size1160net/inet/af_inet.creturn inet_send(sock,ubuf,size,noblock,0);
size1163net/inet/af_inet.cstatic int inet_sendto(struct socket *sock, void *ubuf, int size, int noblock, 
size1179net/inet/af_inet.creturn(sk->prot->sendto(sk, (unsigned char *) ubuf, size, noblock, flags, 
size935net/inet/arp.cint size;
size941net/inet/arp.csize = sprintf(buffer,"IP address       HW type     Flags       HW address            Mask\n");
size943net/inet/arp.cpos+=size;
size944net/inet/arp.clen+=size;
size972net/inet/arp.csize = sprintf(buffer+len,
size978net/inet/arp.csize += sprintf(buffer+len+size,
size983net/inet/arp.clen+=size;
size163net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
size167net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
size889net/inet/dev.cint size;
size892net/inet/dev.csize = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
size904net/inet/dev.csize = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
size906net/inet/dev.creturn size;
size919net/inet/dev.cint size;
size924net/inet/dev.csize = sprintf(buffer, "Inter-|   Receive                  |  Transmit\n"
size927net/inet/dev.cpos+=size;
size928net/inet/dev.clen+=size;
size933net/inet/dev.csize = sprintf_stats(buffer+len, dev);
size934net/inet/dev.clen+=size;
size390net/inet/icmp.cint size, offset;
size395net/inet/icmp.csize = dev->hard_header_len + 64 + len;
size396net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size456net/inet/icmp.cint size, offset;
size473net/inet/icmp.csize = dev->hard_header_len + 84;
size475net/inet/icmp.cif (! (skb2 = alloc_skb(size, GFP_ATOMIC))) 
size558net/inet/icmp.cint size, offset;
size564net/inet/icmp.csize = dev->hard_header_len + 64 + len;
size565net/inet/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size1033net/inet/ipx.cint size;
size1091net/inet/ipx.csize=sizeof(ipx_packet)+len;  /* For mac headers */
size1109net/inet/ipx.csize += dev->hard_header_len;
size1110net/inet/ipx.csize += dl->header_length;
size1113net/inet/ipx.cprintk("IPX: sendto: allocating buffer (%d)\n",size);
size1115net/inet/ipx.cif(size+sk->wmem_alloc>sk->sndbuf) {
size1119net/inet/ipx.cskb=alloc_skb(size,GFP_KERNEL);
size1127net/inet/ipx.cskb->len=size;
size1200net/inet/ipx.cstatic int ipx_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
size1202net/inet/ipx.creturn ipx_sendto(sock,ubuf,size,noblock,flags,NULL,0);
size1205net/inet/ipx.cstatic int ipx_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
size1247net/inet/ipx.cstatic int ipx_write(struct socket *sock, char *ubuf, int size, int noblock)
size1249net/inet/ipx.creturn ipx_send(sock,ubuf,size,noblock,0);
size1253net/inet/ipx.cstatic int ipx_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1259net/inet/ipx.creturn ipx_recvfrom(sock,ubuf,size,noblock,flags,NULL, NULL);
size1262net/inet/ipx.cstatic int ipx_read(struct socket *sock, char *ubuf, int size, int noblock)
size1264net/inet/ipx.creturn ipx_recv(sock,ubuf,size,noblock,0);
size431net/inet/rarp.cint size;
size437net/inet/rarp.csize = sprintf(buffer,"RARP disabled until entries added to cache.\n");
size438net/inet/rarp.cpos+=size;
size439net/inet/rarp.clen+=size;
size443net/inet/rarp.csize = sprintf(buffer,
size445net/inet/rarp.cpos+=size;
size446net/inet/rarp.clen+=size;
size458net/inet/rarp.csize = sprintf(buffer+len,
size469net/inet/rarp.clen+=size;
size500net/inet/route.cint size;
size512net/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",
size516net/inet/route.clen+=size;
size517net/inet/route.cpos+=size;
size390net/inet/skbuff.cstruct sk_buff *alloc_skb(unsigned int size,int priority)
size404net/inet/skbuff.csize+=sizeof(struct sk_buff);
size405net/inet/skbuff.cskb=(struct sk_buff *)kmalloc(size,priority);
size421net/inet/skbuff.cskb->truesize = size;
size422net/inet/skbuff.cskb->mem_len = size;
size436net/inet/skbuff.cnet_memory += size;
size450net/inet/skbuff.cvoid kfree_skbmem(struct sk_buff *skb,unsigned size)
size462net/inet/skbuff.cif(size!=skb->truesize)
size471net/inet/skbuff.ckfree_s((void *)skb,size);
size473net/inet/skbuff.cnet_memory -= size;
size481net/inet/skbuff.ckfree_s((void *)skb,size);
size483net/inet/skbuff.cnet_memory -= size;
size314net/inet/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
size318net/inet/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) 
size320net/inet/sock.cstruct sk_buff * c = alloc_skb(size, priority);
size333net/inet/sock.creturn(alloc_skb(size, priority));
size337net/inet/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
size341net/inet/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) 
size343net/inet/sock.cstruct sk_buff *c = alloc_skb(size, priority);
size356net/inet/sock.creturn(alloc_skb(size, priority));
size391net/inet/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
size396net/inet/sock.ckfree_skbmem(skb, size);
size402net/inet/sock.csk->wmem_alloc -= size;
size412net/inet/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
size417net/inet/sock.ckfree_skbmem(skb, size);
size423net/inet/sock.csk->rmem_alloc -= size;
size432net/inet/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode)
size457net/inet/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
size193net/inet/sock.hunsigned long size, int force,
size196net/inet/sock.hunsigned long size, int force,
size199net/inet/sock.hunsigned long size);
size201net/inet/sock.hunsigned long size);
size281net/inet/sock.hunsigned long size, int force,
size284net/inet/sock.hunsigned long size, int force,
size287net/inet/sock.hunsigned long size);
size289net/inet/sock.hunsigned long size);
size296net/inet/sock.hextern struct sk_buff     *sock_alloc_send_skb(struct sock *skb, unsigned long size, int noblock, int *errcode);
size382net/inet/tcp.cint size;
size400net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
size418net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size1042net/inet/tcp.cint size;
size1046net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
size1049net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
size1058net/inet/tcp.cif (size == sizeof(struct tcphdr)) 
size1071net/inet/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
size1095net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size2872net/inet/tcp.cint size;
size2883net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
size2888net/inet/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size259net/inet/udp.cint size, tmp;
size266net/inet/udp.csize = sk->prot->max_header + len;
size267net/inet/udp.cskb = sock_alloc_send_skb(sk, size, 0, &tmp);
size67net/socket.cint size);
size69net/socket.cint size);
size314net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *ubuf, int size)
size327net/socket.cif(size<0)
size329net/socket.cif(size==0)
size331net/socket.cif ((err=verify_area(VERIFY_WRITE,ubuf,size))<0)
size333net/socket.creturn(sock->ops->read(sock, ubuf, size, (file->f_flags & O_NONBLOCK)));
size341net/socket.cstatic int sock_write(struct inode *inode, struct file *file, char *ubuf, int size)
size355net/socket.cif(size<0)
size357net/socket.cif(size==0)
size360net/socket.cif ((err=verify_area(VERIFY_READ,ubuf,size))<0)
size362net/socket.creturn(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
size72net/unix/sock.cstatic int unix_proto_read(struct socket *sock, char *ubuf, int size,
size74net/unix/sock.cstatic int unix_proto_write(struct socket *sock, char *ubuf, int size,
size609net/unix/sock.cstatic int unix_proto_read(struct socket *sock, char *ubuf, int size, int nonblock)
size614net/unix/sock.cif ((todo = size) <= 0) 
size669net/unix/sock.creturn(size - todo);
size679net/unix/sock.cstatic int unix_proto_write(struct socket *sock, char *ubuf, int size, int nonblock)
size684net/unix/sock.cif ((todo = size) <= 0)
size765net/unix/sock.creturn(size - todo);