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;
size455arch/alpha/kernel/alcor.cregs->pc, mchk_header->size, mchk_header->proc_offset, mchk_header->sys_offset));
size464arch/alpha/kernel/alcor.cfor (i = 0; i < mchk_header->size / sizeof(long); i += 2) {
size503arch/alpha/kernel/apecs.cregs->pc, mchk_header->size, mchk_header->proc_offset, mchk_header->sys_offset));
size512arch/alpha/kernel/apecs.cfor (i = 0; i < mchk_header->size / sizeof(long); i += 2) {
size137arch/alpha/kernel/bios32.cunsigned int base, mask, size, reg;
size168arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
size170arch/alpha/kernel/bios32.calignto = MAX(0x400, size) ;
size172arch/alpha/kernel/bios32.cio_base = base + size;
size184arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
size231arch/alpha/kernel/bios32.calignto = MAX(0x1000, size) ;
size233arch/alpha/kernel/bios32.cif (size > 7 * 16*MB) {
size239arch/alpha/kernel/bios32.cPCI_FUNC(dev->devfn), size);
size246arch/alpha/kernel/bios32.cif (base / (128*MB) != (base + size) / (128*MB)) {
size252arch/alpha/kernel/bios32.cmem_base = base + size;
size426arch/alpha/kernel/lca.cswitch (el.c->size) {
size453arch/alpha/kernel/lca.cprintk("  Unknown errorlog size %d\n", el.c->size);
size643arch/alpha/kernel/osf_sys.calpha_create_module (char * module_name, unsigned long size,
size650arch/alpha/kernel/osf_sys.cretval = sys_create_module(module_name, size);
size282arch/alpha/kernel/traps.clong dir, size;
size310arch/alpha/kernel/traps.csize = 4;
size313arch/alpha/kernel/traps.csize = 8;
size315arch/alpha/kernel/traps.cif (verify_area(dir, va, size)) {
size110arch/i386/boot/compressed/misc.cstatic void *malloc(int size);
size137arch/i386/boot/compressed/misc.cstatic void *malloc(int size)
size141arch/i386/boot/compressed/misc.cif (size <0) error("Malloc error\n");
size147arch/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;
size468arch/i386/kernel/smp.cint size=(num_processors-1)*PAGE_SIZE;    /* Number of stacks needed */
size474arch/i386/kernel/smp.cif(mem_base+size>=0x9F000)
size477arch/i386/kernel/smp.cmem_base+=size;
size86arch/mips/kernel/jazz-c.cvoid jazz_fd_cacheflush(unsigned char *addr, unsigned int size)
size88arch/mips/kernel/jazz-c.csys_cacheflush((void *)addr, size, DCACHE);
size69arch/mips/kernel/jazzdma.cunsigned long vdma_alloc(unsigned long paddr, unsigned long size)
size87arch/mips/kernel/jazzdma.cif (size > 0x400000 || size == 0)
size90arch/mips/kernel/jazzdma.cprintk("vdma_alloc: Invalid size: %08lx\n",size);
size95arch/mips/kernel/jazzdma.cpages = (size + 4095) >> 12; /* no. of pages to allocate */
size188arch/mips/kernel/jazzdma.cint vdma_remap(unsigned long laddr, unsigned long paddr, unsigned long size)
size207arch/mips/kernel/jazzdma.cpages = (((paddr & (VDMA_PAGESIZE-1)) + size) >> 12) + 1;
size214arch/mips/kernel/jazzdma.cprintk("vdma_alloc: Invalid size: %08lx\n",size);
size240arch/mips/kernel/jazzdma.cpages = (((paddr & (VDMA_PAGESIZE-1)) + size) >> 12) + 1;
size56arch/mips/kernel/setup.cvoid jazz_fd_cacheflush(unsigned char *addr, unsigned int size);
size143arch/mips/kernel/setup.cvoid jazz_fd_cacheflush(unsigned char *addr, unsigned int size);
size245arch/mips/kernel/setup.cbi_TagAdd(enum bi_tag tag, unsigned long size, void *tagdata)
size91arch/mips/kernel/tyne-c.csys_cacheflush((void *)addr, size, DCACHE);
size106arch/mips/kernel/tyne-c.cunsigned long deskstation_tyne_dma_alloc(size_t size)
size109arch/mips/kernel/tyne-c.callocated += size;
size766arch/sparc/mm/srmmu.cvoid srmmu_uncache_iommu_page_table(unsigned long start, int size)
size771arch/sparc/mm/srmmu.cunsigned long end = start + size;
size927arch/sparc/mm/srmmu.cstatic void *srmmu_init_alloc(unsigned long *kbrk, unsigned size)
size929arch/sparc/mm/srmmu.cregister unsigned mask = size - 1;
size932arch/sparc/mm/srmmu.cif(size==0) return 0x0;
size933arch/sparc/mm/srmmu.cif(size & mask) {
size938arch/sparc/mm/srmmu.c*kbrk = ret + size;
size939arch/sparc/mm/srmmu.cmemset((void*) ret, 0, size);
size194arch/sparc/prom/tree.cprom_setprop(int node, char *pname, char *value, int size)
size196arch/sparc/prom/tree.cif(size == 0) return 0;
size198arch/sparc/prom/tree.creturn prom_nodeops->no_setprop(node, pname, value, size);
size193drivers/block/floppy.cstatic inline int __get_order(unsigned long size)
size197drivers/block/floppy.csize = (size-1) >> (PAGE_SHIFT-1);
size200drivers/block/floppy.csize >>= 1;
size202drivers/block/floppy.c} while (size);
size206drivers/block/floppy.cstatic unsigned long dma_mem_alloc(int size)
size208drivers/block/floppy.cint order = __get_order(size);
size2047drivers/block/floppy.cunsigned char track,head,sect,size;
size2089drivers/block/floppy.chere[count].size = F_SIZECODE;
size2260drivers/block/floppy.cfloppy_sizes[TOMINOR(current_drive) ]= _floppy->size>>1;
size2269drivers/block/floppy.cfloppy_sizes[TOMINOR(current_drive)] = _floppy->size >> 1;
size2289drivers/block/floppy.cint size;
size2293drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2298drivers/block/floppy.cwhile (bh && bh->b_data == base + size){
size2299drivers/block/floppy.csize += bh->b_size;
size2303drivers/block/floppy.creturn size >> 9;
size2328drivers/block/floppy.cint size;
size2359drivers/block/floppy.csize = CURRENT->current_nr_sectors << 9;
size2363drivers/block/floppy.cSUPBOUND(size, remaining);
size2365drivers/block/floppy.cif (dma_buffer + size >
size2384drivers/block/floppy.cfd_cacheflush(dma_buffer, size);
size2385drivers/block/floppy.cmemcpy(buffer, dma_buffer, size);
size2387drivers/block/floppy.cmemcpy(dma_buffer, buffer, size);
size2388drivers/block/floppy.cfd_cacheflush(dma_buffer, size);
size2390drivers/block/floppy.cremaining -= size;
size2394drivers/block/floppy.cdma_buffer += size;
size2402drivers/block/floppy.csize = bh->b_size;
size2832drivers/block/floppy.cstatic int fd_copyout(void *param, const void *address, int size)
size2836drivers/block/floppy.cECALL(verify_area(VERIFY_WRITE,param,size));
size2837drivers/block/floppy.cfd_cacheflush(address, size); /* is this necessary ??? */
size2840drivers/block/floppy.cmemcpy_tofs(param,(void *) address, size);
size2844drivers/block/floppy.cstatic int fd_copyin(void *param, void *address, int size)
size2848drivers/block/floppy.cECALL(verify_area(VERIFY_READ,param,size));
size2849drivers/block/floppy.cmemcpy_fromfs((void *) address, param, size);
size3133drivers/block/floppy.cfloppy_type[type].size>>1;
size3152drivers/block/floppy.cfloppy_sizes[drive] = user_params[drive].size >> 1;
size3204drivers/block/floppy.cstatic inline int normalize_0x02xx_ioctl(int *cmd, int *size)
size3210drivers/block/floppy.c*size = _IOC_SIZE(*cmd);
size3212drivers/block/floppy.cif (*size > _IOC_SIZE(*cmd)) {
size3222drivers/block/floppy.cstatic inline int xlate_0x00xx_ioctl(int *cmd, int *size)
size3239drivers/block/floppy.c*size = translation_table[i].oldsize;
size3259drivers/block/floppy.cint size;
size3287drivers/block/floppy.cECALL(normalize_0x02xx_ioctl(&cmd, &size));
size3289drivers/block/floppy.cECALL(xlate_0x00xx_ioctl(&cmd, &size));
size3300drivers/block/floppy.cECALL(verify_area(VERIFY_WRITE,(void *) param, size));
size3305drivers/block/floppy.cECALL(fd_copyin((void *)param, &inparam, size))
size3381drivers/block/floppy.cSUPBOUND(size,strlen(outparam)+1);
size3425drivers/block/floppy.creturn fd_copyout((void *)param, outparam, size);
size3689drivers/block/floppy.cint size = floppy_blocksizes[MINOR(dev)];
size3690drivers/block/floppy.cif (!size)
size3691drivers/block/floppy.csize = 1024;
size3692drivers/block/floppy.cif (!(bh = getblk(dev,0,size))){
size3961drivers/block/floppy.cfloppy_sizes[i] = floppy_type[ITYPE(i)].size >> 1;
size98drivers/block/genhd.cstatic void add_partition (struct gendisk *hd, int minor, int start, int size)
size102drivers/block/genhd.chd->part[minor].nr_sects   = size;
size34drivers/block/linear.cint cur=0, i, size, dev0_size, nb_zone;
size50drivers/block/linear.cif (data->smallest->size > devices[minor][i].size)
size54drivers/block/linear.cmd_size[minor]/data->smallest->size +
size55drivers/block/linear.c(md_size[minor]%data->smallest->size ? 1 : 0);
size59drivers/block/linear.csize=devices[minor][cur].size;
size66drivers/block/linear.cif (size>=data->smallest->size) /* If we completely fill the slot */
size69drivers/block/linear.csize-=data->smallest->size;
size71drivers/block/linear.cif (!size)
size74drivers/block/linear.csize=devices[minor][cur].size;
size86drivers/block/linear.cdev0_size=size;    /* Here, we use a 2nd dev to fill the slot */
size87drivers/block/linear.csize=devices[minor][cur].size;
size89drivers/block/linear.csize-=(data->smallest->size - dev0_size);
size121drivers/block/linear.chash=data->hash_table+(block/data->smallest->size);
size123drivers/block/linear.cif (block >= (hash->dev0->size + hash->dev0->offset))
size132drivers/block/linear.cif (block >= (tmp_dev->size + tmp_dev->offset) || block < tmp_dev->offset)
size133drivers/block/linear.cprintk ("Block %ld out of bounds on dev %04x size %d offset %d\n", block, tmp_dev->dev, tmp_dev->size, tmp_dev->offset);
size149drivers/block/linear.cbh && rblock + nblk + (bh->b_size >> 10) <= tmp_dev->size;
size47drivers/block/loop.cchar *loop_buf, int size)
size50drivers/block/loop.cmemcpy(loop_buf, raw_buf, size);
size52drivers/block/loop.cmemcpy(raw_buf, loop_buf, size);
size57drivers/block/loop.cchar *loop_buf, int size)
size71drivers/block/loop.cfor (i=0; i < size; i++)
size78drivers/block/loop.cchar *loop_buf, int size)
size83drivers/block/loop.cif (size & 7)
size87drivers/block/loop.cwhile (size) {
size106drivers/block/loop.csize -= 8;
size131drivers/block/loop.cint  size;
size134drivers/block/loop.csize = (lo->lo_inode->i_size - lo->lo_offset) / 1024;
size137drivers/block/loop.csize = ((blk_size[MAJOR(lo->lo_device)]
size141drivers/block/loop.csize = MAX_DISK_SIZE;
size143drivers/block/loop.cloop_sizes[lo->lo_number] = size;
size148drivers/block/loop.cint  real_block, block, offset, len, blksize, size;
size216drivers/block/loop.csize = blksize - offset;
size217drivers/block/loop.cif (size > len)
size218drivers/block/loop.csize = len;
size221drivers/block/loop.cdest_addr, size)) {
size229drivers/block/loop.cdest_addr += size;
size230drivers/block/loop.clen -= size;
size183drivers/block/md.cdevices[minor][index].size=gen_real->sizes[MINOR(dev)] & ~((PAGE_SIZE >> 10)-1);
size185drivers/block/md.c(devices[minor][index-1].offset + devices[minor][index-1].size) : 0;
size188drivers/block/md.cmd_size[minor]=devices[minor][index].size;
size190drivers/block/md.cmd_size[minor]+=devices[minor][index].size;
size44drivers/block/raid0.cif (devices[minor][i].size==devices[minor][j].size)
size68drivers/block/raid0.cif (devices[minor][j].size>current_offset)
size72drivers/block/raid0.csmallest_by_zone->size > devices[minor][j].size)
size77drivers/block/raid0.cdata->strip_zone[i].size=(smallest_by_zone->size-current_offset)*c;
size80drivers/block/raid0.cdata->smallest->size > data->strip_zone[i].size)
size84drivers/block/raid0.cdata->strip_zone[i-1].size) : 0;
size85drivers/block/raid0.ccurrent_offset=smallest_by_zone->size;
size91drivers/block/raid0.cint cur=0, i=0, size, zone0_size, nb_zone, min;
size97drivers/block/raid0.cif (devices[minor][i].size<min)
size111drivers/block/raid0.cdevices[minor][i].size &= ~((1 << FACTOR_SHIFT(FACTOR(mddev))) - 1);
size112drivers/block/raid0.cmd_size[minor] += devices[minor][i].size;
size121drivers/block/raid0.cmd_size[minor]/data->smallest->size +
size122drivers/block/raid0.c(md_size[minor]%data->smallest->size ? 1 : 0);
size126drivers/block/raid0.csize=data->strip_zone[cur].size;
size133drivers/block/raid0.cif (size>=data->smallest->size)/* If we completely fill the slot */
size136drivers/block/raid0.csize-=data->smallest->size;
size138drivers/block/raid0.cif (!size)
size141drivers/block/raid0.csize=data->strip_zone[cur].size;
size153drivers/block/raid0.czone0_size=size;    /* Here, we use a 2nd dev to fill the slot */
size154drivers/block/raid0.csize=data->strip_zone[cur].size;
size156drivers/block/raid0.csize-=(data->smallest->size - zone0_size);
size198drivers/block/raid0.chash=data->hash_table+(block/data->smallest->size);
size200drivers/block/raid0.cif (block >= (hash->zone0->size +
size300drivers/block/raid0.cdata->strip_zone[j].size);
size327drivers/block/rd.cconst int size = 512;
size334drivers/block/rd.cbuf = kmalloc(size, GFP_KERNEL);
size340drivers/block/rd.cmemset(buf, 0xe5, size);
size349drivers/block/rd.cfp->f_op->read(fp->f_inode, fp, buf, size);
size370drivers/block/rd.cfp->f_op->read(fp->f_inode, fp, buf, size);
size574drivers/block/rd.cstatic void *malloc(int size);
size582drivers/block/rd.cstatic void *malloc(int size)
size584drivers/block/rd.creturn kmalloc(size, GFP_KERNEL);
size183drivers/block/triton.cunsigned long size, addr, *table = HWIF(drive)->dmatable;
size198drivers/block/triton.csize = drive->tape.pc->request_transfer;
size201drivers/block/triton.csize = rq->nr_sectors << 9;
size205drivers/block/triton.csize = bh->b_size;
size207drivers/block/triton.cif ((addr + size) != virt_to_bus (bh->b_data))
size209drivers/block/triton.csize += bh->b_size;
size217drivers/block/triton.cwhile (size) {
size223drivers/block/triton.cif (bcount > size)
size224drivers/block/triton.cbcount = size;
size228drivers/block/triton.csize -= bcount;
size242drivers/cdrom/cdu31a.cstatic void size_to_buf(unsigned int size,
size1062drivers/cdrom/cdu31a.csize_to_buf(unsigned int size,
size1065drivers/cdrom/cdu31a.cbuf[0] = size / 65536;
size1066drivers/cdrom/cdu31a.csize = size % 65536;
size1067drivers/cdrom/cdu31a.cbuf[1] = size / 256;
size1068drivers/cdrom/cdu31a.cbuf[2] = size % 256;
size1711drivers/cdrom/cdu31a.cint  size)
size1713drivers/cdrom/cdu31a.csrc += (size - 1);
size1714drivers/cdrom/cdu31a.cdst += (size - 1);
size1715drivers/cdrom/cdu31a.cwhile (size > 0)
size1718drivers/cdrom/cdu31a.csize--;
size1120drivers/cdrom/cm206.clong int size=sizeof(struct cm206_struct);
size1130drivers/cdrom/cm206.ccd = (struct cm206_struct *) kmalloc(size, GFP_KERNEL);
size1180drivers/cdrom/cm206.c" %ld bytes kernel memory used.\n", cd->max_sectors*2, size);
size734drivers/cdrom/gscd.cstatic void cmd_read_b ( char *pb, int count, int size )
size763drivers/cdrom/gscd.cfor ( i=0 ; i< size ; i++ )
size811drivers/cdrom/gscd.cstatic void cmd_read_w ( char *pb, int count, int size )
size835drivers/cdrom/gscd.cfor ( i=0 ; i<size ; i++ )
size242drivers/cdrom/mcdx.cvoid *buffer, size_t size, 
size917drivers/cdrom/mcdx.cvoid *buffer, size_t size, 
size945drivers/cdrom/mcdx.ctries, timeout, size, (unsigned char) cmd[0]));
size956drivers/cdrom/mcdx.csize_t sz = size;
size1120drivers/cdrom/mcdx.cint size;
size1124drivers/cdrom/mcdx.csize = sizeof(*stuffp);
size1129drivers/cdrom/mcdx.cTRACE((MALLOC, "init() malloc %d bytes\n", size));
size1130drivers/cdrom/mcdx.cif (!(stuffp = kmalloc(size, GFP_KERNEL))) {
size1500drivers/cdrom/mcdx.cint size;
size1501drivers/cdrom/mcdx.csize = sizeof(struct s_subqcode) * (stuffp->di.n_last - stuffp->di.n_first + 2);
size1503drivers/cdrom/mcdx.cTRACE((MALLOC, "ioctl() malloc %d bytes\n", size));
size1504drivers/cdrom/mcdx.cstuffp->toc = kmalloc(size, GFP_KERNEL);
size1506drivers/cdrom/mcdx.cWARN(("Cannot malloc %s bytes for toc\n", size));
size766drivers/cdrom/sonycd535.csize_to_buf(unsigned int size, Byte *buf)
size768drivers/cdrom/sonycd535.cbuf[0] = size / 65536;
size769drivers/cdrom/sonycd535.csize = size % 65536;
size770drivers/cdrom/sonycd535.cbuf[1] = size / 256;
size771drivers/cdrom/sonycd535.cbuf[2] = size % 256;
size549drivers/char/ftape/ftape-read.cftape_last_segment.size = 0;
size553drivers/char/ftape/ftape-read.cftape_last_segment.size += space;  /* sectors free */
size554drivers/char/ftape/ftape-read.cftape_last_segment.free = (ftape_last_segment.size -
size559drivers/char/ftape/ftape-read.cftape_last_segment.id, ftape_last_segment.size);
size121drivers/char/ftape/ftape-rw.hint size;
size88drivers/char/ftape/kernel-interface.cstatic inline int __get_order(unsigned long size)
size92drivers/char/ftape/kernel-interface.csize = (size-1) >> (PAGE_SHIFT-1);
size95drivers/char/ftape/kernel-interface.csize >>= 1;
size97drivers/char/ftape/kernel-interface.c} while (size);
size579drivers/char/istallion.cstatic int  stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
size580drivers/char/istallion.cstatic void  stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
size631drivers/char/istallion.cstatic void *stli_mapbrdmem(unsigned long physaddr, unsigned int size);
size1203drivers/char/istallion.cstatic int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
size1208drivers/char/istallion.cprintk("stli_cmdwait(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,copyback=%d)\n", (int) brdp, (int) portp, (int) cmd, (int) arg, size, copyback);
size1221drivers/char/istallion.cstli_sendcmd(brdp, portp, cmd, arg, size, copyback);
size1369drivers/char/istallion.cunsigned int    len, stlen, head, tail, size;
size1432drivers/char/istallion.csize = portp->txsize;
size1434drivers/char/istallion.clen = size - (head - tail) - 1;
size1435drivers/char/istallion.cstlen = size - head;
size1452drivers/char/istallion.cif (head >= size) {
size1521drivers/char/istallion.cunsigned int    len, stlen, head, tail, size, count, cooksize;
size1562drivers/char/istallion.csize = portp->txsize;
size1564drivers/char/istallion.clen = size - (head - tail) - 1;
size1565drivers/char/istallion.cstlen = size - head;
size1583drivers/char/istallion.cif (head >= size) {
size2220drivers/char/istallion.cstatic void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
size2228drivers/char/istallion.cprintk("stli_sendcmd(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,copyback=%d)\n", (int) brdp, (int) portp, (int) cmd, (int) arg, size, copyback);
size2242drivers/char/istallion.cif (size > 0) {
size2243drivers/char/istallion.cmemcpy((void *) &(cp->args[0]), arg, size);
size2246drivers/char/istallion.cportp->argsize = size;
size2275drivers/char/istallion.cunsigned int    head, tail, size;
size2293drivers/char/istallion.csize = portp->rxsize;
size2298drivers/char/istallion.clen = size - (tail - head);
size2299drivers/char/istallion.cstlen = size - tail;
size2315drivers/char/istallion.cif (tail >= size) {
size3359drivers/char/istallion.cstatic void *stli_mapbrdmem(unsigned long physaddr, unsigned int size)
size3365drivers/char/istallion.cprintk("stli_mapbrdmem(physaddr=%x,size=%x)\n", (int) physaddr, size);
size3368drivers/char/istallion.cif ((virtaddr = vmalloc(size)) == (char *) NULL) {
size3369drivers/char/istallion.cprintk("STALLION: failed to allocate virtual address space, size=%x\n", size);
size3372drivers/char/istallion.cif ((rc = remap_page_range((TASK_SIZE + ((unsigned long) virtaddr)), physaddr, size, PAGE_IOMEM))) {
size3753drivers/char/istallion.cportp->rxsize = ap->rxq.size;
size3754drivers/char/istallion.cportp->txsize = ap->txq.size;
size4123drivers/char/istallion.cint    brdnr, size, n;
size4140drivers/char/istallion.csize = MIN(count, (brdp->memsize - fp->f_pos));
size4145drivers/char/istallion.cwhile (size > 0) {
size4147drivers/char/istallion.cn = MIN(size, (brdp->pagesize - (((unsigned long) fp->f_pos) % brdp->pagesize)));
size4151drivers/char/istallion.csize -= n;
size4173drivers/char/istallion.cint    brdnr, size, n;
size4191drivers/char/istallion.csize = MIN(count, (brdp->memsize - fp->f_pos));
size4196drivers/char/istallion.cwhile (size > 0) {
size4198drivers/char/istallion.cn = MIN(size, (brdp->pagesize - (((unsigned long) fp->f_pos) % brdp->pagesize)));
size4202drivers/char/istallion.csize -= n;
size538drivers/char/lp.cint base, size;
size546drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
size547drivers/char/lp.cif (check_region(base, size) < 0)
size557drivers/char/lp.crequest_region(base, size, "lp");
size669drivers/char/lp.cint base, size;
size671drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
size673drivers/char/lp.crelease_region(LP_B(offset),size);
size759drivers/char/n_tty.cint size;
size913drivers/char/n_tty.csize = b - buf;
size914drivers/char/n_tty.cif (size && nr)
size916drivers/char/n_tty.cif (!size && clear_bit(TTY_PUSH, &tty->flags))
size918drivers/char/n_tty.cif (!size && !retval)
size920drivers/char/n_tty.creturn (size ? size : retval);
size547drivers/char/pcxx.cint total, remain, size, stlen;
size557drivers/char/pcxx.csize = ch->txbufsize;
size564drivers/char/pcxx.chead = bc->tin & (size - 1);
size568drivers/char/pcxx.ctail &= (size - 1);
size569drivers/char/pcxx.cstlen = (head >= tail) ? (size - (head - tail) - 1) : (tail - head - 1);
size589drivers/char/pcxx.chead = bc->tin & (size - 1);
size593drivers/char/pcxx.ctail &= (size - 1);
size595drivers/char/pcxx.cremain = size - (head - tail) - 1;
size596drivers/char/pcxx.cstlen = size - head;
size612drivers/char/pcxx.cif (head >= size) {
size734drivers/char/random.cint *p, size, ent_count;
size765drivers/char/random.csize = get_user(p);
size767drivers/char/random.cif (size < 0)
size769drivers/char/random.cif (size > POOLWORDS)
size770drivers/char/random.csize = POOLWORDS;
size772drivers/char/random.csize*sizeof(__u32));
size782drivers/char/random.csize = get_user(p++);
size783drivers/char/random.c(void) random_write(0, file, (const char *) p, size);
size1030drivers/char/stallion.cunsigned int  size;
size1047drivers/char/stallion.csize = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
size1048drivers/char/stallion.cif ((size == 0) && test_bit(ASYI_TXBUSY, &portp->istate))
size1049drivers/char/stallion.csize = 1;
size1050drivers/char/stallion.creturn(size);
size780drivers/char/tpqic02.cstatic int send_qic02_data(char sb[], unsigned size, int ignore_ex)
size784drivers/char/tpqic02.cfor (i=0; i<size; i++) {
size846drivers/char/tpqic02.cstatic int rdstatus(char *stp, unsigned size, char qcmd)
size880drivers/char/tpqic02.cfor (q=stp; q<stp+size; q++)
size2803drivers/char/tpqic02.cstatic inline unsigned long const align_buffer(unsigned long a, unsigned size)
size2805drivers/char/tpqic02.cif (a & (size-1))      /* if not aligned */
size2806drivers/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;
size124drivers/isdn/icn/icn.cp->size = sizeof(pqueue) + length;
size144drivers/isdn/icn/icn.ckfree_s(q, q->size);
size382drivers/isdn/icn/icn.ckfree_s(p, p->size);
size181drivers/isdn/icn/icn.hshort size;
size113drivers/isdn/isdn_common.cp->size = sizeof(pqueue) + length;
size132drivers/isdn/isdn_common.ckfree_s(q, q->size);
size634drivers/isdn/isdn_common.ckfree_s(p, p->size);
size306drivers/isdn/teles/buffers.cSmalloc(int size, int pr, char *why)
size310drivers/isdn/teles/buffers.cp = (byte *) kmalloc(size, pr);
size312drivers/isdn/teles/buffers.cprintk(KERN_DEBUG "Smalloc %s size %d res %x\n", why, size, p);
size417drivers/isdn/teles/callc.cprp(byte * p, int size)
size419drivers/isdn/teles/callc.cwhile (size--)
size1036drivers/isdn/teles/callc.cint             size;
size1044drivers/isdn/teles/callc.csize = ibh->datasize - chanp->ds.l2.ihsize;
size1045drivers/isdn/teles/callc.ciif.rcvcallb(drid, chanp->chan, ptr, size);
size29drivers/isdn/teles/isdnl3.cint             size;
size34drivers/isdn/teles/isdnl3.csize = st->l2.ihsize;
size40drivers/isdn/teles/isdnl3.csize += 4;
size42drivers/isdn/teles/isdnl3.cdibh->datasize = size;
size317drivers/isdn/teles/isdnl3.cint             size;
size322drivers/isdn/teles/isdnl3.csize = st->l2.ihsize;
size328drivers/isdn/teles/isdnl3.csize += 4;
size334drivers/isdn/teles/isdnl3.csize += 4;
size336drivers/isdn/teles/isdnl3.cdibh->datasize = size;
size410drivers/isdn/teles/isdnl3.cint             i, mt, size;
size417drivers/isdn/teles/isdnl3.csize = ibh->datasize - st->l2.ihsize;
size419drivers/isdn/teles/isdnl3.cprintk(KERN_INFO "isdnl3/l3up DL_DATA size=%d\n", size);
size420drivers/isdn/teles/isdnl3.cfor (i = 0; i < size; i++)
size456drivers/isdn/teles/isdnl3.csize = ibh->datasize - st->l2.uihsize;
size458drivers/isdn/teles/isdnl3.cprintk(KERN_INFO "isdnl3/l3up DL_UNIT_DATA size=%d\n", size);
size459drivers/isdn/teles/isdnl3.cfor (i = 0; i < size; i++)
size19drivers/isdn/teles/q931.cfindie(byte * p, int size, byte ie, int wanted_set)
size22drivers/isdn/teles/q931.cbyte           *pend = p + size;
size787drivers/isdn/teles/q931.cdlogframe(struct IsdnCardState *sp, byte * buf, int size, char *comment)
size789drivers/isdn/teles/q931.cbyte           *bend = buf + size;
size817drivers/isdn/teles/q931.cbuf[2], size, mtlist[i].descr);
size149drivers/isdn/teles/teles.hbyte           *Smalloc(int size, int pr, char *why);
size396drivers/isdn/teles/teles.hbyte           *findie(byte * p, int size, byte ie, int wanted_set);
size422drivers/isdn/teles/teles.hvoid            dlogframe(struct IsdnCardState *sp, byte * p, int size, char *comment);
size182drivers/net/3c505.cstatic inline int __get_order(unsigned long size)
size186drivers/net/3c505.csize = (size - 1) >> (PAGE_SHIFT - 1);
size189drivers/net/3c505.csize >>= 1;
size191drivers/net/3c505.c} while (size);
size195drivers/net/3c505.cstatic unsigned long dma_mem_alloc(int size)
size197drivers/net/3c505.cint order = __get_order(size);
size207drivers/net/3c505.hword size,
size389drivers/net/3c507.cint size;
size392drivers/net/3c507.csize = 64*1024;
size396drivers/net/3c507.csize = ((mem_config & 3) + 1) << 14;
size400drivers/net/3c507.cdev->mem_end = base + size;
size115drivers/net/3c509.cint head, size;
size43drivers/net/apricot.c#define check_region(addr, size)  0
size44drivers/net/apricot.c#define request_region(addr, size,name)  do ; while(0)
size48drivers/net/apricot.c#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
size49drivers/net/apricot.c#define kfree_skbmem(buff, size) kfree_s(buff,size)
size98drivers/net/apricot.cunsigned short size;
size107drivers/net/apricot.cunsigned short size;
size117drivers/net/apricot.cunsigned short size;
size213drivers/net/apricot.crfd->size = 1532;
size642drivers/net/apricot.ctx_cmd->size = 0;
size644drivers/net/apricot.ctx_cmd->tbd->size = EOF | length;
size583drivers/net/de600.cint    size;
size588drivers/net/de600.csize = de600_read_byte(RX_LEN, dev);  /* low byte */
size589drivers/net/de600.csize += (de600_read_byte(RX_LEN, dev) << 8);  /* high byte */
size590drivers/net/de600.csize -= 4;  /* Ignore trailing 4 CRC-bytes */
size598drivers/net/de600.cif ((size < 32)  ||  (size > 1535)) {
size599drivers/net/de600.cprintk("%s: Bogus packet size %d.\n", dev->name, size);
size600drivers/net/de600.cif (size > 10000)
size605drivers/net/de600.cskb = dev_alloc_skb(size+2);
size609drivers/net/de600.cdev->name, size);
size618drivers/net/de600.cbuffer = skb_put(skb,size);
size622drivers/net/de600.cfor (i = size; i > 0; --i, ++buffer)
size653drivers/net/de620.cint size;
size702drivers/net/de620.csize = header_buf.Rx_ByteCount - 4;
size703drivers/net/de620.cif ((size < RUNT) || (GIANT < size)) {
size704drivers/net/de620.cprintk("%s: Illegal packet size: %d!\n", dev->name, size);
size707drivers/net/de620.cskb = dev_alloc_skb(size+2);
size710drivers/net/de620.cdev->name, size);
size718drivers/net/de620.cbuffer = skb_put(skb,size);
size720drivers/net/de620.cde620_read_block(dev, buffer, size);
size721drivers/net/de620.cPRINTK(("Read %d bytes\n", size));
size577drivers/net/dgrs.cif (rbdp->size & I596_RBD_EL)
size583drivers/net/dgrs.camt = mymin(len, rbdp->size - count);
size577drivers/net/dgrs_driver.cif (rbdp->size & I596_RBD_EL)
size583drivers/net/dgrs_driver.camt = mymin(len, rbdp->size - count);
size102drivers/net/dgrs_i82596.hushort      size;  /* Size of buf (constant) */
size105drivers/net/dgrs_i82596.hulong      size;  /* Size of buf (constant) */
size131drivers/net/dgrs_i82596.hushort      size;  /* Size of RFD buffer: always 0 */
size203drivers/net/ni52.cstatic int     check586(struct device *dev,char *where,unsigned size);
size281drivers/net/ni52.cstatic int check586(struct device *dev,char *where,unsigned size)
size288drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
size289drivers/net/ni52.cp->memtop = where + size;
size411drivers/net/ni52.cint i,size;
size428drivers/net/ni52.csize = dev->mem_end - dev->mem_start;
size429drivers/net/ni52.cif(size != 0x2000 && size != 0x4000)
size431drivers/net/ni52.cprintk("\n%s: Illegal memory size %d. Allowed is 0x2000 or 0x4000 bytes.\n",dev->name,size);
size434drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size))
size436drivers/net/ni52.cprintk("?memcheck, Can't find memory at 0x%lx with size %d!\n",dev->mem_start,size);
size442drivers/net/ni52.csize = 0x4000; /* check for 16K mem */
size443drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size444drivers/net/ni52.csize = 0x2000; /* check for 8K mem */
size445drivers/net/ni52.cif(!check586(dev,(char *) dev->mem_start,size)) {
size462drivers/net/ni52.csize = 0x2000; /* check for 8K mem */
size463drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 8K-check */
size465drivers/net/ni52.csize = 0x4000; /* check for 16K mem */
size466drivers/net/ni52.cif(check586(dev,(char *)dev->mem_start,size)) /* 16K-check */
size470drivers/net/ni52.cdev->mem_end = dev->mem_start + size; /* set mem_end showed by 'ifconfig' */
size482drivers/net/ni52.c((struct priv *) (dev->priv))->memtop = (char *) dev->mem_start + size;
size483drivers/net/ni52.c((struct priv *) (dev->priv))->base =  dev->mem_start + size - 0x01000000;
size487drivers/net/ni52.cif(size == 0x2000)
size492drivers/net/ni52.cprintk("Memaddr: 0x%lx, Memsize: %d, ",dev->mem_start,size);
size794drivers/net/ni52.crbd[i].size = RECV_BUFF_SIZE;
size1193drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1220drivers/net/ni52.cp->xmit_buffs[0]->size = TBD_LAST | len;
size1232drivers/net/ni52.cp->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
size159drivers/net/ni52.hunsigned short size;    /* size of this buffer */
size301drivers/net/ni52.hunsigned short size;    /* size + EOF-Flag(15) */
size494drivers/net/ppp.cppp_alloc_buf (int size, int type)
size498drivers/net/ppp.cbuf = (struct ppp_buffer *) kmalloc (size + sizeof (struct ppp_buffer),
size502drivers/net/ppp.cbuf->size   = size - 1;  /* Mask for the buffer size */
size621drivers/net/ppp.cppp->rbuf->size -= 80;  /* reserve space for vj header expansion */
size1166drivers/net/ppp.cif (buf->count < buf->size) {
size1294drivers/net/ppp.ccurrent_idx &= ppp->ubuf->size;       \
size1684drivers/net/ppp.cppp->ubuf->tail &= ppp->ubuf->size;    \
size1782drivers/net/ppp.cppp->ubuf->tail &= ppp->ubuf->size;
size1794drivers/net/ppp.cppp->ubuf->tail &= ppp->ubuf->size;
size2554drivers/net/ppp.ccount += (ppp->ubuf->size + 1);
size641drivers/net/sdla.cshort             size;
size691drivers/net/sdla.csize = sizeof(addr);
size692drivers/net/sdla.cret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, NULL, skb->len, &addr, &size);
size1101drivers/net/sdla.cshort             size;
size1182drivers/net/sdla.csize = sizeof(data);
size1183drivers/net/sdla.cif (sdla_cmd(dev, SDLA_READ_DLCI_CONFIGURATION, 0, 0, NULL, 0, &data, &size) != SDLA_RET_OK)
size330drivers/net/sk_g16.c#define check_region(ioaddr, size)              0
size331drivers/net/sk_g16.c#define request_region(ioaddr, size,name)       do ; while (0)
size144drivers/net/tulip.c#define  ROUND_UP(size, n)  ((size + n - 1) & ~(n - 1))
size2120drivers/net/wavelan.cint    size;
size2127drivers/net/wavelan.csize = sprintf(buffer, "%s", "Iface |  dce    +nwid    -nwid  lvl slnc qual ntxq nrst\n");
size2129drivers/net/wavelan.cpos += size;
size2130drivers/net/wavelan.clen += size;
size2141drivers/net/wavelan.csize = sprintf_stats(buffer + len, lp->dev);
size2143drivers/net/wavelan.clen += size;
size580drivers/pci/pci.cstatic int sprint_dev_config(struct pci_dev *dev, char *buf, int size)
size600drivers/pci/pci.cif (len + 80 > size) {
size606drivers/pci/pci.cif (len + 80 > size) {
size625drivers/pci/pci.cif (len + strlen(str) > size) {
size632drivers/pci/pci.cif (len + strlen(fast_b2b_capable) > size) {
size641drivers/pci/pci.cif (len + strlen(BIST_capable) > size) {
size649drivers/pci/pci.cif (len + 40 > size) {
size656drivers/pci/pci.cif (len + 80 > size) {
size671drivers/pci/pci.cif (len + 40 > size) {
size723drivers/pci/pci.cint nprinted, len, size;
size728drivers/pci/pci.csize  = PAGE_SIZE - (strlen(MSG) + 1);
size732drivers/pci/pci.cnprinted = sprint_dev_config(dev, buf + len, size - len);
size746drivers/pci/pci.cstatic void *pci_malloc(long size, unsigned long *mem_startp)
size751drivers/pci/pci.cprintk("...pci_malloc(size=%ld,mem=%p)", size, *mem_startp);
size754drivers/pci/pci.c*mem_startp += (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
size755drivers/pci/pci.cmemset(mem, 0, size);
size276drivers/scsi/53c7,8xx.cstatic int check_address (unsigned long addr, int size);
size1200drivers/scsi/53c7,8xx.cint script_len = 0, dsa_len = 0, size = 0, max_cmd_size = 0, 
size1270drivers/scsi/53c7,8xx.csize = sizeof(struct NCR53c7x0_hostdata) + script_len + 
size1279drivers/scsi/53c7,8xx.cinstance = scsi_register (tpnt, size);
size1289drivers/scsi/53c7,8xx.chostdata->size = size;
size1349drivers/scsi/53c7,8xx.chostdata->free->size = max_cmd_size;
size2904drivers/scsi/53c7,8xx.cint size;
size2908drivers/scsi/53c7,8xx.csize = print_insn (host, (u32 *) 
size2910drivers/scsi/53c7,8xx.csize = print_insn (host, (u32 *) 
size2911drivers/scsi/53c7,8xx.cbus_to_virt(cmd->saved_data_pointer) + size, "", 1);
size2945drivers/scsi/53c7,8xx.cint size;
size2953drivers/scsi/53c7,8xx.csize = print_insn (host, (u32 *) bus_to_virt(dsp[1]), "", 1);
size2954drivers/scsi/53c7,8xx.cprint_insn (host, (u32 *) bus_to_virt(dsp[1]) + size, "", 1);
size3422drivers/scsi/53c7,8xx.cint size;      /* Size of *tmp */
size3455drivers/scsi/53c7,8xx.csize = hostdata->max_cmd_size + sizeof (void *);
size3457drivers/scsi/53c7,8xx.creal = kmalloc (size, GFP_ATOMIC);
size3461drivers/scsi/53c7,8xx.chost->host_no, size);
size3466drivers/scsi/53c7,8xx.ctmp->size = size;      
size5356drivers/scsi/53c7,8xx.cint size;
size5371drivers/scsi/53c7,8xx.csize = 0;
size5386drivers/scsi/53c7,8xx.csize = 3;
size5389drivers/scsi/53c7,8xx.csize = 2;
size5401drivers/scsi/53c7,8xx.creturn size;
size5783drivers/scsi/53c7,8xx.cint size;
size5787drivers/scsi/53c7,8xx.csize = print_insn (cmd->host, 
size5790drivers/scsi/53c7,8xx.cbus_to_virt(ncmd->saved_data_pointer) + size * sizeof(u32),
size5961drivers/scsi/53c7,8xx.cint i, size;
size5996drivers/scsi/53c7,8xx.cfor (i = 6; i > 0; --i, dsp += size)
size5997drivers/scsi/53c7,8xx.csize = print_insn (host, dsp, "", 1);
size6354drivers/scsi/53c7,8xx.ccheck_address (unsigned long addr, int size) {
size6355drivers/scsi/53c7,8xx.creturn (MAP_NR(addr) < 1 || MAP_NR(addr + size) > MAP_NR(high_memory) ?
size6390drivers/scsi/53c7,8xx.ccmd->free ((void *) cmd->real, cmd->size);
size1091drivers/scsi/53c7,8xx.hint size;        /* scsi_malloc'd size of this 
size1204drivers/scsi/53c7,8xx.hint size;        /* Size of entire Scsi_Host
size749drivers/scsi/NCR53c406a.cint size;
size753drivers/scsi/NCR53c406a.csize = disk->capacity;
size756drivers/scsi/NCR53c406a.cinfo_array[2] = size>>11;   /* cylinders */
size760drivers/scsi/NCR53c406a.cinfo_array[2] = size / (255*63);
size1208drivers/scsi/aha152x.cint size = disk->capacity;
size1212drivers/scsi/aha152x.cprintk("aha152x_biosparam: dev=%s, size=%d, ", kdevname(dev), size);
size1219drivers/scsi/aha152x.cinfo_array[2]=size>>11;
size1298drivers/scsi/aha1542.cint size = disk->capacity;
size1302drivers/scsi/aha1542.cif((size>>11) > 1024 && translation_algorithm == 2) {
size1306drivers/scsi/aha1542.cip[2] = size /255/63;
size1310drivers/scsi/aha1542.cip[2] = size >> 11;
size510drivers/scsi/aha1740.cint size = disk->capacity;
size514drivers/scsi/aha1740.cip[2] = size >> 11;
size82drivers/scsi/aic7xxx_asm.cMalloc(size_t size)
size84drivers/scsi/aic7xxx_asm.cvoid *p = malloc(size);
size91drivers/scsi/aic7xxx_asm.cRealloc(void *ptr, size_t size)
size93drivers/scsi/aic7xxx_asm.cvoid *p = realloc(ptr, size);
size30drivers/scsi/aic7xxx_proc.c#define BLS buffer + len + size
size81drivers/scsi/aic7xxx_proc.cint   size = 0;
size113drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Can't find adapter for host number %d\n", hostno);
size114drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
size130drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Adaptec AIC7xxx driver version: ");
size131drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%s/", rcs_version(AIC7XXX_C_VERSION));
size132drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%s/", rcs_version(AIC7XXX_H_VERSION));
size133drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%s\n", rcs_version(AIC7XXX_SEQ_VER));
size134drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
size136drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "\n");
size137drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Compile Options:\n");
size139drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_RESET_DELAY    : %d\n", AIC7XXX_RESET_DELAY);
size142drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_CMDS_PER_LUN   : %d\n", AIC7XXX_CMDS_PER_LUN);
size145drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_TWIN_SUPPORT   : Enabled\n");
size147drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_TWIN_SUPPORT   : Disabled\n");
size150drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_TAGGED_QUEUEING: Enabled\n");
size152drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_TAGGED_QUEUEING: Disabled\n");
size155drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_SHARE_IRQS     : Enabled\n");
size157drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_SHARE_IRQS     : Disabled\n");
size160drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_PROC_STATS     : Enabled\n");
size162drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  AIC7XXX_PROC_STATS     : Disabled\n");
size164drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
size166drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "\n");
size167drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Adapter Configuration:\n");
size168drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "          SCSI Adapter: %s\n", board_names[p->type]);
size169drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "                        (%s chipset)\n",
size171drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "              Host Bus: %s\n", bus_names[p->bus_type]);
size172drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "               Base IO: %#.4x\n", p->base);
size173drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "                   IRQ: %d\n", HBAptr->irq);
size174drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "                   SCB: %d (%d)\n", p->numscb, p->maxscb);
size175drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "            Interrupts: %d", p->isr_count);
size178drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, " %s\n",
size183drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "\n");
size185drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "         Serial EEPROM: %s\n",
size187drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "  Extended Translation: %sabled\n",
size189drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "        SCSI Bus Reset: %sabled\n",
size191drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "            Ultra SCSI: %sabled\n",
size193drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "     Target Disconnect: %sabled\n",
size195drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
size205drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "\n");
size206drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Statistics:\n");
size218drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "CHAN#%c (TGT %d LUN %d):\n",
size220drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "nxfers %ld (%ld read;%ld written)\n",
size222drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "blks(512) rd=%ld; blks(512) wr=%ld\n",
size224drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%s\n", HDRB);
size225drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, " Reads:");
size226drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[0],
size228drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[4],
size230drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->r_bins[8],
size232drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "Writes:");
size233drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[0],
size235drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[4],
size237drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->w_bins[8],
size239drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "\n");
size243drivers/scsi/aic7xxx_proc.clen += size; pos = begin + len; size = 0;
size277drivers/scsi/dtc.cint size = disk->capacity;
size281drivers/scsi/dtc.cip[2] = size >> 11;
size849drivers/scsi/eata_dma.culong size = 0;
size946drivers/scsi/eata_dma.csize = sizeof(hostdata) + ((sizeof(struct eata_ccb) + sizeof(long)) 
size949drivers/scsi/eata_dma.cDBG(DBG_REGISTER, printk("scsi_register size: %ld\n", size));
size951drivers/scsi/eata_dma.csh = scsi_register(tpnt, size);
size90drivers/scsi/eata_dma_proc.cint    size, len = 0;
size120drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len, "EATA (Extended Attachment) driver version: "
size122drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
size123drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "queued commands:     %10ld\n"
size125drivers/scsi/eata_dma_proc.clen += size; pos = begin + len;
size127drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "\nscsi%-2d: HBA %.10s\n",
size129drivers/scsi/eata_dma_proc.clen += size; 
size131drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Firmware revision: v%s\n", 
size133drivers/scsi/eata_dma_proc.clen += size;
size135drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Hardware Configuration:\n");
size136drivers/scsi/eata_dma_proc.clen += size; 
size141drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
size143drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
size144drivers/scsi/eata_dma_proc.clen += size; 
size147drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
size148drivers/scsi/eata_dma_proc.clen += size; 
size151drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: EISA\n"); 
size152drivers/scsi/eata_dma_proc.clen += size; 
size196drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "IRQ: %2d, %s triggered\n", cc->interrupt,
size198drivers/scsi/eata_dma_proc.clen += size; 
size201drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: BUSMASTER\n");
size203drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "DMA: %d\n", HBA_ptr->dma_channel);
size204drivers/scsi/eata_dma_proc.clen += size; 
size206drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "CPU: MC680%02d %dMHz\n", bt->cpu_type,
size208drivers/scsi/eata_dma_proc.clen += size; 
size210drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
size211drivers/scsi/eata_dma_proc.clen += size; 
size213drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Bus: %s\n", 
size217drivers/scsi/eata_dma_proc.clen += size; 
size219drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI Bus:%s%s Speed: %sMB/sec. %s\n",
size224drivers/scsi/eata_dma_proc.clen += size; 
size226drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SCSI channel expansion Module: %s present\n",
size229drivers/scsi/eata_dma_proc.clen += size; 
size231drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartRAID hardware: %spresent.\n",
size233drivers/scsi/eata_dma_proc.clen += size; 
size235drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
size241drivers/scsi/eata_dma_proc.clen += size; 
size244drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max array groups:              %d\n",
size246drivers/scsi/eata_dma_proc.clen += size; 
size248drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 0 array:   %d\n",
size250drivers/scsi/eata_dma_proc.clen += size; 
size252drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Max drives per RAID 3/5 array: %d\n",
size254drivers/scsi/eata_dma_proc.clen += size; 
size256drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Cache Module: %spresent.\n",
size258drivers/scsi/eata_dma_proc.clen += size; 
size260drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Type: %s\n",
size266drivers/scsi/eata_dma_proc.clen += size; 
size269drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "    Bank%d: %dMB with%s ECC\n",x,
size272drivers/scsi/eata_dma_proc.clen += size; 
size275drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Timer Mod.: %spresent\n",
size277drivers/scsi/eata_dma_proc.clen += size; 
size279drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "NVRAM     : %spresent\n",
size281drivers/scsi/eata_dma_proc.clen += size; 
size283drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "SmartROM  : %sabled\n",
size285drivers/scsi/eata_dma_proc.clen += size; 
size287drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Alarm     : %s\n",
size289drivers/scsi/eata_dma_proc.clen += size; 
size334drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host<->Disk command statistics:\n"
size336drivers/scsi/eata_dma_proc.clen += size; 
size339drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u\n", 1 << x,
size342drivers/scsi/eata_dma_proc.clen += size; 
size345drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u\n",
size348drivers/scsi/eata_dma_proc.clen += size; 
size350drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Sum   :%12u %12u\n",
size353drivers/scsi/eata_dma_proc.clen += size; 
size365drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Host Latency Command Statistics:\n"
size368drivers/scsi/eata_dma_proc.clen += size; 
size371drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
size380drivers/scsi/eata_dma_proc.clen += size; 
size383drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
size391drivers/scsi/eata_dma_proc.clen += size; 
size401drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len,
size403drivers/scsi/eata_dma_proc.clen += size; 
size406drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"%5dk:%12u %12u %12u %12u\n", 
size415drivers/scsi/eata_dma_proc.clen += size; 
size418drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,">1024k:%12u %12u %12u %12u\n",
size426drivers/scsi/eata_dma_proc.clen += size; 
size440drivers/scsi/eata_dma_proc.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
size441drivers/scsi/eata_dma_proc.clen += size; 
size446drivers/scsi/eata_dma_proc.cproc_print_scsidevice(scd, buffer, &size, len);
size447drivers/scsi/eata_dma_proc.clen += size; 
size678drivers/scsi/eata_pio.culong size = 0;
size729drivers/scsi/eata_pio.csize = sizeof(hostdata) + (sizeof(struct eata_ccb) * ntohs(gc->queuesiz));
size731drivers/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; 
size1099drivers/scsi/fdomain.cunsigned long blocks, size, capacity;
size1103drivers/scsi/fdomain.csize = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
size1104drivers/scsi/fdomain.ccapacity = +( +(blocks / 1024L) * +(size * 10L)) / 1024L;
size1107drivers/scsi/fdomain.c((capacity + 5L) / 10L), size );
size1922drivers/scsi/fdomain.cint        size      = disk->capacity;
size2055drivers/scsi/fdomain.cif ((unsigned int)size >= 0x7e0000U) {
size2058drivers/scsi/fdomain.c} else if ((unsigned int)size >= 0x200000U) {
size2067drivers/scsi/fdomain.cinfo_array[2] = (unsigned int)size / (info_array[0] * info_array[1] );
size320drivers/scsi/g_NCR5380.cint size = disk->capacity;
size323drivers/scsi/g_NCR5380.cip[2] = size >> 11;
size326drivers/scsi/hosts.hextern void * scsi_init_malloc(unsigned int size, int priority);
size327drivers/scsi/hosts.hextern void scsi_init_free(char * ptr, unsigned int size);
size426drivers/scsi/in2000.cint timeout, size, loop;
size458drivers/scsi/in2000.csize = SCpnt->cmd_len;  /* CDB length */ 
size519drivers/scsi/in2000.cfor ( loop=0; loop < size; loop++ )
size697drivers/scsi/in2000.cint size = disk->capacity;
size701drivers/scsi/in2000.ciinfo[2] = size >> 11;
size480drivers/scsi/pas16.cint size = disk->capacity;
size483drivers/scsi/pas16.cip[2] = size >> 11;    /* I think I have it as /(32*64) */
size487drivers/scsi/pas16.cip[2]=size/(63*255);
size2367drivers/scsi/scsi.cvoid * scsi_init_malloc(unsigned int size, int priority)
size2375drivers/scsi/scsi.cif ((size % PAGE_SIZE) == 0) {
size2378drivers/scsi/scsi.ca_size < size; order++, a_size <<= 1)
size2383drivers/scsi/scsi.cretval = kmalloc(size, priority);
size2386drivers/scsi/scsi.cmemset(retval, 0, size);
size2391drivers/scsi/scsi.cvoid scsi_init_free(char * ptr, unsigned int size)
size2398drivers/scsi/scsi.cif ((size % PAGE_SIZE) == 0) {
size2402drivers/scsi/scsi.ca_size < size; order++, a_size <<= 1)
size2584drivers/scsi/scsi.cint    size, len = 0;
size2592drivers/scsi/scsi.csize = sprintf(buffer+len,"Attached devices: %s\n", (scd)?"":"none");
size2593drivers/scsi/scsi.clen += size; 
size2597drivers/scsi/scsi.csize += sprintf(buffer+len,"scsi%2d: %s\n", (int) HBA_ptr->host_no, 
size2599drivers/scsi/scsi.clen += size; 
size2605drivers/scsi/scsi.cproc_print_scsidevice(scd, buffer, &size, len);
size2606drivers/scsi/scsi.clen += size; 
size2755drivers/scsi/scsi.cunsigned long size;
size2830drivers/scsi/scsi.csize = (new_dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
size2831drivers/scsi/scsi.cnew_dma_malloc_freelist = (FreeSectorBitmap *) scsi_init_malloc(size, GFP_ATOMIC);
size2832drivers/scsi/scsi.cmemset(new_dma_malloc_freelist, 0, size);
size2834drivers/scsi/scsi.csize = (new_dma_sectors / SECTORS_PER_PAGE)*sizeof(*new_dma_malloc_pages);
size2835drivers/scsi/scsi.cnew_dma_malloc_pages = (unsigned char **) scsi_init_malloc(size, GFP_ATOMIC);
size2836drivers/scsi/scsi.cmemset(new_dma_malloc_pages, 0, size);
size2855drivers/scsi/scsi.csize = (dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
size2856drivers/scsi/scsi.cmemcpy(new_dma_malloc_freelist, dma_malloc_freelist, size);
size2857drivers/scsi/scsi.cscsi_init_free((char *) dma_malloc_freelist, size);
size2863drivers/scsi/scsi.csize = (dma_sectors / SECTORS_PER_PAGE)*sizeof(*dma_malloc_pages);
size2864drivers/scsi/scsi.cmemcpy(new_dma_malloc_pages, dma_malloc_pages, size);
size2865drivers/scsi/scsi.cscsi_init_free((char *) dma_malloc_pages, size);
size3348drivers/scsi/scsi.cunsigned long size;
size3374drivers/scsi/scsi.csize = (dma_sectors / SECTORS_PER_PAGE)*sizeof(FreeSectorBitmap);
size3375drivers/scsi/scsi.cdma_malloc_freelist = (unsigned char *) scsi_init_malloc(size, GFP_ATOMIC);
size3376drivers/scsi/scsi.cmemset(dma_malloc_freelist, 0, size);
size589drivers/scsi/scsi_debug.cint size = disk->capacity;
size592drivers/scsi/scsi_debug.cinfo[2] = (size + 2047) >> 11;
size257drivers/scsi/scsi_proc.cvoid proc_print_scsidevice(Scsi_Device *scd, char *buffer, int *size, int len)
size259drivers/scsi/scsi_proc.cint x, y = *size;
size296drivers/scsi/scsi_proc.c*size = y; 
size51drivers/scsi/scsicam.cint size = disk->capacity;
size59drivers/scsi/scsicam.cret_code = partsize (bh, (unsigned long) size, (unsigned int *) ip + 2, 
size67drivers/scsi/scsicam.cret_code = setsize ((unsigned long) size, (unsigned int *) ip + 2, 
size64drivers/scsi/sg.cstatic void sg_free(char *buff,int size);
size161drivers/scsi/sg.cstatic char *sg_malloc(int size)
size163drivers/scsi/sg.cif (size<=4096)
size164drivers/scsi/sg.creturn (char *) scsi_malloc(size);
size166drivers/scsi/sg.cif (size<=SG_BIG_BUFF)
size181drivers/scsi/sg.cstatic void sg_free(char *buff,int size) 
size191drivers/scsi/sg.cscsi_free(buff,size);
size297drivers/scsi/sg.cint        bsize,size,amt,i;
size346drivers/scsi/sg.csize=COMMAND_SIZE(opcode);
size347drivers/scsi/sg.cif (opcode >= 0xc0 && device->header.twelve_byte) size = 12;
size352drivers/scsi/sg.cinput_size = device->header.pack_len - size;
size419drivers/scsi/sg.cSCpnt->cmd_len = size;
size424drivers/scsi/sg.cmemcpy_fromfs(cmnd,buf,size);
size425drivers/scsi/sg.cbuf+=size;
size303drivers/scsi/t128.cint size = disk->capacity;
size306drivers/scsi/t128.cip[2] = size >> 11;
size855drivers/scsi/u14-34f.cint size = disk->capacity;
size859drivers/scsi/u14-34f.cdkinfo[2] = size / (HD(j)->heads * HD(j)->sectors);
size1015drivers/scsi/ultrastor.cint size = disk->capacity;
size1020drivers/scsi/ultrastor.cdkinfo[2] = size / s;  /* Ignore partial cylinders */
size1224drivers/scsi/wd7000.cint size = disk->capacity;
size1227drivers/scsi/wd7000.cip[2] = size >> 11;
size1031drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
size1140drivers/sound/dmabuf.c*size = dmap->fragment_size;
size1744drivers/sound/dmabuf.cDMAbuf_getwrbuffer (int dev, char **buf, int *size, int dontblock)
size240drivers/sound/pss.cpss_download_boot (pss_config * devc, unsigned char *block, int size, int flags)
size275drivers/sound/pss.cif (count >= size && flags & CPF_LAST)
size280drivers/sound/pss.ccount, size);
size7drivers/sound/sound_calls.hint DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock);
size237drivers/sound/soundcard.cunsigned long   size;
size297drivers/sound/soundcard.csize = vma_get_end (vma) - vma_get_start (vma);
size299drivers/sound/soundcard.cif (size != dmap->bytes_in_use)
size302drivers/sound/soundcard.csize, dmap->bytes_in_use);
size648drivers/sound/soundcard.cint             sz, size;
size650drivers/sound/soundcard.cfor (sz = 0, size = PAGE_SIZE;
size651drivers/sound/soundcard.csize < audio_devs[dev]->buffsize;
size652drivers/sound/soundcard.csz++, size <<= 1);
size708drivers/sound/soundcard.cint             sz, size, i;
size711drivers/sound/soundcard.cfor (sz = 0, size = PAGE_SIZE;
size712drivers/sound/soundcard.csize < audio_devs[dev]->buffsize;
size713drivers/sound/soundcard.csz++, size <<= 1);
size438drivers/sound/sscape.csscape_download_boot (struct sscape_info *devc, unsigned char *block, int size, int flag)
size484drivers/sound/sscape.cmemcpy (audio_devs[devc->my_audiodev]->dmap_out->raw_buf, block, size);
size491drivers/sound/sscape.csize, DMA_MODE_WRITE);
size944fs/binfmt_elf.csize_t size;
size965fs/binfmt_elf.csize = 0;
size971fs/binfmt_elf.cif (size+sz >= limit)
size974fs/binfmt_elf.csize += sz;
size980fs/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;
size46fs/buffer.cstatic int grow_buffers(int pri, int size);
size47fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size);
size463fs/buffer.cstatic inline struct buffer_head * find_buffer(kdev_t dev, int block, int size)
size469fs/buffer.cif (tmp->b_size == size)
size486fs/buffer.cstruct buffer_head * get_hash_table(kdev_t dev, int block, int size)
size491fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
size496fs/buffer.c&& bh->b_size == size)
size502fs/buffer.cvoid set_blocksize(kdev_t dev, int size)
size510fs/buffer.cif (size > PAGE_SIZE)
size511fs/buffer.csize = 0;
size513fs/buffer.cswitch (size) {
size518fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
size519fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size522fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
size525fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
size537fs/buffer.cif (bh->b_size == size)
size541fs/buffer.cif (bh->b_dev == dev && bh->b_size != size) {
size554fs/buffer.cvoid refill_freelist(int size)
size559fs/buffer.cint isize = BUFSIZE_INDEX(size);
size576fs/buffer.cneeded =bdf_prm.b_un.nrefill * size;  
size579fs/buffer.cgrow_buffers(GFP_BUFFER, size)) {
size588fs/buffer.cwhile(maybe_shrink_lav_buffers(size))
size590fs/buffer.cif(!grow_buffers(GFP_BUFFER, size)) break;
size622fs/buffer.cif (bh->b_count || buffer_protected(bh) || bh->b_size != size)
size662fs/buffer.cif (bh->b_count || bh->b_size != size)
size696fs/buffer.cif (bh->b_count || buffer_protected(bh) || bh->b_size != size)
size725fs/buffer.cif (grow_buffers(GFP_BUFFER, size)) {
size732fs/buffer.cif (!grow_buffers(GFP_ATOMIC, size))
size748fs/buffer.cstruct buffer_head * getblk(kdev_t dev, int block, int size)
size751fs/buffer.cint isize = BUFSIZE_INDEX(size);
size760fs/buffer.cbh = get_hash_table(dev, block, size);
size771fs/buffer.cwhile(!free_list[isize]) refill_freelist(size);
size773fs/buffer.cif (find_buffer(dev,block,size))
size883fs/buffer.cstruct buffer_head * bread(kdev_t dev, int block, int size)
size887fs/buffer.cif (!(bh = getblk(dev, block, size))) {
size1064fs/buffer.cstatic struct buffer_head * create_buffers(unsigned long page, unsigned long size)
size1071fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
size1078fs/buffer.cbh->b_size = size;
size1135fs/buffer.cint brw_page(int rw, unsigned long address, kdev_t dev, int b[], int size, int bmap)
size1150fs/buffer.cbh = create_buffers(address, size);
size1176fs/buffer.cmemset(next->b_data, 0, size);
size1180fs/buffer.ctmp = get_hash_table(dev, block, size);
size1188fs/buffer.cmemcpy(next->b_data, tmp->b_data, size);
size1190fs/buffer.cmemcpy(tmp->b_data, next->b_data, size);
size1322fs/buffer.cstatic int grow_buffers(int pri, int size)
size1329fs/buffer.cif ((size & 511) || (size > PAGE_SIZE)) {
size1330fs/buffer.cprintk("VFS: grow_buffers: size = %d\n",size);
size1334fs/buffer.cisize = BUFSIZE_INDEX(size);
size1338fs/buffer.cbh = create_buffers(page, size);
size1463fs/buffer.cstatic int maybe_shrink_lav_buffers(int size)
size1486fs/buffer.cisize = (size ? BUFSIZE_INDEX(size) : -1);
size1513fs/buffer.cstatic int shrink_specific_buffers(unsigned int priority, int size)
size1520fs/buffer.cif(size) printk("Shrinking buffers of size %d\n", size);
size1524fs/buffer.cisize1 = (size ? BUFSIZE_INDEX(size) : -1);
size1564fs/buffer.cif(size && bh->b_size != size) continue;
size1701fs/buffer.cunsigned int starting_block, int size)
size1704fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1711fs/buffer.cwhile(nr_free[isize] < 32) refill_freelist(size);
size1727fs/buffer.cstatic unsigned long try_to_generate_cluster(kdev_t dev, int block, int size)
size1730fs/buffer.cint isize = BUFSIZE_INDEX(size);
size1738fs/buffer.cbh = create_buffers(page, size);
size1744fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
size1745fs/buffer.cif (find_buffer(dev, nblock++, size))
size1781fs/buffer.cunsigned long generate_cluster(kdev_t dev, int b[], int size)
size1785fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
size1787fs/buffer.cif(find_buffer(dev, b[i], size)) return 0;
size1794fs/buffer.cif(maybe_shrink_lav_buffers(size))
size1797fs/buffer.cretval = try_to_generate_cluster(dev, b[0], size);
size1802fs/buffer.creturn try_to_generate_cluster(dev, b[0], size);
size1804fs/buffer.creturn reassign_cluster(dev, b[0], size);
size83fs/ext/file.cunsigned int size;
size94fs/ext/file.csize = inode->i_size;
size95fs/ext/file.cif (offset > size)
size98fs/ext/file.cleft = size - offset;
size106fs/ext/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
size112fs/ext/file.cif (block + blocks > size)
size113fs/ext/file.cblocks = size - block;
size217fs/fat/file.cint size,offset;
size237fs/fat/file.csize = MIN(SECTOR_SIZE-offset,left_in_file);
size239fs/fat/file.csize = MIN(size,end-buf);
size240fs/fat/file.cmemcpy_tofs(buf,data,size);
size241fs/fat/file.cbuf += size;
size242fs/fat/file.cfilp->f_pos += size;
size244fs/fat/file.cfor (; size && buf < end; size--) {
size275fs/fat/file.cint sector,offset,size,left,written;
size300fs/fat/file.cfor (start = buf; count || carry; count -= size) {
size308fs/fat/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
size311fs/fat/file.c&& (size == SECTOR_SIZE
size312fs/fat/file.c|| filp->f_pos + size >= inode->i_size)){
size325fs/fat/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
size326fs/fat/file.cbuf += size;
size336fs/fat/file.cfor (size = 0; size < count && left; size++) {
size437fs/fat/inode.cinode->i_size = CF_LE_L(raw_entry->size);
size477fs/fat/inode.craw_entry->size = 0;
size481fs/fat/inode.craw_entry->size = CT_LE_L(inode->i_size);
size521fs/isofs/inode.cinode->i_size = isonum_733 (raw_inode->size);
size710fs/isofs/inode.cdirectory_size = isonum_733 (de->size);
size824fs/isofs/inode.cvoid * leak_check_malloc(unsigned int size){
size827fs/isofs/inode.ctmp = kmalloc(size, GFP_KERNEL);
size831fs/isofs/inode.cvoid leak_check_free_s(void * obj, int size){
size833fs/isofs/inode.creturn kfree_s(obj, size);
size836fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
size838fs/isofs/inode.creturn bread(dev, block, size);
size45fs/isofs/rock.ccont_size = isonum_733(rr->u.CE.size);}
size14fs/isofs/rock.hchar size[8];
size83fs/minix/dir.cint size = strnlen(de->name, info->s_namelen);
size84fs/minix/dir.cif (filldir(dirent, de->name, size, filp->f_pos, de->inode) < 0) {
size281fs/msdos/namei.cde->size = 0;
size65fs/ncpfs/ioctl.c|| (request.size >
size83fs/ncpfs/ioctl.cserver->current_size = request.size;
size84fs/ncpfs/ioctl.cmemcpy_fromfs(server->packet, request.data, request.size);
size56fs/ncpfs/ncplib_kernel.cncp_add_mem(struct ncp_server *server, const void *source, int size)
size59fs/ncpfs/ncplib_kernel.cmemcpy(&(server->packet[server->current_size]), source, size);
size60fs/ncpfs/ncplib_kernel.cserver->current_size += size;
size65fs/ncpfs/ncplib_kernel.cncp_add_mem_fromfs(struct ncp_server *server, const char *source, int size)
size68fs/ncpfs/ncplib_kernel.cmemcpy_fromfs(&(server->packet[server->current_size]), source, size);
size69fs/ncpfs/ncplib_kernel.cserver->current_size += size;
size134fs/ncpfs/ncplib_kernel.cint size, int *target)
size139fs/ncpfs/ncplib_kernel.cncp_add_word(server, htons(size));
size147fs/ncpfs/ncplib_kernel.c*target =min(ntohs(ncp_reply_word(server, 0)), size);
size26fs/ncpfs/ncplib_kernel.hncp_negotiate_buffersize(struct ncp_server *server, int size,
size31fs/ncpfs/sock.cint size, int noblock, unsigned flags,
size38fs/ncpfs/sock.ciov.iov_len  = size;
size48fs/ncpfs/sock.creturn sock->ops->recvmsg(sock, &msg, size, noblock, flags, addr_len);
size318fs/ncpfs/sock.cdo_ncp_rpc_call(struct ncp_server *server, int size)
size393fs/ncpfs/sock.cresult = _sendto(sock, (void *) start, size, 0, 0,
size556fs/ncpfs/sock.cncp_do_request(struct ncp_server *server, int size)
size571fs/ncpfs/sock.cresult = do_ncp_rpc_call(server, size);
size274fs/nfs/dir.cif (fattr->size == -1 || fattr->uid == -1 || fattr->gid == -1
size391fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size427fs/nfs/dir.csattr.size = rdev; /* get out your barf bag */
size429fs/nfs/dir.csattr.size = (unsigned) -1;
size456fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size573fs/nfs/dir.csattr.uid = sattr.gid = sattr.size = (unsigned) -1;
size671fs/nfs/dir.cif (inode->i_size != fattr->size)
size673fs/nfs/dir.cinode->i_size = fattr->size;
size66fs/nfs/inode.cint size = inode->i_sb->u.nfs_sb.s_server.wsize;
size68fs/nfs/inode.cif (rsize > size)
size69fs/nfs/inode.csize = rsize;
size70fs/nfs/inode.cinode->i_blksize = size;
size295fs/nfs/inode.csattr.size = (unsigned) -1;
size297fs/nfs/inode.csattr.size = S_ISREG(inode->i_mode) ? attr->ia_size : -1;
size567fs/nfs/nfsroot.cstatic inline int root_send_udp(struct socket *sock, void *buf, int size)
size577fs/nfs/nfsroot.ciov.iov_len = size;
size582fs/nfs/nfsroot.cresult = sock->ops->sendmsg(sock, &msg, size, 0, 0);
size584fs/nfs/nfsroot.creturn (result != size);
size591fs/nfs/nfsroot.cstatic inline int root_recv_udp(struct socket *sock, void *buf, int size)
size601fs/nfs/nfsroot.ciov.iov_len = size;
size607fs/nfs/nfsroot.cresult = sock->ops->recvmsg(sock, &msg, size, O_NONBLOCK, 0, &msg.msg_namelen);
size79fs/nfs/proc.cstatic inline int *nfs_rpc_alloc(int size)
size83fs/nfs/proc.cwhile (!(i = (int *)kmalloc(size+NFS_SLACK_SPACE,GFP_NFS))) {
size171fs/nfs/proc.cfattr->size = ntohl(*p++);
size191fs/nfs/proc.c*p++ = htonl(sattr->size);
size809fs/nfs/proc.cint size;
size813fs/nfs/proc.csize = server->rsize;
size820fs/nfs/proc.c*p++ = htonl(size);
size42fs/nfs/sock.cnfs_rpc_call(struct nfs_server *server, int *start, int *end, int size)
size46fs/nfs/sock.csize += 1024;    /* account for NFS slack space. ugly */
size57fs/nfs/sock.creq.rq_rvec[0].iov_len = size;
size58fs/nfs/sock.creq.rq_rlen = size;
size32fs/pipe.cint chars = 0, size = 0, read = 0;
size53fs/pipe.cwhile (count>0 && (size = PIPE_SIZE(*inode))) {
size57fs/pipe.cif (chars > size)
size58fs/pipe.cchars = size;
size365fs/proc/array.cint size = 0, result = 0;
size377fs/proc/array.cresult = size;
size378fs/proc/array.cif (size < PAGE_SIZE)
size379fs/proc/array.cbuffer[size++] = c;
size730fs/proc/array.cstatic inline void statm_pte_range(pmd_t * pmd, unsigned long address, unsigned long size,
size745fs/proc/array.cend = address + size;
size768fs/proc/array.cstatic inline void statm_pmd_range(pgd_t * pgd, unsigned long address, unsigned long size,
size783fs/proc/array.cend = address + size;
size806fs/proc/array.cint size=0, resident=0, share=0, trs=0, lrs=0, drs=0, dt=0;
size821fs/proc/array.csize += total;
size834fs/proc/array.csize, resident, share, trs, lrs, drs, dt);
size85fs/proc/inode.cif (de->size)
size86fs/proc/inode.cinode->i_size = de->size;
size173fs/read_write.cconst struct iovec * iov, long count, long size)
size191fs/read_write.creturn sock->ops->recvmsg(sock, &msg, size,
size196fs/read_write.creturn sock->ops->sendmsg(sock, &msg, size,
size787fs/smbfs/dir.centry.size  = 0;
size99fs/smbfs/inode.cinode->i_size    = SMB_INOP(inode)->finfo.size;
size583fs/smbfs/proc.centry->size   = DVAL(buf, smb_vwv4);
size929fs/smbfs/proc.centry->size = DVAL(p, 5);
size1082fs/smbfs/proc.cfinfo->size = DVAL(p,16);
size1097fs/smbfs/proc.cfinfo->size = DVAL(p,16);
size1121fs/smbfs/proc.cfinfo->size = DVAL(p,0);
size1411fs/smbfs/proc.centry->size         = DVAL(buf, smb_vwv3);
size1435fs/smbfs/proc.centry->size  = DVAL(buf, smb_vwv6);
size1463fs/smbfs/proc.centry->size  = temp_entry.size;
size27fs/smbfs/sock.cstatic int _recvfrom(struct socket *sock, unsigned char *ubuf, int size, int noblock, unsigned flags,
size34fs/smbfs/sock.ciov.iov_len  = size;
size44fs/smbfs/sock.creturn sock->ops->recvmsg(sock, &msg, size, noblock, flags, addr_len);
size85fs/sysv/file.cunsigned int size;
size96fs/sysv/file.csize = inode->i_size;
size97fs/sysv/file.cif (offset > size)
size100fs/sysv/file.cleft = size - offset;
size108fs/sysv/file.csize = (size + sb->sv_block_size_1) >> sb->sv_block_size_bits;
size113fs/sysv/file.cif (block + blocks > size)
size114fs/sysv/file.cblocks = size - block;
size208fs/umsdos/emd.cint size;  /* Current size of buffer */
size223fs/umsdos/emd.cint mustmove = buf->size - buf->pos;
size236fs/umsdos/emd.cif (ret == 0) buf->size = mustmove + mustread;    
size238fs/umsdos/emd.cbuf->size = mustmove;
size291fs/umsdos/emd.cbuf.size = 0;
size300fs/umsdos/emd.cint file_pos = buf.filp.f_pos - buf.size + buf.pos;
size301fs/umsdos/emd.cif (buf.pos == buf.size){
size331fs/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;
size886fs/vfat/namei.cde->size = 0;
size1060fs/vfat/namei.cde->size = 0;
size1463fs/vfat/namei.cnew_de->size = old_de->size;
size122include/asm-alpha/bitops.hextern inline unsigned long find_next_zero_bit(void * addr, unsigned long size, unsigned long offset)
size128include/asm-alpha/bitops.hif (offset >= size)
size129include/asm-alpha/bitops.hreturn size;
size130include/asm-alpha/bitops.hsize -= result;
size135include/asm-alpha/bitops.hif (size < 64)
size139include/asm-alpha/bitops.hsize -= 64;
size142include/asm-alpha/bitops.hwhile (size & ~63UL) {
size146include/asm-alpha/bitops.hsize -= 64;
size148include/asm-alpha/bitops.hif (!size)
size152include/asm-alpha/bitops.htmp |= ~0UL << size;
size160include/asm-alpha/bitops.h#define find_first_zero_bit(addr, size) \
size161include/asm-alpha/bitops.hfind_next_zero_bit((addr), (size), 0)
size28include/asm-alpha/floppy.h#define fd_cacheflush(addr,size) /* nothing */
size125include/asm-alpha/hwrpb.hunsigned long size;    /* size of hwrpb */
size39include/asm-alpha/ioctl.h#define _IOC(dir,type,nr,size)      \
size44include/asm-alpha/ioctl.h((size) << _IOC_SIZESHIFT)))
size48include/asm-alpha/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size49include/asm-alpha/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size50include/asm-alpha/ioctl.h#define _IOWR(type,nr,size)  _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
size32include/asm-alpha/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size35include/asm-alpha/segment.hswitch (size) {
size55include/asm-alpha/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size60include/asm-alpha/segment.hswitch (size) {
size39include/asm-alpha/system.hunsigned int  size;    /* size in bytes of logout area */
size160include/asm-alpha/system.hstatic __inline__ unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
size162include/asm-alpha/system.hswitch (size) {
size75include/asm-i386/bitops.hextern __inline__ int find_first_zero_bit(void * addr, unsigned size)
size79include/asm-i386/bitops.hif (!size)
size93include/asm-i386/bitops.h:"c" ((size + 31) >> 5), "D" (addr), "b" (addr)
size98include/asm-i386/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
size121include/asm-i386/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
size30include/asm-i386/floppy.h#define fd_cacheflush(addr,size) /* nothing */
size49include/asm-i386/ioctl.h#define _IOC(dir,type,nr,size) \
size53include/asm-i386/ioctl.h((size) << _IOC_SIZESHIFT))
size57include/asm-i386/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size58include/asm-i386/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size59include/asm-i386/ioctl.h#define _IOWR(type,nr,size)  _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
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) {
size679include/asm-i386/string-486.hextern inline void * memscan(void * addr, int c, size_t size)
size681include/asm-i386/string-486.hif (!size)
size688include/asm-i386/string-486.h: "=D" (addr), "=c" (size)
size689include/asm-i386/string-486.h: "0" (addr), "1" (size), "a" (c));
size614include/asm-i386/string.hextern inline void * memscan(void * addr, int c, size_t size)
size616include/asm-i386/string.hif (!size)
size623include/asm-i386/string.h: "=D" (addr), "=c" (size)
size624include/asm-i386/string.h: "0" (addr), "1" (size), "a" (c));
size197include/asm-i386/system.hstatic inline unsigned long __xchg(unsigned long x, void * ptr, int size)
size199include/asm-i386/system.hswitch (size) {
size279include/asm-i386/system.h#define set_ldt_desc(n,addr,size) \
size280include/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));
size54include/asm-mips/asm.h.size  symbol,_size
size57include/asm-mips/asm.h#define SIZE(symbol,size)
size152include/asm-mips/bitops.hextern __inline__ int find_first_zero_bit (void *addr, unsigned size)
size156include/asm-mips/bitops.hif (!size)
size178include/asm-mips/bitops.h"r" (size),
size186include/asm-mips/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
size217include/asm-mips/bitops.hres = find_first_zero_bit (p, size - 32 * (p - (unsigned long *) addr));
size208include/asm-mips/bootinfo.hunsigned long  size;
size33include/asm-mips/floppy.h#define fd_cacheflush(addr, size)  feature->fd_cacheflush((void *)addr, size)
size55include/asm-mips/ioctl.h#define _IOC(dir,type,nr,size) \
size59include/asm-mips/ioctl.h(((size) & _IOC_SLMASK) << _IOC_SIZESHIFT))
size63include/asm-mips/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size64include/asm-mips/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size65include/asm-mips/ioctl.h#define _IOWR(type,nr,size)  _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
size13include/asm-mips/jazzdma.hunsigned long vdma_alloc(unsigned long paddr, unsigned long size);
size15include/asm-mips/jazzdma.hint vdma_remap(unsigned long laddr, unsigned long paddr, unsigned long size);
size49include/asm-mips/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size52include/asm-mips/segment.hswitch (size) {
size72include/asm-mips/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size77include/asm-mips/segment.hswitch (size) {
size206include/asm-mips/string.hextern __inline__ void * memscan(void * addr, int c, size_t size)
size208include/asm-mips/string.hif (!size)
size220include/asm-mips/string.h: "=r" (addr), "=r" (size)
size221include/asm-mips/string.h: "0" (addr), "1" (size), "r" (c)
size195include/asm-mips/system.hstatic inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
size197include/asm-mips/system.hswitch (size) {
size40include/asm-mips/vector.hvoid (*fd_cacheflush)(unsigned char *addr, unsigned int size);
size34include/asm-ppc/ioctl.h#define _IOC(dir,type,nr,size) \
size38include/asm-ppc/ioctl.h((size) << _IOC_SIZESHIFT))
size42include/asm-ppc/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size43include/asm-ppc/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size44include/asm-ppc/ioctl.h#define _IOWR(type,nr,size)  _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
size11include/asm-ppc/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size13include/asm-ppc/segment.hswitch (size) {
size31include/asm-ppc/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size33include/asm-ppc/segment.hswitch (size) {
size50include/asm-ppc/system.hstatic inline unsigned long __xchg(unsigned long x, void * ptr, int size)
size52include/asm-ppc/system.hswitch (size) {
size90include/asm-sparc/bitops.hextern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
size96include/asm-sparc/bitops.hif (offset >= size)
size97include/asm-sparc/bitops.hreturn size;
size98include/asm-sparc/bitops.hsize -= result;
size103include/asm-sparc/bitops.hif (size < 32)
size107include/asm-sparc/bitops.hsize -= 32;
size110include/asm-sparc/bitops.hwhile (size & ~31UL) {
size114include/asm-sparc/bitops.hsize -= 32;
size116include/asm-sparc/bitops.hif (!size)
size121include/asm-sparc/bitops.htmp |= ~0UL >> size;
size130include/asm-sparc/bitops.h#define find_first_zero_bit(addr, size) \
size131include/asm-sparc/bitops.hfind_next_zero_bit((addr), (size), 0)
size173include/asm-sparc/bitops.h#define ext2_find_first_zero_bit(addr, size) \
size174include/asm-sparc/bitops.hext2_find_next_zero_bit((addr), (size), 0)
size176include/asm-sparc/bitops.hextern __inline__ unsigned long ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
size182include/asm-sparc/bitops.hif (offset >= size)
size183include/asm-sparc/bitops.hreturn size;
size184include/asm-sparc/bitops.hsize -= result;
size189include/asm-sparc/bitops.hif(size < 32)
size193include/asm-sparc/bitops.hsize -= 32;
size196include/asm-sparc/bitops.hwhile(size & ~31UL) {
size200include/asm-sparc/bitops.hsize -= 32;
size202include/asm-sparc/bitops.hif(!size)
size207include/asm-sparc/bitops.htmp |= ~0UL << size;
size103include/asm-sparc/fbio.hstruct fbcurpos size;   /* cursor bit map size */
size66include/asm-sparc/floppy.h#define fd_cacheflush(addr, size) /* nothing... */
size27include/asm-sparc/ioctl.h#define _IOC(dir,type,nr,size) \
size31include/asm-sparc/ioctl.h((size) << _IOC_SIZESHIFT))
size34include/asm-sparc/ioctl.h#define _IOR(type,nr,size)  _IOC(_IOC_READ,(type),(nr),sizeof(size))
size35include/asm-sparc/ioctl.h#define _IOW(type,nr,size)  _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
size36include/asm-sparc/ioctl.h#define _IORW(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
size39include/asm-sparc/openprom.hvoid (*v2_dumb_munmap)(char *virta, unsigned size);
size197include/asm-sparc/oplib.hextern char *prom_alloc(char *virt_hint, unsigned int size);
size200include/asm-sparc/oplib.hextern void prom_free(char *virt_addr, unsigned int size);
size68include/asm-sparc/pgtsun4c.hextern char *sun4c_lockarea(char *vaddr, unsigned long size);
size69include/asm-sparc/pgtsun4c.hextern void sun4c_unlockarea(char *vaddr, unsigned long size);
size25include/asm-sparc/segment.hstatic inline void __put_user(unsigned long x, void * y, int size)
size27include/asm-sparc/segment.hswitch (size) {
size43include/asm-sparc/segment.hstatic inline unsigned long __get_user(const void * y, int size)
size45include/asm-sparc/segment.hswitch (size) {
size125include/asm-sparc/system.hstatic inline unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
size127include/asm-sparc/system.hswitch (size) {
size438include/linux/cdk.hunsigned short  size;
size13include/linux/fd.hunsigned int  size,    /* nr of sectors total */
size552include/linux/fs.hextern void refill_freelist(int size);
size614include/linux/fs.hextern struct buffer_head * get_hash_table(kdev_t dev, int block, int size);
size615include/linux/fs.hextern struct buffer_head * getblk(kdev_t dev, int block, int size);
size632include/linux/fs.hextern void set_blocksize(kdev_t dev, int size);
size633include/linux/fs.hextern struct buffer_head * bread(kdev_t dev, int block, int size);
size634include/linux/fs.hextern struct buffer_head * breada(kdev_t dev,int block, int size, 
size643include/linux/fs.hunsigned long generate_cluster(kdev_t dev, int b[], int size);
size71include/linux/if_pppvar.h__s32    size;    /* Size of the buffer area  */
size501include/linux/isdn.hshort   size;                         /* Allocated size                   */
size110include/linux/iso_fs.hchar size      [ISODCL (11, 18)]; /* 733 */
size201include/linux/iso_fs.hextern void * leak_check_malloc(unsigned int size);
size202include/linux/iso_fs.hextern void leak_check_free_s(void * obj, int size);
size203include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
size28include/linux/loop.hchar *raw_buf, char *loop_buf, int size);
size38include/linux/loop.hchar *raw_buf, char *loop_buf, int size);
size6include/linux/malloc.hvoid * kmalloc(unsigned int size, int priority);
size94include/linux/md.hint size;      /* Device size (in blocks) */
size260include/linux/mm.hextern int zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size);
size262include/linux/mm.hextern int remap_page_range(unsigned long from, unsigned long to, unsigned long size, pgprot_t prot);
size263include/linux/mm.hextern int zeromap_page_range(unsigned long from, unsigned long size, pgprot_t prot);
size278include/linux/mm.hextern void * vmalloc(unsigned long size);
size279include/linux/mm.hextern void * vremap(unsigned long offset, unsigned long size);
size51include/linux/module.hint size; /* total, including string table!!! */
size66include/linux/module.hint size;      /* size of module in pages */
size124include/linux/msdos_fs.h__u32  size;    /* file size (in bytes) */
size25include/linux/ncp_fs.hunsigned int   size;
size87include/linux/ncp_fs.hncp_kmalloc(unsigned int size, int priority)
size91include/linux/ncp_fs.hreturn kmalloc(size, priority);
size95include/linux/ncp_fs.hncp_kfree_s(void *obj, int size)
size98include/linux/ncp_fs.hkfree_s(obj, size);
size135include/linux/nfs.hu_int size;
size150include/linux/nfs.hu_int size;
size107include/linux/nfs_fs.hint *end, int size);
size169include/linux/proc_fs.hunsigned long size;
size221include/linux/proc_fs.hextern void scsi_init_free(char *ptr, unsigned int size);
size9include/linux/raid0.hint size;      /* Zone size */
size37include/linux/raid0.hint size;      /* Zone size */
size62include/linux/shm.hasmlinkage int sys_shmget (key_t key, int size, int flag);
size150include/linux/skbuff.hextern struct sk_buff *    alloc_skb(unsigned int size, int priority);
size151include/linux/skbuff.hextern struct sk_buff *    dev_alloc_skb(unsigned int size);
size445include/linux/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
size446include/linux/skbuff.hextern void      skb_copy_datagram_iovec(struct sk_buff *from, int offset, struct iovec *to,int size);
size98include/linux/smb.hunsigned long   size;  /* File size. */
size61include/linux/smb_fs.hsmb_kmalloc(unsigned int size, int priority)
size65include/linux/smb_fs.hreturn kmalloc(size, priority);
size69include/linux/smb_fs.hsmb_kfree_s(void *obj, int size)
size72include/linux/smb_fs.hkfree_s(obj, size);
size619include/linux/soundcard.hint size;
size461include/net/sock.hunsigned long size, int force,
size464include/net/sock.hunsigned long size, int force,
size481include/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);
size23ipc/shm.cstatic int newseg (key_t key, int shmflg, int size);
size74ipc/shm.cstatic int newseg (key_t key, int shmflg, int size)
size77ipc/shm.cint numpages = (size + PAGE_SIZE -1) >> PAGE_SHIFT;
size80ipc/shm.cif (size < SHMMIN)
size116ipc/shm.cshp->shm_segsz = size;
size133ipc/shm.casmlinkage int sys_shmget (key_t key, int size, int shmflg)
size138ipc/shm.cif (size < 0 || size > SHMMAX)
size141ipc/shm.creturn newseg(key, shmflg, size);
size145ipc/shm.creturn newseg(key, shmflg, size);
size152ipc/shm.cif (size > shp->shm_segsz)
size101ipc/util.casmlinkage int sys_shmget (key_t key, int size, int flag)
size88kernel/module.csys_create_module(char *module_name, unsigned long size)
size99kernel/module.cif (module_name == NULL || size == 0)
size112kernel/module.cnpages = (size + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE;
size122kernel/module.cmp->size = npages;
size131kernel/module.cmp->name, (unsigned long) mp->size, (unsigned long) mp->addr));
size183kernel/module.cif ((codesize + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE > mp->size)
size187kernel/module.cmp->size * PAGE_SIZE - (codesize + sizeof (long)));
size196kernel/module.cint size;
size200kernel/module.cif ((error = verify_area(VERIFY_READ, &symtab->size, sizeof(symtab->size))))
size202kernel/module.csize = get_user(&symtab->size);
size204kernel/module.cif ((newtab = (struct symbol_table*) kmalloc(size, GFP_KERNEL)) == NULL) {
size208kernel/module.cif ((error = verify_area(VERIFY_READ, symtab, size))) {
size209kernel/module.ckfree_s(newtab, size);
size212kernel/module.cmemcpy_fromfs((char *)(newtab), symtab, size);
size219kernel/module.cif ((newtab->n_symbols < 0) || (newtab->n_refs < 0) || (legal_start > size)) {
size222kernel/module.ckfree_s(newtab, size);
size228kernel/module.cif ((unsigned long)sym->name < legal_start || size <= (unsigned long)sym->name) {
size230kernel/module.ckfree_s(newtab, size);
size471kernel/module.cif (mp->symtab->size)
size472kernel/module.ckfree_s(mp->symtab, mp->symtab->size);
size494kernel/module.cchar size[32];
size502kernel/module.cif (*q == '\0' && mp->size == 0 && mp->ref == NULL)
size509kernel/module.csprintf(size, "%d", mp->size);
size510kernel/module.ci -= strlen(size);
size515kernel/module.cq = size;
size542kernel/module.csprintf(size,"\t%ld%s",
size546kernel/module.cq = size;
size638kernel/module.cint size;
size703kernel/module.cif (oldtab->size > 0)
size704kernel/module.ckfree_s(oldtab, oldtab->size);
size719kernel/module.csize = SYMSIZ + intab->n_symbols * INTSIZ +
size730kernel/module.cnewtab->size = size;
size757kernel/module.cif (oldtab->size > 0)
size758kernel/module.ckfree_s(oldtab, oldtab->size);
size408kernel/sysctl.cde->size = 0;
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)
size768mm/filemap.cunsigned long size;
size770mm/filemap.csize = offset + PAGE_SIZE;
size773mm/filemap.cif (size > inode->i_size)
size774mm/filemap.csize = inode->i_size;
size776mm/filemap.cif (size < offset)
size779mm/filemap.csize -= offset;
size783mm/filemap.cif (size == file->f_op->write(inode, file, (const char *) page, size))
size911mm/filemap.cunsigned long address, unsigned long size, 
size928mm/filemap.cend = address + size;
size941mm/filemap.cunsigned long address, unsigned long size, 
size958mm/filemap.cend = address + size;
size971mm/filemap.csize_t size, unsigned int flags)
size974mm/filemap.cunsigned long end = address + size;
size978mm/filemap.cflush_cache_range(vma->vm_mm, end - size, end);
size984mm/filemap.cflush_tlb_range(vma->vm_mm, end - size, end);
size198mm/kmalloc.cvoid *kmalloc(size_t size, int priority)
size209mm/kmalloc.cunsigned int realsize = size + sizeof(struct block_header);
size217mm/kmalloc.cprintk("kmalloc of too large a block (%d bytes).\n", (int) size);
size299mm/kmalloc.csizes[order].nbytesmalloced += size;
size301mm/kmalloc.cp->bh_length = size;
size303mm/kmalloc.cmemset(p+1, 0xf0, size);
size325mm/kmalloc.cint size;
size350mm/kmalloc.csize = p->bh_length;
size353mm/kmalloc.cmemset(p+1, 0xe0, size);
size384mm/kmalloc.csizes[order].nbytesmalloced -= size;
size211mm/memory.cstatic inline int copy_pte_range(pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long address, unsigned long size, int cow)
size230mm/memory.cend = address + size;
size243mm/memory.cstatic inline int copy_pmd_range(pgd_t *dst_pgd, pgd_t *src_pgd, unsigned long address, unsigned long size, int cow)
size263mm/memory.cend = address + size;
size322mm/memory.cstatic inline void zap_pte_range(pmd_t * pmd, unsigned long address, unsigned long size)
size336mm/memory.cend = address + size;
size348mm/memory.cstatic inline void zap_pmd_range(pgd_t * dir, unsigned long address, unsigned long size)
size362mm/memory.cend = address + size;
size375mm/memory.cint zap_page_range(struct mm_struct *mm, unsigned long address, unsigned long size)
size378mm/memory.cunsigned long end = address + size;
size381mm/memory.cflush_cache_range(mm, end - size, end);
size387mm/memory.cflush_tlb_range(mm, end - size, end);
size391mm/memory.cstatic inline void zeromap_pte_range(pte_t * pte, unsigned long address, unsigned long size, pte_t zero_pte)
size396mm/memory.cend = address + size;
size408mm/memory.cstatic inline int zeromap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size, pte_t zero_pte)
size413mm/memory.cend = address + size;
size427mm/memory.cint zeromap_page_range(unsigned long address, unsigned long size, pgprot_t prot)
size432mm/memory.cunsigned long end = address + size;
size458mm/memory.cstatic inline void remap_pte_range(pte_t * pte, unsigned long address, unsigned long size,
size464mm/memory.cend = address + size;
size479mm/memory.cstatic inline int remap_pmd_range(pmd_t * pmd, unsigned long address, unsigned long size,
size485mm/memory.cend = address + size;
size500mm/memory.cint remap_page_range(unsigned long from, unsigned long offset, unsigned long size, pgprot_t prot)
size505mm/memory.cunsigned long end = from + size;
size671mm/memory.cint verify_area(int type, const void * addr, unsigned long size)
size680mm/memory.cif (!size || get_fs() == KERNEL_DS)
size696mm/memory.cif (vma->vm_end - start >= size)
size710mm/memory.cif (vma->vm_end - start >= size)
size721mm/memory.csize--;
size722mm/memory.csize += start & ~PAGE_MASK;
size723mm/memory.csize >>= PAGE_SHIFT;
size728mm/memory.cif (!size)
size730mm/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;
size161mm/page_alloc.cdo { unsigned long size = 1 << high; \
size163mm/page_alloc.carea--; high--; size >>= 1; \
size166mm/page_alloc.cindex += size; \
size167mm/page_alloc.cmap += size; \
size196mm/swapfile.cunsigned long address, unsigned long size, unsigned long offset,
size212mm/swapfile.cend = address + size;
size225mm/swapfile.cunsigned long address, unsigned long size,
size241mm/swapfile.cend = address + size;
size24mm/vmalloc.cunsigned long size;
size41mm/vmalloc.cstatic inline void free_area_pte(pmd_t * pmd, unsigned long address, unsigned long size)
size55mm/vmalloc.cend = address + size;
size73mm/vmalloc.cstatic inline void free_area_pmd(pgd_t * dir, unsigned long address, unsigned long size)
size87mm/vmalloc.cend = address + size;
size97mm/vmalloc.cstatic void free_area_pages(unsigned long address, unsigned long size)
size100mm/vmalloc.cunsigned long end = address + size;
size112mm/vmalloc.cstatic inline int alloc_area_pte(pte_t * pte, unsigned long address, unsigned long size)
size117mm/vmalloc.cend = address + size;
size134mm/vmalloc.cstatic inline int alloc_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size)
size139mm/vmalloc.cend = address + size;
size154mm/vmalloc.cstatic int alloc_area_pages(unsigned long address, unsigned long size)
size157mm/vmalloc.cunsigned long end = address + size;
size175mm/vmalloc.cstatic inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
size181mm/vmalloc.cend = address + size;
size194mm/vmalloc.cstatic inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size,
size200mm/vmalloc.cend = address + size;
size215mm/vmalloc.cstatic int remap_area_pages(unsigned long address, unsigned long offset, unsigned long size)
size218mm/vmalloc.cunsigned long end = address + size;
size237mm/vmalloc.cstatic struct vm_struct * get_vm_area(unsigned long size)
size246mm/vmalloc.carea->size = size + PAGE_SIZE;
size249mm/vmalloc.cif (size + (unsigned long) addr < (unsigned long) tmp->addr)
size251mm/vmalloc.caddr = (void *) (tmp->size + (unsigned long) tmp->addr);
size272mm/vmalloc.cfree_area_pages(VMALLOC_VMADDR(tmp->addr), tmp->size);
size280mm/vmalloc.cvoid * vmalloc(unsigned long size)
size285mm/vmalloc.csize = PAGE_ALIGN(size);
size286mm/vmalloc.cif (!size || size > (MAP_NR(high_memory) << PAGE_SHIFT))
size288mm/vmalloc.carea = get_vm_area(size);
size292mm/vmalloc.cif (alloc_area_pages(VMALLOC_VMADDR(addr), size)) {
size304mm/vmalloc.cvoid * vremap(unsigned long offset, unsigned long size)
size313mm/vmalloc.csize = PAGE_ALIGN(size);
size314mm/vmalloc.cif (!size || size > offset + size)
size316mm/vmalloc.carea = get_vm_area(size);
size320mm/vmalloc.cif (remap_area_pages(VMALLOC_VMADDR(addr), offset, size)) {
size340mm/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;
size1634net/appletalk/ddp.cint size;
size1679net/appletalk/ddp.csize=sizeof(struct ddpehdr)+len+ddp_dl->header_length;  /* For headers */
size1700net/appletalk/ddp.cprintk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
size1702net/appletalk/ddp.csize += dev->hard_header_len;
size1704net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0, 0 , &err);
size1813net/appletalk/ddp.cstatic int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size1836net/appletalk/ddp.cif(copied > size)
size1837net/appletalk/ddp.ccopied=size;
size1843net/appletalk/ddp.cif (copied > size)
size1844net/appletalk/ddp.ccopied = size;
size1942net/ax25/af_ax25.cint size;
size2008net/ax25/af_ax25.csize = len + 3 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
size2010net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
size2017net/ax25/af_ax25.cskb_reserve(skb, size - len);
size2072net/ax25/af_ax25.cstatic int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size2108net/ax25/af_ax25.ccopied = (size < length) ? size : length;
size2456net/ax25/af_ax25.cint size;
size2464net/ax25/af_ax25.csize = skb->len;
size2468net/ax25/af_ax25.c*ptr++ = (size + 5) % 256;
size2469net/ax25/af_ax25.c*ptr++ = (size + 5) / 256;
size875net/bridge/br.cint size;
size887net/bridge/br.csize = sizeof(Config_bpdu) + dev->hard_header_len;
size888net/bridge/br.cskb = alloc_skb(size, GFP_ATOMIC);
size895net/bridge/br.cskb->h.eth = (struct ethhdr *)skb_put(skb, size);
size934net/bridge/br.cint size;
size943net/bridge/br.csize = sizeof(Tcn_bpdu) + dev->hard_header_len;
size944net/bridge/br.cskb = alloc_skb(size, GFP_ATOMIC);
size951net/bridge/br.cskb->h.eth = (struct ethhdr *)skb_put(skb,size);
size159net/core/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
size161net/core/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
size169net/core/datagram.cvoid skb_copy_datagram_iovec(struct sk_buff *skb, int offset, struct iovec *to, int size)
size171net/core/datagram.cmemcpy_toiovec(to,skb->h.raw+offset,size);
size856net/core/dev.cint size;
size859net/core/dev.csize = sprintf(buffer, "%6s:%7d %4d %4d %4d %4d %8d %4d %4d %4d %5d %4d\n",
size871net/core/dev.csize = sprintf(buffer, "%6s: No statistics available.\n", dev->name);
size873net/core/dev.creturn size;
size886net/core/dev.cint size;
size891net/core/dev.csize = sprintf(buffer, "Inter-|   Receive                  |  Transmit\n"
size894net/core/dev.cpos+=size;
size895net/core/dev.clen+=size;
size900net/core/dev.csize = sprintf_stats(buffer+len, dev);
size901net/core/dev.clen+=size;
size632net/core/skbuff.cstruct sk_buff *alloc_skb(unsigned int size,int priority)
size635net/core/skbuff.cint len=size;
size648net/core/skbuff.csize=(size+15)&~15;    /* Allow for alignments. Make a multiple of 16 bytes */
size649net/core/skbuff.csize+=sizeof(struct sk_buff);  /* And stick the control itself on the end */
size655net/core/skbuff.cbptr=(unsigned char *)kmalloc(size,priority);
size674net/core/skbuff.cskb=(struct sk_buff *)(bptr+size)-1;
size686net/core/skbuff.cskb->truesize=size;
size344net/core/sock.cstruct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
size347net/core/sock.cif (force || sk->wmem_alloc + size < sk->sndbuf) {
size348net/core/sock.cstruct sk_buff * skb = alloc_skb(size, priority);
size355net/core/sock.creturn alloc_skb(size, priority);
size358net/core/sock.cstruct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
size361net/core/sock.cif (force || sk->rmem_alloc + size < sk->rcvbuf) {
size362net/core/sock.cstruct sk_buff *skb = alloc_skb(size, priority);
size369net/core/sock.creturn alloc_skb(size, priority);
size437net/core/sock.cstruct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size, unsigned long fallback, int noblock, int *errcode)
size461net/core/sock.cskb = sock_wmalloc(sk, size, 0, sk->allocation);
size466net/core/sock.cskb = sock_wmalloc(sk, size, 0 , GFP_BUFFER);
size510net/core/sock.cif (sk->wmem_alloc + size >= sk->sndbuf) 
size150net/ipv4/af_inet.cint size = 32767; /* a big num. */
size178net/ipv4/af_inet.cif (j < size) 
size181net/ipv4/af_inet.csize = j;
size1122net/ipv4/af_inet.cstatic int inet_recvmsg(struct socket *sock, struct msghdr *ubuf, int size, int noblock, 
size1134net/ipv4/af_inet.creturn(sk->prot->recvmsg(sk, ubuf, size, noblock, flags,addr_len));
size1138net/ipv4/af_inet.cstatic int inet_sendmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, 
size1154net/ipv4/af_inet.creturn(sk->prot->sendmsg(sk, msg, size, noblock, flags));
size1537net/ipv4/arp.cint size;
size1543net/ipv4/arp.csize = sprintf(buffer,"IP address       HW type     Flags       HW address            Mask     Device\n");
size1545net/ipv4/arp.cpos+=size;
size1546net/ipv4/arp.clen+=size;
size1580net/ipv4/arp.csize = sprintf(buffer+len,
size1587net/ipv4/arp.csize += sprintf(buffer+len+size,
size1592net/ipv4/arp.csize += sprintf(buffer+len+size,
size1600net/ipv4/arp.clen += size;
size1601net/ipv4/arp.cpos += size;
size66net/ipv4/ip_fragment.cextern __inline__ void *frag_kmalloc(int size, int pri)
size68net/ipv4/ip_fragment.cvoid *vp=kmalloc(size,pri);
size71net/ipv4/ip_fragment.catomic_add(size, &ip_frag_mem);
size416net/ipv4/ip_masq.cint    size;
size460net/ipv4/ip_masq.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
size479net/ipv4/ip_masq.csize = skb->len - ((unsigned char *)portptr-skb->h.raw);
size489net/ipv4/ip_masq.crecalc_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size);
size506net/ipv4/ip_masq.cskb->csum = csum_partial((void *)(th + 1), size - sizeof(*th), 0);
size507net/ipv4/ip_masq.ctcp_send_check(th,iph->saddr,iph->daddr,size,skb);
size567net/ipv4/ip_masq.cint size;
size589net/ipv4/ip_masq.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
size607net/ipv4/ip_masq.csize = skb->len - ((unsigned char *)portptr-skb->h.raw);
size614net/ipv4/ip_masq.crecalc_check((struct udphdr *)portptr,iph->saddr,iph->daddr,size);
size618net/ipv4/ip_masq.csize - sizeof(struct tcphdr), 0);
size619net/ipv4/ip_masq.ctcp_send_check((struct tcphdr *)portptr,iph->saddr,iph->daddr,size,skb);
size802net/ipv4/ipmr.cint size;
size816net/ipv4/ipmr.csize = sprintf(buffer+len, "%-10s %8ld  %7ld  %8ld   %7ld   %05X %08lX %08lX\n",
size819net/ipv4/ipmr.clen+=size;
size820net/ipv4/ipmr.cpos+=size;
size843net/ipv4/ipmr.cint size;
size876net/ipv4/ipmr.csize = sprintf(buffer+len, "%08lX %08lX %-8s %s\n",
size881net/ipv4/ipmr.clen+=size;
size882net/ipv4/ipmr.cpos+=size;
size489net/ipv4/rarp.cint size;
size495net/ipv4/rarp.csize = sprintf(buffer,"RARP disabled until entries added to cache.\n");
size496net/ipv4/rarp.cpos+=size;
size497net/ipv4/rarp.clen+=size;
size501net/ipv4/rarp.csize = sprintf(buffer,
size503net/ipv4/rarp.cpos+=size;
size504net/ipv4/rarp.clen+=size;
size516net/ipv4/rarp.csize = sprintf(buffer+len,
size527net/ipv4/rarp.clen+=size;
size46net/ipv4/tcp_output.cint size;
size53net/ipv4/tcp_output.csize = skb->len - ((unsigned char *) th - skb->data);
size59net/ipv4/tcp_output.cif (size < sizeof(struct tcphdr) || size > skb->len) 
size72net/ipv4/tcp_output.cif (size == sizeof(struct tcphdr)) 
size89net/ipv4/tcp_output.cskb->end_seq = skb->seq + size - 4*th->doff;
size126net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
size271net/ipv4/tcp_output.cint size;
size281net/ipv4/tcp_output.csize = skb->len - (((unsigned char *) th) - skb->data);
size283net/ipv4/tcp_output.cif (size > sk->mtu - sizeof(struct iphdr))
size293net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
size335net/ipv4/tcp_output.cint size;
size371net/ipv4/tcp_output.csize = ntohs(iph->tot_len) - (iph->ihl<<2);
size441net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
size1248net/ipx/af_ipx.cint size;
size1269net/ipx/af_ipx.csize=sizeof(ipx_packet)+len;
size1270net/ipx/af_ipx.csize += ipx_offset;
size1272net/ipx/af_ipx.cskb=sock_alloc_send_skb(sk, size, 0, 0, &err);
size2115net/ipx/af_ipx.cstatic int ipx_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
size2142net/ipx/af_ipx.ccopied = (truesize > size) ? size : truesize;
size1073net/netrom/af_netrom.cint size;
size1109net/netrom/af_netrom.csize = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
size1111net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
size1118net/netrom/af_netrom.cskb_reserve(skb, size - len);
size1168net/netrom/af_netrom.cstatic int nr_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
size1199net/netrom/af_netrom.ccopied = (size < skb->len) ? size : skb->len;
size86net/socket.cint size);
size88net/socket.cint size);
size334net/socket.cstatic int sock_read(struct inode *inode, struct file *file, char *ubuf, int size)
size345net/socket.cif(size<0)
size347net/socket.cif(size==0)    /* Match SYS5 behaviour */
size349net/socket.cif ((err=verify_area(VERIFY_WRITE,ubuf,size))<0)
size356net/socket.ciov.iov_len=size;
size358net/socket.creturn(sock->ops->recvmsg(sock, &msg, size,(file->f_flags & O_NONBLOCK), 0,&msg.msg_namelen));
size366net/socket.cstatic int sock_write(struct inode *inode, struct file *file, const char *ubuf, int size)
size378net/socket.cif(size<0)
size380net/socket.cif(size==0)    /* Match SYS5 behaviour */
size383net/socket.cif ((err=verify_area(VERIFY_READ,ubuf,size))<0)
size391net/socket.ciov.iov_len=size;
size393net/socket.creturn(sock->ops->sendmsg(sock, &msg, size,(file->f_flags & O_NONBLOCK),0));
size972net/socket.casmlinkage int sys_recv(int fd, void * ubuf, int size, unsigned flags)
size986net/socket.cif(size<0)
size988net/socket.cif(size==0)
size990net/socket.cerr=verify_area(VERIFY_WRITE, ubuf, size);
size999net/socket.ciov.iov_len=size;
size1001net/socket.creturn(sock->ops->recvmsg(sock, &msg, size,(file->f_flags & O_NONBLOCK), flags,&msg.msg_namelen));
size1010net/socket.casmlinkage int sys_recvfrom(int fd, void * ubuf, int size, unsigned flags,
size1024net/socket.cif(size<0)
size1026net/socket.cif(size==0)
size1029net/socket.cerr=verify_area(VERIFY_WRITE,ubuf,size);
size1036net/socket.ciov.iov_len=size;
size1040net/socket.csize=sock->ops->recvmsg(sock, &msg, size, (file->f_flags & O_NONBLOCK),
size1043net/socket.cif(size<0)
size1044net/socket.creturn size;
size1048net/socket.creturn size;
size876net/unix/af_unix.cint err,size;
size942net/unix/af_unix.csize=len-sent;
size944net/unix/af_unix.cif(size>(sk->sndbuf-sizeof(struct sk_buff))/2)  /* Keep two messages in the pipe so it schedules better */
size951net/unix/af_unix.csize=(sk->sndbuf-sizeof(struct sk_buff))/2;
size959net/unix/af_unix.cif(size > 4000 && sock->type!=SOCK_DGRAM)
size968net/unix/af_unix.cskb=sock_alloc_send_skb(sk,size,limit,nonblock, &err);
size980net/unix/af_unix.csize=skb_tailroom(skb);    /* If we dropped back on a limit then our skb is smaller */
size993net/unix/af_unix.cmemcpy_fromiovec(skb_put(skb,size),msg->msg_iov, size);
size1029net/unix/af_unix.cother->data_ready(other,size);
size1030net/unix/af_unix.csent+=size;
size1050net/unix/af_unix.cstatic int unix_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
size1104net/unix/af_unix.cif (copied == size)