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;
size96arch/alpha/kernel/bios32.cunsigned int base, mask, size, reg;
size125arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
size126arch/alpha/kernel/bios32.cbase = ALIGN(io_base, size);
size127arch/alpha/kernel/bios32.cio_base = base + size;
size140arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
size186arch/alpha/kernel/bios32.cbase = ALIGN(mem_base, size);
size187arch/alpha/kernel/bios32.cif (size > 7 * 16*MB) {
size193arch/alpha/kernel/bios32.cPCI_FUNC(dev->devfn), size);
size198arch/alpha/kernel/bios32.cbase  = ALIGN(base, size);
size200arch/alpha/kernel/bios32.cif (base / 128*MB != (base + size) / 128*MB) {
size203arch/alpha/kernel/bios32.cbase  = ALIGN(base, size);
size206arch/alpha/kernel/bios32.cmem_base = base + size;
size168arch/alpha/kernel/traps.clong dir, size;
size194arch/alpha/kernel/traps.csize = 4;
size197arch/alpha/kernel/traps.csize = 8;
size199arch/alpha/kernel/traps.cif (verify_area(dir, va, size)) {
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));
size84arch/i386/boot/compressed/misc.cvoid *malloc(int size)
size88arch/i386/boot/compressed/misc.cif (size <0) error("Malloc error\n");
size95arch/i386/boot/compressed/misc.cfree_mem_ptr += size;
size19arch/i386/kernel/ldt.cunsigned long size;
size23arch/i386/kernel/ldt.csize = LDT_ENTRIES*LDT_ENTRY_SIZE;
size26arch/i386/kernel/ldt.csize = sizeof(default_ldt);
size28arch/i386/kernel/ldt.cif (size > bytecount)
size29arch/i386/kernel/ldt.csize = bytecount;
size30arch/i386/kernel/ldt.cerror = verify_area(VERIFY_WRITE, ptr, size);
size33arch/i386/kernel/ldt.cmemcpy_tofs(ptr, address, size);
size34arch/i386/kernel/ldt.creturn size;
size17arch/mips/kernel/tynedma.cunsigned long deskstation_tyne_dma_alloc(size_t size)
size20arch/mips/kernel/tynedma.callocated += size;
size577arch/sparc/mm/srmmu.csrmmu_init_alloc(unsigned long *kbrk, unsigned size)
size579arch/sparc/mm/srmmu.cregister unsigned mask = size - 1;
size582arch/sparc/mm/srmmu.cif(size==0) return 0x0;
size583arch/sparc/mm/srmmu.cif(size & mask) {
size588arch/sparc/mm/srmmu.c*kbrk = ret + size;
size589arch/sparc/mm/srmmu.cmemset((void*) ret, 0, size);
size180arch/sparc/prom/tree.cprom_setprop(int node, char *pname, char *value, int size)
size182arch/sparc/prom/tree.cif(size == 0) return 0;
size184arch/sparc/prom/tree.creturn prom_nodeops->no_setprop(node, pname, value, size);
size240drivers/block/cdu31a.cstatic void size_to_buf(unsigned int size,
size1053drivers/block/cdu31a.csize_to_buf(unsigned int size,
size1056drivers/block/cdu31a.cbuf[0] = size / 65536;
size1057drivers/block/cdu31a.csize = size % 65536;
size1058drivers/block/cdu31a.cbuf[1] = size / 256;
size1059drivers/block/cdu31a.cbuf[2] = size % 256;
size1699drivers/block/cdu31a.cint  size)
size1701drivers/block/cdu31a.csrc += (size - 1);
size1702drivers/block/cdu31a.cdst += (size - 1);
size1703drivers/block/cdu31a.cwhile (size > 0)
size1706drivers/block/cdu31a.csize--;
size1149drivers/block/cm206.c#define OK  mem_start+size
size1161drivers/block/cm206.clong int size=sizeof(struct cm206_struct);
size1178drivers/block/cm206.ccd = (struct cm206_struct *) kmalloc(size, GFP_KERNEL);
size1232drivers/block/cm206.c" %ld bytes kernel memory used.\n", cd->max_sectors*2, size);
size167drivers/block/floppy.cstatic inline int __get_order (int size)
size174drivers/block/floppy.c: "r" (size / PAGE_SIZE) );  
size177drivers/block/floppy.cif (size <= (PAGE_SIZE << order))
size183drivers/block/floppy.cstatic unsigned long dma_mem_alloc(int size)
size185drivers/block/floppy.cint order = __get_order(size);
size2003drivers/block/floppy.cunsigned char track,head,sect,size;
size2042drivers/block/floppy.chere[count].size = F_SIZECODE;
size2212drivers/block/floppy.cfloppy->size >> 1;
size2222drivers/block/floppy.cfloppy->size >> 1;
size2242drivers/block/floppy.cint size;
size2246drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2251drivers/block/floppy.cwhile ( bh && bh->b_data == base + size ){
size2252drivers/block/floppy.csize += bh->b_size;
size2256drivers/block/floppy.creturn size >> 9;
size2282drivers/block/floppy.cint size;
size2316drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2320drivers/block/floppy.cif ( size > remaining )
size2321drivers/block/floppy.csize = remaining;
size2323drivers/block/floppy.cif (dma_buffer + size >
size2342drivers/block/floppy.cmemcpy( buffer, dma_buffer, size);
size2344drivers/block/floppy.cmemcpy( dma_buffer, buffer, size);
size2345drivers/block/floppy.cremaining -= size;
size2349drivers/block/floppy.cdma_buffer += size;
size2357drivers/block/floppy.csize = bh->b_size;
size2790drivers/block/floppy.cstatic int fd_copyout(void *param, volatile void *address, int size)
size2794drivers/block/floppy.ci = verify_area(VERIFY_WRITE,param,size);
size2797drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
size3035drivers/block/floppy.cfloppy_type[type].size>>1;
size3056drivers/block/floppy.cfloppy_sizes[drive] = user_params[drive].size >> 1;
size3363drivers/block/floppy.cint size = floppy_blocksizes[MINOR(dev)];
size3364drivers/block/floppy.cif (!size)
size3365drivers/block/floppy.csize = 1024;
size3366drivers/block/floppy.cif (!(bh = getblk(dev,0,size))){
size3586drivers/block/floppy.cfloppy_sizes[i] = floppy_type[TYPE(i)].size >> 1;
size62drivers/block/genhd.cstatic void add_partition (struct gendisk *hd, int minor, int start, int size)
size65drivers/block/genhd.chd->part[minor].nr_sects   = size;
size746drivers/block/gscd.cstatic void cmd_read_b ( char *pb, int count, int size )
size775drivers/block/gscd.cfor ( i=0 ; i< size ; i++ )
size823drivers/block/gscd.cstatic void cmd_read_w ( char *pb, int count, int size )
size847drivers/block/gscd.cfor ( i=0 ; i<size ; i++ )
size246drivers/block/mcdx.csize_t size, unsigned int timeout, int);
size855drivers/block/mcdx.cvoid *buffer, size_t size, 
size864drivers/block/mcdx.cif (!buffer || size == 0) buffer = &c, size = 1;
size881drivers/block/mcdx.ctries, timeout, size, (unsigned char) cmd[0]));
size891drivers/block/mcdx.csize_t sz = size;
size1042drivers/block/mcdx.cint size;
size1044drivers/block/mcdx.csize = sizeof(*stuffp);
size1049drivers/block/mcdx.cTRACE((MALLOC, "init() malloc %d bytes\n", size));
size1050drivers/block/mcdx.cif (!(stuffp = kmalloc(size, GFP_KERNEL))) {
size1057drivers/block/mcdx.cmem_start += size;
size1085drivers/block/mcdx.cfree(stuffp, size);
size1102drivers/block/mcdx.cfree(stuffp, size);
size1130drivers/block/mcdx.cfree(stuffp, size);
size1139drivers/block/mcdx.cfree(stuffp, size);
size1157drivers/block/mcdx.cfree(stuffp, size);
size1403drivers/block/mcdx.cint size;
size1404drivers/block/mcdx.csize = sizeof(struct s_subqcode) * (stuffp->di.n_last - stuffp->di.n_first + 2);
size1406drivers/block/mcdx.cTRACE((MALLOC, "ioctl() malloc %d bytes\n", size));
size1407drivers/block/mcdx.cstuffp->toc = kmalloc(size, GFP_KERNEL);
size1409drivers/block/mcdx.cWARN(("Cannot malloc %s bytes for toc\n", size));
size798drivers/block/sonycd535.csize_to_buf(unsigned int size, Byte *buf)
size800drivers/block/sonycd535.cbuf[0] = size / 65536;
size801drivers/block/sonycd535.csize = size % 65536;
size802drivers/block/sonycd535.cbuf[1] = size / 256;
size803drivers/block/sonycd535.cbuf[2] = size % 256;
size145drivers/block/triton.cunsigned long size, addr, *table = HWIF(drive)->dmatable;
size158drivers/block/triton.csize = rq->nr_sectors << 9;
size162drivers/block/triton.csize = bh->b_size;
size164drivers/block/triton.cif ((addr + size) != virt_to_bus (bh->b_data))
size166drivers/block/triton.csize += bh->b_size;
size174drivers/block/triton.cwhile (size) {
size180drivers/block/triton.cif (bcount > size)
size181drivers/block/triton.cbcount = size;
size185drivers/block/triton.csize -= bcount;
size542drivers/char/lp.cint base,size;
size555drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
size556drivers/char/lp.cif (check_region(base, size))
size566drivers/char/lp.crequest_region(base, size, "lp");
size584drivers/char/lp.cint base,size;
size597drivers/char/lp.cint base, size;
size599drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
size601drivers/char/lp.crelease_region(LP_B(offset),size);
size750drivers/char/n_tty.cint size;
size904drivers/char/n_tty.csize = b - buf;
size905drivers/char/n_tty.cif (size && nr)
size907drivers/char/n_tty.cif (!size && clear_bit(TTY_PUSH, &tty->flags))
size909drivers/char/n_tty.cif (!size && !retval)
size911drivers/char/n_tty.creturn (size ? size : retval);
size305drivers/char/scc.csccfreelist[i]->bp->size = BUFSIZE;
size355drivers/char/scc.csccfreelist[i]->bp->size = BUFSIZE;
size813drivers/char/scc.cif ((bp = scc->rbp1) == NULLBUF || bp->cnt >= bp->size)  
size1478drivers/char/scc.cif(scc->sndq2->cnt == scc->sndq2->size)    /* buffer full? */
size779drivers/char/tpqic02.cstatic int send_qic02_data(char sb[], unsigned size, int ignore_ex)
size783drivers/char/tpqic02.cfor (i=0; i<size; i++) {
size845drivers/char/tpqic02.cstatic int rdstatus(char *stp, unsigned size, char qcmd)
size879drivers/char/tpqic02.cfor (q=stp; q<stp+size; q++)
size2799drivers/char/tpqic02.cstatic inline unsigned long const align_buffer(unsigned long a, unsigned size)
size2801drivers/char/tpqic02.cif (a & (size-1))      /* if not aligned */
size2802drivers/char/tpqic02.creturn (a | (size-1)) + 1;
size33drivers/char/vc_screen.cint size = video_num_lines * video_num_columns;
size35drivers/char/vc_screen.csize = 2*size + HEADER_SIZE;
size36drivers/char/vc_screen.creturn size;
size42drivers/char/vc_screen.cint size = vcs_size(inode);
size52drivers/char/vc_screen.cfile->f_pos = size + offset;
size57drivers/char/vc_screen.cif (file->f_pos < 0 || file->f_pos > size)
size67drivers/char/vc_screen.cint viewed, attr, size, read;
size83drivers/char/vc_screen.csize = vcs_size(inode);
size84drivers/char/vc_screen.cif (count < 0 || p > size)
size86drivers/char/vc_screen.cif (count > size - p)
size87drivers/char/vc_screen.ccount = size - p;
size125drivers/char/vc_screen.cint viewed, attr, size, written;
size141drivers/char/vc_screen.csize = vcs_size(inode);
size142drivers/char/vc_screen.cif (count < 0 || p > size)
size144drivers/char/vc_screen.cif (count > size - p)
size145drivers/char/vc_screen.ccount = size - p;
size207drivers/net/3c505.hword size,
size394drivers/net/3c507.cint size;
size397drivers/net/3c507.csize = 64*1024;
size401drivers/net/3c507.csize = ((mem_config & 3) + 1) << 14;
size405drivers/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;
size242drivers/net/arcnet.c#define check_region(ioaddr, size)     0
size243drivers/net/arcnet.c#define  request_region(ioaddr, size)    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 = dev_alloc_skb(size+2);
size616drivers/net/de600.cdev->name, size);
size625drivers/net/de600.cbuffer = skb_put(skb,size);
size629drivers/net/de600.cfor (i = size; i > 0; --i, ++buffer)
size627drivers/net/de620.cint size;
size676drivers/net/de620.csize = header_buf.Rx_ByteCount - 4;
size677drivers/net/de620.cif ((size < RUNT) || (GIANT < size)) {
size678drivers/net/de620.cprintk("%s: Illegal packet size: %d!\n", dev->name, size);
size681drivers/net/de620.cskb = dev_alloc_skb(size+2);
size684drivers/net/de620.cdev->name, size);
size692drivers/net/de620.cbuffer = skb_put(skb,size);
size694drivers/net/de620.cde620_read_block(dev, buffer, size);
size695drivers/net/de620.cPRINTK(("Read %d bytes\n", size));
size156drivers/net/ni52.c#define check_region(ioaddr, size)              0
size157drivers/net/ni52.c#define request_region(ioaddr, size,name)    do ; while (0)
size170drivers/net/ni52.cstatic int     check586(struct device *dev,char *where,unsigned size);
size245drivers/net/ni52.cstatic int check586(struct device *dev,char *where,unsigned size)
size251drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
size252drivers/net/ni52.cp->memtop = where + size;
size348drivers/net/ni52.cint i,size;
size370drivers/net/ni52.csize = 0x4000; /* check for 16K mem */
size371drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size372drivers/net/ni52.csize = 0x2000; /* check for 8K mem */
size373drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size388drivers/net/ni52.csize = 0x2000; /* check for 8K mem */
size389drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 8K-check */
size391drivers/net/ni52.csize = 0x4000; /* check for 16K mem */
size392drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 16K-check */
size396drivers/net/ni52.cdev->mem_end = dev->mem_start + size; /* set mem_end showed by 'ifconfig' */
size398drivers/net/ni52.c((struct priv *) (dev->priv))->base =  dev->mem_start + size - 0x01000000;
size402drivers/net/ni52.cif(size == 0x2000)
size407drivers/net/ni52.cprintk("Memaddr: 0x%lx, Memsize: %d, ",dev->mem_start,size);
size707drivers/net/ni52.crbd[i].size = RECV_BUFF_SIZE;
size992drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1013drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1025drivers/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)
size2127drivers/net/wavelan.cint    size;
size2134drivers/net/wavelan.csize = sprintf(buffer, "%s", "Iface |  dce    +nwid    -nwid  lvl slnc qual ntxq nrst\n");
size2136drivers/net/wavelan.cpos += size;
size2137drivers/net/wavelan.clen += size;
size2148drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
size2150drivers/net/wavelan.clen += size;
size467drivers/pci/pci.cstatic int sprint_dev_config(struct pci_dev *dev, char *buf, int size)
size487drivers/pci/pci.cif (len + 80 > size) {
size493drivers/pci/pci.cif (len + 80 > size) {
size512drivers/pci/pci.cif (len + strlen(str) > size) {
size519drivers/pci/pci.cif (len + strlen(fast_b2b_capable) > size) {
size528drivers/pci/pci.cif (len + strlen(BIST_capable) > size) {
size536drivers/pci/pci.cif (len + 40 > size) {
size543drivers/pci/pci.cif (len + 80 > size) {
size558drivers/pci/pci.cif (len + 40 > size) {
size610drivers/pci/pci.cint nprinted, len, size;
size615drivers/pci/pci.csize  = PAGE_SIZE - (strlen(MSG) + 1);
size619drivers/pci/pci.cnprinted = sprint_dev_config(dev, buf + len, size - len);
size633drivers/pci/pci.cstatic void *pci_malloc(long size, unsigned long *mem_startp)
size638drivers/pci/pci.cprintk("...pci_malloc(size=%ld,mem=%p)", size, *mem_startp);
size641drivers/pci/pci.c*mem_startp += (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
size642drivers/pci/pci.cmemset(mem, 0, size);
size682drivers/scsi/53c7,8xx.cint script_len = 0, dsa_len = 0, size = 0, max_cmd_size = 0;
size754drivers/scsi/53c7,8xx.csize = sizeof(struct NCR53c7x0_hostdata) + script_len + max_cmd_size;
size756drivers/scsi/53c7,8xx.cinstance = scsi_register (tpnt, size);
size767drivers/scsi/53c7,8xx.chostdata->size = size;
size827drivers/scsi/53c7,8xx.chostdata->free->size = max_cmd_size;
size2365drivers/scsi/53c7,8xx.cint size;      /* Size of *tmp */
size2389drivers/scsi/53c7,8xx.csize = (hostdata->max_cmd_size + 511) / 512 * 512;
size2390drivers/scsi/53c7,8xx.ctmp = (struct NCR53c7x0_cmd *) scsi_malloc (size);
size2397drivers/scsi/53c7,8xx.csize = hostdata->max_cmd_size + sizeof(void*);
size2398drivers/scsi/53c7,8xx.creal = kmalloc (size, GFP_ATOMIC);
size2405drivers/scsi/53c7,8xx.ctmp->size = size;      
size3720drivers/scsi/53c7,8xx.cint size;
size3728drivers/scsi/53c7,8xx.csize = 3;
size3731drivers/scsi/53c7,8xx.csize = 2;
size3742drivers/scsi/53c7,8xx.creturn size;
size971drivers/scsi/53c7,8xx.hint size;        /* scsi_malloc'd size of this 
size1048drivers/scsi/53c7,8xx.hint size;        /* Size of entire Scsi_Host
size1113drivers/scsi/aha152x.cint size = disk->capacity;
size1117drivers/scsi/aha152x.cprintk("aha152x_biosparam: dev=%x, size=%d, ", dev, size);
size1124drivers/scsi/aha152x.cinfo_array[2]=size>>11;
size1231drivers/scsi/aha1542.cint size = disk->capacity;
size1235drivers/scsi/aha1542.cif((size>>11) > 1024 && translation_algorithm == 2) {
size1239drivers/scsi/aha1542.cip[2] = size /255/63;
size1243drivers/scsi/aha1542.cip[2] = size >> 11;
size502drivers/scsi/aha1740.cint size = disk->capacity;
size506drivers/scsi/aha1740.cip[2] = size >> 11;
size65drivers/scsi/aic7xxx_asm.cMalloc(size_t size)
size67drivers/scsi/aic7xxx_asm.cvoid *p = malloc(size);
size74drivers/scsi/aic7xxx_asm.cRealloc(void *ptr, size_t size)
size76drivers/scsi/aic7xxx_asm.cvoid *p = realloc(ptr, size);
size1503drivers/scsi/buslogic.cunsigned int size = disk->capacity;
size1507drivers/scsi/buslogic.c&& size >= 0x200000) {    /* 1GB */
size1508drivers/scsi/buslogic.cif (size >= 0x400000) {    /* 2GB */
size1529drivers/scsi/buslogic.cip[2] = size / (ip[0] * ip[1]);
size822drivers/scsi/eata_dma.culong size = 0;
size920drivers/scsi/eata_dma.csize = sizeof(hostdata) + ((sizeof(struct eata_ccb) + sizeof(long)) 
size923drivers/scsi/eata_dma.cDBG(DBG_REGISTER, printk("scsi_register size: %ld\n", size));
size925drivers/scsi/eata_dma.csh = scsi_register(tpnt, size);
size90drivers/scsi/eata_dma_proc.cint    size, len = 0;
size119drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) driver version: "
size121drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
size122drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
size124drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
size126drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
size128drivers/scsi/eata_dma_proc.clen += size; 
size130drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
size132drivers/scsi/eata_dma_proc.clen += size;
size134drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Hardware Configuration:\n");
size135drivers/scsi/eata_dma_proc.clen += size; 
size140drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
size142drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
size143drivers/scsi/eata_dma_proc.clen += size; 
size146drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
size147drivers/scsi/eata_dma_proc.clen += size; 
size149drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: EISA\n"); 
size150drivers/scsi/eata_dma_proc.clen += size; 
size205drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "IRQ: %2d, %s triggered\n", cc->interrupt,
size207drivers/scsi/eata_dma_proc.clen += size; 
size210drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
size212drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
size213drivers/scsi/eata_dma_proc.clen += size; 
size215drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "CPU: MC680%02d %dMHz\n", bt->cpu_type,
size217drivers/scsi/eata_dma_proc.clen += size; 
size219drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
size220drivers/scsi/eata_dma_proc.clen += size; 
size222drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
size226drivers/scsi/eata_dma_proc.clen += size; 
size228drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI Bus:%s%s Speed: %sMB/sec. %s\n",
size233drivers/scsi/eata_dma_proc.clen += size; 
size235drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI channel expansion Module: %s present\n",
size238drivers/scsi/eata_dma_proc.clen += size; 
size240drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartRAID hardware: %spresent.\n",
size242drivers/scsi/eata_dma_proc.clen += size; 
size244drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
size250drivers/scsi/eata_dma_proc.clen += size; 
size253drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max array groups:              %d\n",
size255drivers/scsi/eata_dma_proc.clen += size; 
size257drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 0 array:   %d\n",
size259drivers/scsi/eata_dma_proc.clen += size; 
size261drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 3/5 array: %d\n",
size263drivers/scsi/eata_dma_proc.clen += size; 
size265drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Cache Module: %spresent.\n",
size267drivers/scsi/eata_dma_proc.clen += size; 
size269drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
size275drivers/scsi/eata_dma_proc.clen += size; 
size278drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Bank%d: %dMB with%s ECC\n",x,
size281drivers/scsi/eata_dma_proc.clen += size; 
size284drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Timer Mod.: %spresent\n",
size286drivers/scsi/eata_dma_proc.clen += size; 
size288drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "NVRAM     : %spresent\n",
size290drivers/scsi/eata_dma_proc.clen += size; 
size292drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartROM  : %sabled\n",
size294drivers/scsi/eata_dma_proc.clen += size; 
size296drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Alarm     : %s\n",
size298drivers/scsi/eata_dma_proc.clen += size; 
size354drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host<->Disk command statistics:\n"
size356drivers/scsi/eata_dma_proc.clen += size; 
size359drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u\n", 1 << x,
size362drivers/scsi/eata_dma_proc.clen += size; 
size365drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u\n",
size368drivers/scsi/eata_dma_proc.clen += size; 
size370drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Sum   : %12u %12u\n",
size373drivers/scsi/eata_dma_proc.clen += size; 
size385drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Latency Command Statistics:\n"
size388drivers/scsi/eata_dma_proc.clen += size; 
size391drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
size400drivers/scsi/eata_dma_proc.clen += size; 
size403drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
size411drivers/scsi/eata_dma_proc.clen += size; 
size421drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len,
size423drivers/scsi/eata_dma_proc.clen += size; 
size426drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
size435drivers/scsi/eata_dma_proc.clen += size; 
size438drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
size446drivers/scsi/eata_dma_proc.clen += size; 
size459drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
size460drivers/scsi/eata_dma_proc.clen += size; 
size465drivers/scsi/eata_dma_proc.cproc_print_scsidevice(scd, buffer, &size, len);
size466drivers/scsi/eata_dma_proc.clen += size; 
size672drivers/scsi/eata_pio.culong size = 0;
size723drivers/scsi/eata_pio.csize = sizeof(hostdata) + (sizeof(struct eata_ccb) * ntohs(gc->queuesiz));
size725drivers/scsi/eata_pio.csh = scsi_register(tpnt, size);
size48drivers/scsi/eata_pio_proc.cint   size, len = 0;
size65drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) PIO driver version: "
size67drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
size68drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
size70drivers/scsi/eata_pio_proc.clen += size; pos = begin + len;
size72drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
size74drivers/scsi/eata_pio_proc.clen += size; 
size76drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
size78drivers/scsi/eata_pio_proc.clen += size;
size80drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "IO: PIO\n");
size81drivers/scsi/eata_pio_proc.clen += size; 
size83drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
size84drivers/scsi/eata_pio_proc.clen += size; 
size86drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
size90drivers/scsi/eata_pio_proc.clen += size; 
size102drivers/scsi/eata_pio_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
size103drivers/scsi/eata_pio_proc.clen += size; 
size108drivers/scsi/eata_pio_proc.cproc_print_scsidevice(scd, buffer, &size, len);
size109drivers/scsi/eata_pio_proc.clen += size; 
size972drivers/scsi/fdomain.cunsigned long blocks, size, capacity;
size976drivers/scsi/fdomain.csize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
size977drivers/scsi/fdomain.ccapacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
size980drivers/scsi/fdomain.c((capacity + 5L) / 10L), size );
size1756drivers/scsi/fdomain.cint        size      = disk->capacity;
size1889drivers/scsi/fdomain.cif ((unsigned int)size >= 0x7e0000U) {
size1892drivers/scsi/fdomain.c} else if ((unsigned int)size >= 0x200000U) {
size1901drivers/scsi/fdomain.cinfo_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
size319drivers/scsi/hosts.hextern void * scsi_init_malloc(unsigned int size, int priority);
size320drivers/scsi/hosts.hextern void scsi_init_free(char * ptr, unsigned int size);
size420drivers/scsi/in2000.cint timeout, size, loop;
size452drivers/scsi/in2000.csize = SCpnt->cmd_len;  /* CDB length */ 
size513drivers/scsi/in2000.cfor ( loop=0; loop < size; loop++ )
size689drivers/scsi/in2000.cint size = disk->capacity;
size693drivers/scsi/in2000.ciinfo[2] = size >> 11;
size453drivers/scsi/pas16.cint size = disk->capacity;
size456drivers/scsi/pas16.cip[2] = size >> 11;    /* I think I have it as /(32*64) */
size460drivers/scsi/pas16.cip[2]=size/(63*255);
size2164drivers/scsi/scsi.cvoid * scsi_init_malloc(unsigned int size, int priority)
size2179drivers/scsi/scsi.cif(size == PAGE_SIZE)
size2182drivers/scsi/scsi.cretval = (unsigned long) kmalloc(size, priority);
size2189drivers/scsi/scsi.csize = (size + 15) & ~15;
size2192drivers/scsi/scsi.c(scsi_init_memory_start + size) > scsi_memory_upper_value) {
size2198drivers/scsi/scsi.cscsi_init_memory_start += size;
size2202drivers/scsi/scsi.cmemset((void *) retval, 0, size);
size2207drivers/scsi/scsi.cvoid scsi_init_free(char * ptr, unsigned int size)
size2218drivers/scsi/scsi.cif(size == PAGE_SIZE)
size2224drivers/scsi/scsi.csize = (size + 15) & ~15;
size2226drivers/scsi/scsi.cif(((unsigned long) ptr) + size == scsi_init_memory_start)
size2439drivers/scsi/scsi.cint    size, len = 0;
size2447drivers/scsi/scsi.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
size2448drivers/scsi/scsi.clen += size; 
size2452drivers/scsi/scsi.csize += sprintf(buffer+len,"scsi%2d: %s\n", (int) HBA_ptr->host_no, HBA_ptr->hostt->procname);
size2453drivers/scsi/scsi.clen += size; 
size2459drivers/scsi/scsi.cproc_print_scsidevice(scd, buffer, &size, len);
size2460drivers/scsi/scsi.clen += size; 
size579drivers/scsi/scsi_debug.cint size = disk->capacity;
size582drivers/scsi/scsi_debug.cinfo[2] = (size + 2047) >> 11;
size348drivers/scsi/scsi_proc.cvoid proc_print_scsidevice(Scsi_Device *scd, char *buffer, int *size, int len)
size350drivers/scsi/scsi_proc.cint x, y = *size;
size387drivers/scsi/scsi_proc.c*size = y; 
size56drivers/scsi/scsicam.cint size = disk->capacity;
size64drivers/scsi/scsicam.cret_code = partsize (bh, (unsigned long) size, (unsigned int *) ip + 2, 
size72drivers/scsi/scsicam.cret_code = setsize ((unsigned long) size, (unsigned int *) ip + 2, 
size68drivers/scsi/sg.cstatic void sg_free(char *buff,int size);
size165drivers/scsi/sg.cstatic char *sg_malloc(int size)
size167drivers/scsi/sg.cif (size<=4096)
size168drivers/scsi/sg.creturn (char *) scsi_malloc(size);
size170drivers/scsi/sg.cif (size<=SG_BIG_BUFF)
size185drivers/scsi/sg.cstatic void sg_free(char *buff,int size) 
size195drivers/scsi/sg.cscsi_free(buff,size);
size294drivers/scsi/sg.cint        bsize,size,amt,i;
size400drivers/scsi/sg.csize=COMMAND_SIZE(opcode);
size401drivers/scsi/sg.cif (opcode >= 0xc0 && device->header.twelve_byte) size = 12;
size402drivers/scsi/sg.cSCpnt->cmd_len = size;
size410drivers/scsi/sg.camt -= size;
size415drivers/scsi/sg.cif( count < (sizeof(struct sg_header) + size) )
size427drivers/scsi/sg.cmemcpy_fromfs(cmnd,buf,size);
size428drivers/scsi/sg.cbuf+=size;
size294drivers/scsi/t128.cint size = disk->capacity;
size297drivers/scsi/t128.cip[2] = size >> 11;
size825drivers/scsi/u14-34f.cint size = disk->capacity;
size829drivers/scsi/u14-34f.cdkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
size1008drivers/scsi/ultrastor.cint size = disk->capacity;
size1013drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
size1215drivers/scsi/wd7000.cint size = disk->capacity;
size1218drivers/scsi/wd7000.cip[2] = size >> 11;
size573drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
size640drivers/sound/dmabuf.c*size = dmap->fragment_size;
size1028drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
size139drivers/sound/os.h#define PERMANENT_MALLOC(typecast, mem_ptr, size, linux_ptr) \
size141drivers/sound/os.hlinux_ptr += (size);}
size229drivers/sound/pss.cpss_download_boot (pss_config * devc, unsigned char *block, int size, int flags)
size264drivers/sound/pss.cif (count >= size && flags & CPF_LAST)
size269drivers/sound/pss.ccount, size);
size7drivers/sound/sound_calls.hint DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock);
size437drivers/sound/sscape.csscape_download_boot (struct sscape_info *devc, unsigned char *block, int size, int flag)
size479drivers/sound/sscape.cmemcpy (audio_devs[devc->my_audiodev]->dmap->raw_buf[0], block, size);
size485drivers/sound/sscape.csize, DMA_MODE_WRITE);
size920fs/binfmt_elf.csize_t size;
size941fs/binfmt_elf.csize = 0;
size948fs/binfmt_elf.cif (size+sz > limit)
size952fs/binfmt_elf.csize += sz;
size955fs/binfmt_elf.cprintk("elf_core_dump: %d segs taking %d bytes\n", segs, size);
size33fs/block_dev.cunsigned int size;
size60fs/block_dev.csize = ((loff_t) blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits;
size62fs/block_dev.csize = INT_MAX;
size64fs/block_dev.cif (block >= size)
size91fs/block_dev.cif (block + blocks > size) blocks = size - block;
size174fs/block_dev.cloff_t size;
size192fs/block_dev.csize = (loff_t) blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
size194fs/block_dev.csize = INT_MAX;
size198fs/block_dev.cif (offset > size)
size201fs/block_dev.celse if (size - offset > INT_MAX)
size204fs/block_dev.cleft = size - offset;
size212fs/block_dev.csize >>= blocksize_bits;
size225fs/block_dev.cif (block + blocks > size)
size226fs/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);
size413fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
size419fs/buffer.cif (tmp->b_size == size)
size436fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
size441fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
size446fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
size452fs/buffer.cvoid set_blocksize(dev_t dev, int size)
size460fs/buffer.cswitch(size) {
size465fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
size466fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size469fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
size472fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size484fs/buffer.cif (bh->b_size == size)
size488fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
size499fs/buffer.cvoid refill_freelist(int size)
size504fs/buffer.cint isize = BUFSIZE_INDEX(size);
size521fs/buffer.cneeded =bdf_prm.b_un.nrefill * size;  
size524fs/buffer.cgrow_buffers(GFP_BUFFER, size)) {
size533fs/buffer.cwhile(maybe_shrink_lav_buffers(size))
size535fs/buffer.cif(!grow_buffers(GFP_BUFFER, size)) break;
size567fs/buffer.cif (bh->b_count || bh->b_size != size)
size607fs/buffer.cif (bh->b_count || bh->b_size != size)
size638fs/buffer.cif (bh->b_count || bh->b_size != size)
size667fs/buffer.cif (grow_buffers(GFP_BUFFER, size)) {
size674fs/buffer.cif (!grow_buffers(GFP_ATOMIC, size))
size690fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
size693fs/buffer.cint isize = BUFSIZE_INDEX(size);
size702fs/buffer.cbh = get_hash_table(dev, block, size);
size710fs/buffer.cwhile(!free_list[isize]) refill_freelist(size);
size712fs/buffer.cif (find_buffer(dev,block,size))
size813fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
size817fs/buffer.cif (!(bh = getblk(dev, block, size))) {
size946fs/buffer.cstatic struct buffer_head * create_buffers(unsigned long page, unsigned long size)
size953fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
size960fs/buffer.cbh->b_size = size;
size1013fs/buffer.cdev_t dev, int *b, int size)
size1027fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
size1031fs/buffer.cfirst = get_hash_table(dev, block, size);
size1054fs/buffer.cdev_t dev, int b[], int size)
size1058fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1062fs/buffer.cbh = create_buffers(address, size);
size1067fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1071fs/buffer.cif (find_buffer(dev, block, size))
size1125fs/buffer.cdev_t dev, int *b, int size)
size1133fs/buffer.cbh = get_hash_table(dev, block, size);
size1135fs/buffer.creturn check_aligned(bh, address, dev, b, size);
size1136fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
size1146fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int no_share)
size1153fs/buffer.cwhere = try_to_share_buffers(address, dev, b, size);
size1158fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j+= size) {
size1161fs/buffer.cbh[i] = getblk(dev, b[i], size);
size1165fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size, where += size) {
size1168fs/buffer.cmemcpy((void *) where, bh[i]->b_data, size);
size1171fs/buffer.cmemset((void *) where, 0, size);
size1181fs/buffer.cvoid bwrite_page(unsigned long address, dev_t dev, int b[], int size)
size1186fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j+= size) {
size1189fs/buffer.cbh[i] = getblk(dev, b[i], size);
size1191fs/buffer.cfor (i=0, j=0; j<PAGE_SIZE ; i++, j += size, address += size) {
size1193fs/buffer.cmemcpy(bh[i]->b_data, (void *) address, size);
size1198fs/buffer.cmemset((void *) address, 0, size); /* ???!?!! */
size1207fs/buffer.cstatic int grow_buffers(int pri, int size)
size1214fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
size1215fs/buffer.cprintk("VFS: grow_buffers: size = %d\n",size);
size1219fs/buffer.cisize = BUFSIZE_INDEX(size);
size1223fs/buffer.cbh = create_buffers(page, size);
size1316fs/buffer.cstatic int maybe_shrink_lav_buffers(int size)
size1339fs/buffer.cisize = (size ? BUFSIZE_INDEX(size) : -1);
size1378fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size)
size1385fs/buffer.cif(size) printk("Shrinking buffers of size %d\n", size);
size1389fs/buffer.cisize1 = (size ? BUFSIZE_INDEX(size) : -1);
size1418fs/buffer.cif(size && bh->b_size != size) continue;
size1542fs/buffer.cunsigned int starting_block, int size)
size1545fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1552fs/buffer.cwhile(nr_free[isize] < 32) refill_freelist(size);
size1568fs/buffer.cstatic unsigned long try_to_generate_cluster(dev_t dev, int block, int size)
size1571fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1579fs/buffer.cbh = create_buffers(page, size);
size1585fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1586fs/buffer.cif (find_buffer(dev, nblock++, size))
size1625fs/buffer.cunsigned long generate_cluster(dev_t dev, int b[], int size)
size1629fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
size1631fs/buffer.cif(find_buffer(dev, b[i], size)) return 0;
size1638fs/buffer.cif(maybe_shrink_lav_buffers(size))
size1641fs/buffer.cretval = try_to_generate_cluster(dev, b[0], size);
size1646fs/buffer.creturn try_to_generate_cluster(dev, b[0], size);
size1648fs/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;
size91fs/ext2/file.cunsigned int size;
size105fs/ext2/file.csize = inode->i_size;
size106fs/ext2/file.cif (offset > size)
size109fs/ext2/file.cleft = size - offset;
size118fs/ext2/file.csize = (size + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
size124fs/ext2/file.cif (block + blocks > size)
size125fs/ext2/file.cblocks = size - block;
size487fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
size675fs/isofs/inode.cdirectory_size = isonum_733 (de->size);
size775fs/isofs/inode.cvoid * leak_check_malloc(unsigned int size){
size778fs/isofs/inode.ctmp = kmalloc(size, GFP_KERNEL);
size782fs/isofs/inode.cvoid leak_check_free_s(void * obj, int size){
size784fs/isofs/inode.creturn kfree_s(obj, size);
size787fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
size789fs/isofs/inode.creturn bread(dev, block, size);
size48fs/isofs/rock.ccont_size = isonum_733(rr->u.CE.size);}
size14fs/isofs/rock.hchar size[8];
size85fs/minix/dir.cint size = strnlen(de->name, info->s_namelen);
size86fs/minix/dir.cif (filldir(dirent, de->name, size, filp->f_pos, de->inode) < 0) {
size78fs/minix/file.cunsigned int size;
size89fs/minix/file.csize = inode->i_size;
size90fs/minix/file.cif (offset > size)
size93fs/minix/file.cleft = size - offset;
size101fs/minix/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
size107fs/minix/file.cif (block + blocks > size)
size108fs/minix/file.cblocks = size - block;
size216fs/msdos/file.cint size,offset;
size236fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,left_in_file);
size238fs/msdos/file.csize = MIN(size,end-buf);
size239fs/msdos/file.cmemcpy_tofs(buf,data,size);
size240fs/msdos/file.cbuf += size;
size241fs/msdos/file.cfilp->f_pos += size;
size243fs/msdos/file.cfor (; size && buf < end; size--) {
size274fs/msdos/file.cint sector,offset,size,left,written;
size297fs/msdos/file.cfor (start = buf; count || carry; count -= size) {
size305fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
size308fs/msdos/file.c&& (size == SECTOR_SIZE
size309fs/msdos/file.c|| filp->f_pos + size >= inode->i_size)){
size322fs/msdos/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
size323fs/msdos/file.cbuf += size;
size333fs/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);
size206fs/msdos/namei.cde->size = 0;
size242fs/nfs/dir.cif (fattr->size == -1 || fattr->uid == -1 || fattr->gid == -1
size359fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size395fs/nfs/dir.csattr.size = rdev; /* get out your barf bag */
size397fs/nfs/dir.csattr.size = (unsigned) -1;
size424fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size494fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size590fs/nfs/dir.cinode->i_size = fattr->size;
size266fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? attr->ia_size : -1;
size268fs/nfs/inode.csattr.size = (unsigned) -1;
size81fs/nfs/proc.cstatic inline int *nfs_rpc_alloc(int size)
size85fs/nfs/proc.cwhile (!(i = (int *)kmalloc(size+NFS_SLACK_SPACE,GFP_NFS))) {
size177fs/nfs/proc.cfattr->size = ntohl(*p++);
size197fs/nfs/proc.c*p++ = htonl(sattr->size);
size736fs/nfs/proc.cint size;
size740fs/nfs/proc.csize = server->rsize;
size747fs/nfs/proc.c*p++ = htonl(size);
size52fs/nfs/sock.cstatic int do_nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
size212fs/nfs/sock.csize + 1024, 1, 0, NULL,
size233fs/nfs/sock.cint nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
size240fs/nfs/sock.cresult = do_nfs_rpc_call(server, start, end, size);
size27fs/pipe.cint chars = 0, size = 0, read = 0;
size48fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
size52fs/pipe.cif (chars > size)
size53fs/pipe.cchars = size;
size321fs/proc/array.cint size = 0, result = 0;
size333fs/proc/array.cresult = size;
size334fs/proc/array.cif (size < PAGE_SIZE)
size335fs/proc/array.cbuffer[size++] = c;
size475fs/proc/array.cstatic inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
size490fs/proc/array.cend = address + size;
size513fs/proc/array.cstatic inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
size528fs/proc/array.cend = address + size;
size551fs/proc/array.cint size=0, resident=0, share=0, trs=0, lrs=0, drs=0, dt=0;
size566fs/proc/array.csize += total;
size579fs/proc/array.csize, resident, share, trs, lrs, drs, dt);
size88fs/proc/inode.cif (de->size)
size89fs/proc/inode.cinode->i_size = de->size;
size782fs/smbfs/dir.centry.size  = 0;
size106fs/smbfs/inode.cinode->i_size    = SMB_INOP(inode)->finfo.size;
size585fs/smbfs/proc.centry->size   = DVAL(buf, smb_vwv4);
size931fs/smbfs/proc.centry->size = DVAL(p, 5);
size1084fs/smbfs/proc.cfinfo->size = DVAL(p,16);
size1099fs/smbfs/proc.cfinfo->size = DVAL(p,16);
size1123fs/smbfs/proc.cfinfo->size = DVAL(p,0);
size1412fs/smbfs/proc.centry->size         = DVAL(buf, smb_vwv3);
size1436fs/smbfs/proc.centry->size  = DVAL(buf, smb_vwv6);
size1464fs/smbfs/proc.centry->size  = temp_entry.size;
size86fs/sysv/file.cunsigned int size;
size97fs/sysv/file.csize = inode->i_size;
size98fs/sysv/file.cif (offset > size)
size101fs/sysv/file.cleft = size - offset;
size109fs/sysv/file.csize = (size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
size114fs/sysv/file.cif (block + blocks > size)
size115fs/sysv/file.cblocks = size - block;
size210fs/umsdos/emd.cint size;  /* Current size of buffer */
size225fs/umsdos/emd.cint mustmove = buf->size - buf->pos;
size238fs/umsdos/emd.cif (ret == 0) buf->size = mustmove + mustread;    
size240fs/umsdos/emd.cbuf->size = mustmove;
size293fs/umsdos/emd.cbuf.size = 0;
size302fs/umsdos/emd.cint file_pos = buf.filp.f_pos - buf.size + buf.pos;
size303fs/umsdos/emd.cif (buf.pos == buf.size){
size333fs/umsdos/emd.cif (buf.pos+entry_size > buf.size){
size126fs/umsdos/mangle.cint size = len + (dirent.name-(char*)&dirent);
size127fs/umsdos/mangle.cint nbrec = size / UMSDOS_REC_SIZE;
size128fs/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)
size122include/asm-alpha/hwrpb.hunsigned long size;    /* size of hwrpb */
size39include/asm-alpha/ioctl.h#define _IOC(dir,type,nr,size) \
size43include/asm-alpha/ioctl.h((size) << _IOC_SIZESHIFT))
size47include/asm-alpha/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size48include/asm-alpha/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size49include/asm-alpha/ioctl.h#define _IOWR(type,nr,size)  _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
size22include/asm-alpha/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size24include/asm-alpha/segment.hswitch (size) {
size43include/asm-alpha/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size45include/asm-alpha/segment.hswitch (size) {
size131include/asm-alpha/system.hstatic inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
size133include/asm-alpha/system.hswitch (size) {
size69include/asm-i386/bitops.hextern __inline__ int find_first_zero_bit(void * addr, unsigned size)
size73include/asm-i386/bitops.hif (!size)
size88include/asm-i386/bitops.h:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size93include/asm-i386/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
size117include/asm-i386/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
size35include/asm-i386/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size37include/asm-i386/segment.hswitch (size) {
size58include/asm-i386/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size62include/asm-i386/segment.hswitch (size) {
size579include/asm-i386/string.hextern inline void * memscan(void * addr, int c, size_t size)
size581include/asm-i386/string.hif (!size)
size588include/asm-i386/string.h: "=D" (addr), "=c" (size)
size589include/asm-i386/string.h: "0" (addr), "1" (size), "a" (c));
size147include/asm-i386/system.hstatic inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
size149include/asm-i386/system.hswitch (size) {
size229include/asm-i386/system.h#define set_ldt_desc(n,addr,size) \
size230include/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));
size149include/asm-mips/bitops.hextern __inline__ int find_first_zero_bit (void *addr, unsigned size)
size153include/asm-mips/bitops.hif (!size)
size175include/asm-mips/bitops.h"r" (size),
size183include/asm-mips/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
size214include/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)
size284include/asm-sparc/bitops.hfind_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
size295include/asm-sparc/bitops.hif (offset >= size)
size296include/asm-sparc/bitops.hreturn size;
size297include/asm-sparc/bitops.hsize -= result;
size303include/asm-sparc/bitops.hif (size < 32)
size307include/asm-sparc/bitops.hsize -= 32;
size310include/asm-sparc/bitops.hwhile (size & ~32UL) 
size315include/asm-sparc/bitops.hsize -= 32;
size317include/asm-sparc/bitops.hif (!size)
size322include/asm-sparc/bitops.htmp |= ~0UL << size;
size332include/asm-sparc/bitops.h#define find_first_zero_bit(addr, size) \
size333include/asm-sparc/bitops.hfind_next_zero_bit((addr), (size), 0)
size76include/asm-sparc/openprom.hvoid  (*v2_dumb_munmap)(char*  virta, unsigned size);
size174include/asm-sparc/oplib.hextern char *prom_alloc(char *virt_hint, unsigned int size);
size177include/asm-sparc/oplib.hextern void prom_free(char *virt_addr, unsigned int size);
size63include/linux/fd.hunsigned int  size,    /* nr of sectors total */
size434include/linux/fs.hextern void refill_freelist(int size);
size493include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
size494include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
size500include/linux/fs.hextern void set_blocksize(dev_t dev, int size);
size501include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
size502include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int no_share);
size503include/linux/fs.hextern void bwrite_page(unsigned long addr,dev_t dev,int b[],int size);
size504include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block, int size, 
size507include/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);
size6include/linux/malloc.hvoid * kmalloc(unsigned int size, int priority);
size179include/linux/mm.hextern int unmap_page_range(unsigned long from, unsigned long size);
size180include/linux/mm.hextern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot);
size181include/linux/mm.hextern int zeromap_page_range(unsigned long from, unsigned long size, pgprot_t prot);
size195include/linux/mm.hextern void * vmalloc(unsigned long size);
size196include/linux/mm.hextern void * vremap(unsigned long offset, unsigned long size);
size53include/linux/module.hint size; /* total, including string table!!! */
size68include/linux/module.hint size;      /* size of module in pages */
size87include/linux/msdos_fs.h__u32  size;    /* file size (in bytes) */
size105include/linux/net.hint  (*read)    (struct socket *sock, char *ubuf, int size,
size107include/linux/net.hint  (*write)  (struct socket *sock, const char *ubuf, int size,
size135include/linux/nfs.hu_int size;
size150include/linux/nfs.hu_int size;
size92include/linux/nfs_fs.hextern int nfs_rpc_call(struct nfs_server *server, int *start, int *end, int size);
size142include/linux/proc_fs.hunsigned long size;
size146include/linux/scc.hint size;    /* Size of associated data buffer */
size62include/linux/shm.hasmlinkage int sys_shmget (key_t key, int size, int flag);
size126include/linux/skbuff.hextern struct sk_buff *    alloc_skb(unsigned int size, int priority);
size127include/linux/skbuff.hextern struct sk_buff *    dev_alloc_skb(unsigned int size);
size365include/linux/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
size366include/linux/skbuff.hextern void      skb_copy_datagram_iovec(struct sk_buff *from, int offset, struct iovec *to,int size);
size97include/linux/smb.hunsigned long   size;  /* File size. */
size65include/linux/smb_fs.hsmb_kmalloc(unsigned int size, int priority)
size69include/linux/smb_fs.hreturn kmalloc(size, priority);
size73include/linux/smb_fs.hsmb_kfree_s(void *obj, int size)
size76include/linux/smb_fs.hkfree_s(obj, size);
size240include/net/sock.hunsigned long size, int force,
size243include/net/sock.hunsigned long size, int force,
size334include/net/sock.hunsigned long size, int force,
size337include/net/sock.hunsigned long size, int force,
size354include/net/sock.hunsigned long size,
size87ipc/sem.cint size;
size100ipc/sem.csize = sizeof (*sma) + nsems * sizeof (struct sem);
size102ipc/sem.csma = (struct semid_ds *) kmalloc (size, GFP_KERNEL);
size110ipc/sem.cmemset (sma, 0, size);
size559ipc/sem.cint i, id, size, error;
size601ipc/sem.csize = sizeof(struct sem_undo) + sizeof(short)*sma->sem_nsems;
size602ipc/sem.cun = (struct sem_undo *) kmalloc(size, GFP_ATOMIC);
size605ipc/sem.cmemset(un, 0, size);
size22ipc/shm.cstatic int newseg (key_t key, int shmflg, int size);
size73ipc/shm.cstatic int newseg (key_t key, int shmflg, int size)
size76ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
size79ipc/shm.cif (size < SHMMIN)
size115ipc/shm.cshp->shm_segsz = size;
size132ipc/shm.casmlinkage int sys_shmget (key_t key, int size, int shmflg)
size137ipc/shm.cif (size < 0 || size > SHMMAX)
size140ipc/shm.creturn newseg(key, shmflg, size);
size144ipc/shm.creturn newseg(key, shmflg, size);
size151ipc/shm.cif (size > shp->shm_segsz)
size101ipc/util.casmlinkage int sys_shmget (key_t key, int size, int flag)
size138kernel/module.csys_create_module(char *module_name, unsigned long size)
size149kernel/module.cif (module_name == NULL || size == 0)
size162kernel/module.cnpages = (size + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE;
size172kernel/module.cmp->size = npages;
size181kernel/module.cmp->name, (unsigned long) mp->size, (unsigned long) mp->addr));
size225kernel/module.cif ((codesize + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE > mp->size)
size229kernel/module.cmp->size * PAGE_SIZE - (codesize + sizeof (long)));
size238kernel/module.cint size;
size242kernel/module.cif ((error = verify_area(VERIFY_READ, &symtab->size, sizeof(symtab->size))))
size244kernel/module.csize = get_user(&symtab->size);
size246kernel/module.cif ((newtab = (struct symbol_table*) kmalloc(size, GFP_KERNEL)) == NULL) {
size250kernel/module.cif ((error = verify_area(VERIFY_READ, symtab, size))) {
size251kernel/module.ckfree_s(newtab, size);
size254kernel/module.cmemcpy_fromfs((char *)(newtab), symtab, size);
size262kernel/module.c(legal_start > size)) {
size264kernel/module.ckfree_s(newtab, size);
size271kernel/module.cif ((unsigned long)sym->name < legal_start || size <= (unsigned long)sym->name) {
size273kernel/module.ckfree_s(newtab, size);
size501kernel/module.cif (mp->symtab->size)
size502kernel/module.ckfree_s(mp->symtab, mp->symtab->size);
size524kernel/module.cchar size[32];
size537kernel/module.csprintf(size, "%d", mp->size);
size538kernel/module.ci -= strlen(size);
size543kernel/module.cq = size;
size657kernel/module.cint size;
size722kernel/module.cif (oldtab->size > 0)
size723kernel/module.ckfree_s(oldtab, oldtab->size);
size738kernel/module.csize = SYMSIZ + intab->n_symbols * INTSIZ +
size749kernel/module.cnewtab->size = size;
size776kernel/module.cif (oldtab->size > 0)
size777kernel/module.ckfree_s(oldtab, oldtab->size);
size270lib/string.cvoid * memscan(void * addr, int c, size_t size)
size274lib/string.cwhile (size) {
size278lib/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)
size72mm/filemap.cunsigned long size, result;
size92mm/filemap.csize = offset + PAGE_SIZE;
size95mm/filemap.cif (size > inode->i_size)
size96mm/filemap.csize = inode->i_size;
size98mm/filemap.cif (size < offset)
size101mm/filemap.csize -= offset;
size110mm/filemap.cresult = file.f_op->write(inode, &file, (const char *) page, size);
size112mm/filemap.cif (result != size)
size197mm/filemap.cunsigned long address, unsigned long size, 
size214mm/filemap.cend = address + size;
size227mm/filemap.cunsigned long address, unsigned long size, 
size244mm/filemap.cend = address + size;
size257mm/filemap.csize_t size, unsigned int flags)
size260mm/filemap.cunsigned long end = address + size;
size88mm/kmalloc.cint size;
size143mm/kmalloc.c#define BLOCKSIZE(order)        (sizes[order].size)
size171mm/kmalloc.cint get_order(int size)
size176mm/kmalloc.csize += sizeof(struct block_header);
size178mm/kmalloc.cif (size <= BLOCKSIZE(order))
size183mm/kmalloc.cvoid *kmalloc(size_t size, int priority)
size191mm/kmalloc.corder = get_order(size);
size193mm/kmalloc.cprintk("kmalloc of too large a block (%d bytes).\n", (int) size);
size278mm/kmalloc.csizes[order].nbytesmalloced += size;
size280mm/kmalloc.cp->bh_length = size;
size286mm/kmalloc.cint size;
size311mm/kmalloc.csize = p->bh_length;
size342mm/kmalloc.csizes[order].nbytesmalloced -= size;
size357mm/memory.cstatic inline void unmap_pte_range(pmd_t * pmd, unsigned long address, unsigned long size)
size371mm/memory.cend = address + size;
size383mm/memory.cstatic inline void unmap_pmd_range(pgd_t * dir, unsigned long address, unsigned long size)
size397mm/memory.cend = address + size;
size411mm/memory.cint unmap_page_range(unsigned long address, unsigned long size)
size414mm/memory.cunsigned long end = address + size;
size426mm/memory.cstatic inline void zeromap_pte_range(pte_t * pte, unsigned long address, unsigned long size, pte_t zero_pte)
size431mm/memory.cend = address + size;
size443mm/memory.cstatic inline int zeromap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size, pte_t zero_pte)
size448mm/memory.cend = address + size;
size462mm/memory.cint zeromap_page_range(unsigned long address, unsigned long size, pgprot_t prot)
size466mm/memory.cunsigned long end = address + size;
size491mm/memory.cstatic inline void remap_pte_range(pte_t * pte, unsigned long address, unsigned long size,
size497mm/memory.cend = address + size;
size512mm/memory.cstatic inline int remap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size,
size518mm/memory.cend = address + size;
size533mm/memory.cint remap_page_range(unsigned long from, unsigned long offset, unsigned long size, pgprot_t prot)
size537mm/memory.cunsigned long end = from + size;
size697mm/memory.cint verify_area(int type, const void * addr, unsigned long size)
size726mm/memory.cif (vma->vm_end - start >= size)
size740mm/memory.cif (vma->vm_end - start >= size)
size751mm/memory.csize--;
size752mm/memory.csize += start & ~PAGE_MASK;
size753mm/memory.csize >>= PAGE_SHIFT;
size758mm/memory.cif (!size)
size760mm/memory.csize--;
size21mm/mprotect.cunsigned long size, pgprot_t newprot)
size35mm/mprotect.cend = address + size;
size48mm/mprotect.cunsigned long size, pgprot_t newprot)
size62mm/mprotect.cend = address + size;
size769mm/swap.cdo { unsigned long size = PAGE_SIZE << high; \
size771mm/swap.chigh--; size >>= 1; cli(); \
size775mm/swap.caddr = (struct mem_list *) (size + (unsigned long) addr); \
size880mm/swap.cunsigned long address, unsigned long size, unsigned long offset,
size896mm/swap.cend = address + size;
size909mm/swap.cunsigned long address, unsigned long size,
size925mm/swap.cend = address + size;
size24mm/vmalloc.cunsigned long size;
size38mm/vmalloc.cstatic inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)
size52mm/vmalloc.cend = address + size;
size70mm/vmalloc.cstatic inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)
size84mm/vmalloc.cend = address + size;
size94mm/vmalloc.cstatic void free_area_pages(unsigned long address, unsigned long size)
size97mm/vmalloc.cunsigned long end = address + size;
size108mm/vmalloc.cstatic inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)
size113mm/vmalloc.cend = address + size;
size130mm/vmalloc.cstatic inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)
size135mm/vmalloc.cend = address + size;
size150mm/vmalloc.cstatic int alloc_area_pages(unsigned long address, unsigned long size)
size153mm/vmalloc.cunsigned long end = address + size;
size170mm/vmalloc.cstatic inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
size176mm/vmalloc.cend = address + size;
size189mm/vmalloc.cstatic inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
size195mm/vmalloc.cend = address + size;
size210mm/vmalloc.cstatic int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)
size213mm/vmalloc.cunsigned long end = address + size;
size231mm/vmalloc.cstatic struct vm_struct * get_vm_area(unsigned long size)
size240mm/vmalloc.carea->size = size + PAGE_SIZE;
size243mm/vmalloc.cif (size + (unsigned long) addr < (unsigned long) tmp->addr)
size245mm/vmalloc.caddr = (void *) (tmp->size + (unsigned long) tmp->addr);
size266mm/vmalloc.cfree_area_pages(VMALLOC_VMADDR(tmp->addr), tmp->size);
size274mm/vmalloc.cvoid * vmalloc(unsigned long size)
size279mm/vmalloc.csize = PAGE_ALIGN(size);
size280mm/vmalloc.cif (!size || size > (MAP_NR(high_memory) << PAGE_SHIFT))
size282mm/vmalloc.carea = get_vm_area(size);
size286mm/vmalloc.cif (alloc_area_pages(VMALLOC_VMADDR(addr), size)) {
size298mm/vmalloc.cvoid * vremap(unsigned long offset, unsigned long size)
size307mm/vmalloc.csize = PAGE_ALIGN(size);
size308mm/vmalloc.cif (!size || size > offset + size)
size310mm/vmalloc.carea = get_vm_area(size);
size314mm/vmalloc.cif (remap_area_pages(VMALLOC_VMADDR(addr), offset, size)) {
size334mm/vmalloc.cn = tmp->size - PAGE_SIZE;
size249net/802/tr.cint size,i;
size253net/802/tr.csize=sprintf(buffer,
size255net/802/tr.cpos+=size;
size256net/802/tr.clen+=size;
size260net/802/tr.csize=sprintf(buffer+len,"%02X:%02X:%02X:%02X:%02X:%02X %04X %04X %04X %04X %04X %04X %04X %04X %04X %lu\n",
size264net/802/tr.clen+=size;
size1478net/appletalk/ddp.cint size;
size1523net/appletalk/ddp.csize=sizeof(struct ddpehdr)+len+ddp_dl->header_length;  /* For headers */
size1544net/appletalk/ddp.cprintk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
size1546net/appletalk/ddp.csize += dev->hard_header_len;
size1548net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0 , &err);
size1647net/appletalk/ddp.cstatic int atalk_sendto(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags,
size1653net/appletalk/ddp.ciov.iov_len=size;
size1659net/appletalk/ddp.creturn atalk_sendmsg(sock,&msg,size,noblock,flags);  
size1663net/appletalk/ddp.cstatic int atalk_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
size1665net/appletalk/ddp.creturn atalk_sendto(sock,ubuf,size,noblock,flags,NULL,0);
size1668net/appletalk/ddp.cstatic int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size1695net/appletalk/ddp.cif(copied > size)
size1696net/appletalk/ddp.ccopied=size;
size1702net/appletalk/ddp.cif (copied > size)
size1703net/appletalk/ddp.ccopied = size;
size1718net/appletalk/ddp.cstatic int atalk_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1720net/appletalk/ddp.creturn atalk_send(sock,ubuf,size,noblock,0);
size1724net/appletalk/ddp.cstatic int atalk_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags,
size1730net/appletalk/ddp.ciov.iov_len=size;
size1738net/appletalk/ddp.creturn atalk_recvmsg(sock,&msg,size,noblock,flags,addr_len);  
size1741net/appletalk/ddp.cstatic int atalk_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1747net/appletalk/ddp.creturn atalk_recvfrom(sock,ubuf,size,noblock,flags,NULL, NULL);
size1750net/appletalk/ddp.cstatic int atalk_read(struct socket *sock, char *ubuf, int size, int noblock)
size1752net/appletalk/ddp.creturn atalk_recv(sock,ubuf,size,noblock,0);
size1642net/ax25/af_ax25.cint size;
size1721net/ax25/af_ax25.csize = len + 3 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
size1723net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
size1730net/ax25/af_ax25.cskb_reserve(skb, size - len);
size1785net/ax25/af_ax25.cstatic int ax25_sendto(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags,
size1791net/ax25/af_ax25.ciov.iov_len=size;
size1797net/ax25/af_ax25.creturn ax25_sendmsg(sock,&msg,size,noblock,flags);  
size1801net/ax25/af_ax25.cstatic int ax25_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
size1803net/ax25/af_ax25.creturn ax25_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
size1806net/ax25/af_ax25.cstatic int ax25_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1808net/ax25/af_ax25.creturn ax25_sendto(sock, ubuf, size, noblock, 0, NULL, 0);
size1811net/ax25/af_ax25.cstatic int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size1851net/ax25/af_ax25.ccopied = (size < length) ? size : length;
size1881net/ax25/af_ax25.cstatic int ax25_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags,
size1887net/ax25/af_ax25.ciov.iov_len=size;
size1895net/ax25/af_ax25.creturn ax25_recvmsg(sock,&msg,size,noblock,flags,addr_len);  
size1898net/ax25/af_ax25.cstatic int ax25_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1906net/ax25/af_ax25.creturn ax25_recvfrom(sock, ubuf, size, noblock, flags, NULL, NULL);
size1909net/ax25/af_ax25.cstatic int ax25_read(struct socket *sock, char *ubuf, int size, int noblock)
size1911net/ax25/af_ax25.creturn ax25_recv(sock, ubuf, size, noblock, 0);
size2183net/ax25/af_ax25.cint size;
size2193net/ax25/af_ax25.csize = skb->len;
size2197net/ax25/af_ax25.c*ptr++ = (size + 5) % 256;
size2198net/ax25/af_ax25.c*ptr++ = (size + 5) / 256;
size172net/core/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
size174net/core/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
size182net/core/datagram.cvoid skb_copy_datagram_iovec(struct sk_buff *skb, int offset, struct iovec *to, int size)
size184net/core/datagram.cmemcpy_toiovec(to,skb->h.raw+offset,size);
size884net/core/dev.cint size;
size887net/core/dev.csize = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
size899net/core/dev.csize = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
size901net/core/dev.creturn size;
size914net/core/dev.cint size;
size919net/core/dev.csize = sprintf(buffer, "Inter-|   Receive                  |  Transmit\n"
size922net/core/dev.cpos+=size;
size923net/core/dev.clen+=size;
size928net/core/dev.csize = sprintf_stats(buffer+len, dev);
size929net/core/dev.clen+=size;
size492net/core/skbuff.cstruct sk_buff *alloc_skb(unsigned int size,int priority)
size496net/core/skbuff.cint len=size;
size509net/core/skbuff.csize=(size+15)&~15;    /* Allow for alignments. Make a multiple of 16 bytes */
size510net/core/skbuff.csize+=sizeof(struct sk_buff);  /* And stick the control itself on the end */
size516net/core/skbuff.cbptr=(unsigned char *)kmalloc(size,priority);
size535net/core/skbuff.cskb=(struct sk_buff *)(bptr+size)-1;
size543net/core/skbuff.cskb->truesize=size;
size305net/core/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
size309net/core/sock.cif (sk->wmem_alloc + size < sk->sndbuf || force) 
size311net/core/sock.cstruct sk_buff * c = alloc_skb(size, priority);
size324net/core/sock.creturn(alloc_skb(size, priority));
size328net/core/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
size332net/core/sock.cif (sk->rmem_alloc + size < sk->rcvbuf || force) 
size334net/core/sock.cstruct sk_buff *c = alloc_skb(size, priority);
size347net/core/sock.creturn(alloc_skb(size, priority));
size424net/core/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, int noblock, int *errcode)
size449net/core/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
size134net/ipv4/af_inet.cint size = 32767; /* a big num. */
size159net/ipv4/af_inet.cif (j < size) 
size162net/ipv4/af_inet.csize = j;
size1178net/ipv4/af_inet.cstatic int inet_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, 
size1190net/ipv4/af_inet.creturn(sk->prot->recvfrom(sk, (unsigned char *) ubuf, size, noblock, flags,
size1195net/ipv4/af_inet.cstatic int inet_recv(struct socket *sock, void *ubuf, int size, int noblock,
size1199net/ipv4/af_inet.creturn inet_recvfrom(sock,ubuf,size,noblock,flags,NULL,NULL);
size1202net/ipv4/af_inet.cstatic int inet_read(struct socket *sock, char *ubuf, int size, int noblock)
size1211net/ipv4/af_inet.creturn(sk->prot->read(sk, (unsigned char *) ubuf, size, noblock, 0));
size1214net/ipv4/af_inet.cstatic int inet_send(struct socket *sock, const void *ubuf, int size, int noblock, 
size1228net/ipv4/af_inet.creturn(sk->prot->write(sk, (const unsigned char *) ubuf, size, noblock, flags));
size1231net/ipv4/af_inet.cstatic int inet_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1233net/ipv4/af_inet.creturn inet_send(sock,ubuf,size,noblock,0);
size1236net/ipv4/af_inet.cstatic int inet_sendto(struct socket *sock, const void *ubuf, int size, int noblock, 
size1252net/ipv4/af_inet.creturn(sk->prot->sendto(sk, (const unsigned char *) ubuf, size, noblock, flags, 
size1056net/ipv4/arp.cint size;
size1062net/ipv4/arp.csize = sprintf(buffer,"IP address       HW type     Flags       HW address            Mask\n");
size1064net/ipv4/arp.cpos+=size;
size1065net/ipv4/arp.clen+=size;
size1098net/ipv4/arp.csize = sprintf(buffer+len,
size1104net/ipv4/arp.csize += sprintf(buffer+len+size,
size1109net/ipv4/arp.clen+=size;
size515net/ipv4/icmp.cint size, offset;
size520net/ipv4/icmp.csize = dev->hard_header_len + 64 + len + 15;
size521net/ipv4/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size587net/ipv4/icmp.cint size, offset;
size600net/ipv4/icmp.csize = dev->hard_header_len + 84 + 15;
size602net/ipv4/icmp.cif (! (skb2 = alloc_skb(size, GFP_ATOMIC))) 
size694net/ipv4/icmp.cint size, offset;
size700net/ipv4/icmp.csize = dev->hard_header_len + 64 + len + 15;
size701net/ipv4/icmp.cskb2 = alloc_skb(size, GFP_ATOMIC);
size722net/ipv4/ip_fw.cint    size;
size779net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
size790net/ipv4/ip_fw.crecalc_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size);
size814net/ipv4/ip_fw.ctcp_send_check(th,iph->saddr,iph->daddr,size,skb->sk);
size871net/ipv4/ip_fw.cint size = skb_ptr->len - ((unsigned char *)portptr - skb_ptr->h.raw);
size879net/ipv4/ip_fw.crecalc_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size);
size891net/ipv4/ip_fw.ctcp_send_check((struct tcphdr *)portptr,iph->saddr,iph->daddr,size,skb_ptr->sk);
size487net/ipv4/rarp.cint size;
size493net/ipv4/rarp.csize = sprintf(buffer,"RARP disabled until entries added to cache.\n");
size494net/ipv4/rarp.cpos+=size;
size495net/ipv4/rarp.clen+=size;
size499net/ipv4/rarp.csize = sprintf(buffer,
size501net/ipv4/rarp.cpos+=size;
size502net/ipv4/rarp.clen+=size;
size514net/ipv4/rarp.csize = sprintf(buffer+len,
size525net/ipv4/rarp.clen+=size;
size560net/ipv4/route.cint size;
size572net/ipv4/route.csize = sprintf(buffer+len, "%s\t%08lX\t%08lX\t%02X\t%d\t%lu\t%d\t%08lX\t%d\t%lu\t%u\n",
size576net/ipv4/route.clen+=size;
size577net/ipv4/route.cpos+=size;
size456net/ipv4/tcp.cint size;
size479net/ipv4/tcp.csize = ntohs(iph->tot_len) - (iph->ihl<<2);
size533net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size1138net/ipv4/tcp.cint size;
size1145net/ipv4/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
size1151net/ipv4/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
size1164net/ipv4/tcp.cif (size == sizeof(struct tcphdr)) 
size1180net/ipv4/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
size1224net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size3076net/ipv4/tcp.cint size;
size3086net/ipv4/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
size3091net/ipv4/tcp.ctcp_send_check(th, sk->saddr, sk->daddr, size, sk);
size997net/ipx/af_ipx.cint size;
size1014net/ipx/af_ipx.csize=sizeof(ipx_packet)+len;
size1015net/ipx/af_ipx.csize += ipx_offset;
size1017net/ipx/af_ipx.cif(size+sk->wmem_alloc>sk->sndbuf) return -EAGAIN;
size1019net/ipx/af_ipx.cskb=alloc_skb(size,GFP_KERNEL);
size1737net/ipx/af_ipx.cstatic int ipx_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
size1739net/ipx/af_ipx.creturn ipx_sendto(sock,ubuf,size,noblock,flags,NULL,0);
size1742net/ipx/af_ipx.cstatic int ipx_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
size1772net/ipx/af_ipx.ccopied = (truesize > size) ? size : truesize;
size1787net/ipx/af_ipx.cstatic int ipx_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1789net/ipx/af_ipx.creturn ipx_send(sock,ubuf,size,noblock,0);
size1793net/ipx/af_ipx.cstatic int ipx_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1799net/ipx/af_ipx.creturn ipx_recvfrom(sock,ubuf,size,noblock,flags,NULL, NULL);
size1802net/ipx/af_ipx.cstatic int ipx_read(struct socket *sock, char *ubuf, int size, int noblock)
size1804net/ipx/af_ipx.creturn ipx_recv(sock,ubuf,size,noblock,0);
size1031net/netrom/af_netrom.cint size;
size1070net/netrom/af_netrom.csize = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + 3 + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
size1072net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
size1079net/netrom/af_netrom.cskb_reserve(skb, size - len);
size1128net/netrom/af_netrom.cstatic int nr_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags)
size1130net/netrom/af_netrom.creturn nr_sendto(sock, ubuf, size, noblock, flags, NULL, 0);
size1133net/netrom/af_netrom.cstatic int nr_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1135net/netrom/af_netrom.creturn nr_send(sock, ubuf, size, noblock, 0);
size1138net/netrom/af_netrom.cstatic int nr_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
size1172net/netrom/af_netrom.ccopied = (size < skb->len) ? size : skb->len;
size1191net/netrom/af_netrom.cstatic int nr_recv(struct socket *sock, void *ubuf, int size , int noblock,
size1199net/netrom/af_netrom.creturn nr_recvfrom(sock, ubuf, size, noblock, flags, NULL, NULL);
size1202net/netrom/af_netrom.cstatic int nr_read(struct socket *sock, char *ubuf, int size, int noblock)
size1204net/netrom/af_netrom.creturn nr_recv(sock, ubuf, size, noblock, 0);
size73net/socket.cint size);
size75net/socket.cint size);
size318net/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)    /* Match SYS5 behaviour */
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, const char *ubuf, int size)
size351net/socket.cif(size<0)
size353net/socket.cif(size==0)    /* Match SYS5 behaviour */
size356net/socket.cif ((err=verify_area(VERIFY_READ,ubuf,size))<0)
size358net/socket.creturn(sock->ops->write(sock, ubuf, size,(file->f_flags & O_NONBLOCK)));
size659net/unix/af_unix.cint err,size;
size709net/unix/af_unix.csize=/*protocol_size(&proto_unix)+*/len;
size710net/unix/af_unix.cskb=sock_alloc_send_skb(sk,size,nonblock, &err);
size748net/unix/af_unix.cstatic int unix_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size838net/unix/af_unix.cnum=min(skb->len,size-copied);
size983net/unix/af_unix.cstatic int unix_recvfrom(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags,
size989net/unix/af_unix.ciov.iov_len=size;
size997net/unix/af_unix.creturn unix_recvmsg(sock,&msg,size,noblock,flags,addr_len);  
size1000net/unix/af_unix.cstatic int unix_read(struct socket *sock, char *ubuf, int size, int noblock)
size1002net/unix/af_unix.creturn unix_recvfrom(sock,ubuf,size,noblock,0,NULL,NULL);
size1005net/unix/af_unix.cstatic int unix_recv(struct socket *sock, void *ubuf, int size, int noblock, unsigned int flags)
size1007net/unix/af_unix.creturn unix_recvfrom(sock,ubuf,size,noblock,flags,NULL,NULL);
size1010net/unix/af_unix.cstatic int unix_sendto(struct socket *sock, const void *ubuf, int size, int noblock, unsigned flags,
size1016net/unix/af_unix.ciov.iov_len=size;
size1022net/unix/af_unix.creturn unix_sendmsg(sock,&msg,size,noblock,flags);  
size1025net/unix/af_unix.cstatic int unix_write(struct socket *sock, const char *ubuf, int size, int noblock)
size1027net/unix/af_unix.creturn unix_sendto(sock,ubuf,size,noblock, 0, NULL, 0);
size1030net/unix/af_unix.cstatic int unix_send(struct socket *sock, const void *ubuf, int size, int noblock, unsigned int flags)
size1032net/unix/af_unix.creturn unix_sendto(sock,ubuf,size,noblock, flags, NULL, 0);