taglinefilesource code
offset122arch/alpha/boot/tools/build.cunsigned long size, offset;
offset130arch/alpha/boot/tools/build.coffset = shdr[i].s_scnptr;
offset131arch/alpha/boot/tools/build.cif (lseek(fd, offset, SEEK_SET) != offset)
offset137arch/alpha/boot/tools/build.cif (offset)
offset71arch/alpha/kernel/osf_sys.cstatic int osf_filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
offset81arch/alpha/kernel/osf_sys.cput_user(offset, buf->basep);
offset94arch/alpha/kernel/ptrace.cstatic inline long get_stack_long(struct task_struct *task, unsigned long offset)
offset99arch/alpha/kernel/ptrace.cstack += offset+MAGICNUM;
offset109arch/alpha/kernel/ptrace.cstatic inline int put_stack_long(struct task_struct *task, unsigned long offset,
offset115arch/alpha/kernel/ptrace.cstack += offset+MAGICNUM;
offset54arch/i386/kernel/ptrace.cstatic inline int get_stack_long(struct task_struct *task, int offset)
offset59arch/i386/kernel/ptrace.cstack += offset;
offset69arch/i386/kernel/ptrace.cstatic inline int put_stack_long(struct task_struct *task, int offset,
offset75arch/i386/kernel/ptrace.cstack += offset;
offset45arch/i386/math-emu/fpu_aux.coperand_address.offset = 0;
offset47arch/i386/math-emu/fpu_aux.cinstruction_address.offset = 0;
offset97arch/i386/math-emu/fpu_emu.hunsigned int offset;
offset314arch/i386/math-emu/fpu_entry.centry_sel_off.offset = FPU_ORIG_EIP;
offset515arch/i386/math-emu/fpu_entry.coperand_address.offset = 0;
offset77arch/i386/math-emu/get_address.clong offset;
offset89arch/i386/math-emu/get_address.coffset = 0;              /* No base register */
offset91arch/i386/math-emu/get_address.coffset = REG_(base);
offset102arch/i386/math-emu/get_address.coffset += (REG_(index)) << ss;
offset110arch/i386/math-emu/get_address.coffset += (signed char) get_fs_byte((char *) (*fpu_eip));
offset119arch/i386/math-emu/get_address.coffset += (signed) get_fs_long((unsigned long *) (*fpu_eip));
offset124arch/i386/math-emu/get_address.creturn offset;
offset146arch/i386/math-emu/get_address.cunsigned short *selector, long offset)
offset164arch/i386/math-emu/get_address.caddress = base_address + offset;
offset254arch/i386/math-emu/get_address.caddr->offset = address;
offset261arch/i386/math-emu/get_address.caddr->offset = address;
offset287arch/i386/math-emu/get_address.caddr->offset = address;
offset403arch/i386/math-emu/get_address.caddr->offset = address;
offset1164arch/i386/math-emu/reg_ld_str.cinstruction_address.offset = get_fs_word((unsigned short *) (s+6));
offset1166arch/i386/math-emu/reg_ld_str.coperand_address.offset = get_fs_word((unsigned short *) (s+0x0a));
offset1172arch/i386/math-emu/reg_ld_str.cinstruction_address.offset
offset1174arch/i386/math-emu/reg_ld_str.coperand_address.offset += (operand_address.selector & 0xf000) << 4;
offset1184arch/i386/math-emu/reg_ld_str.cinstruction_address.offset = get_fs_long((unsigned long *) (s+0x0c));
offset1187arch/i386/math-emu/reg_ld_str.coperand_address.offset = get_fs_long((unsigned long *) (s+0x14));
offset1305arch/i386/math-emu/reg_ld_str.cput_fs_word(instruction_address.offset, (unsigned short *) (d+6));
offset1306arch/i386/math-emu/reg_ld_str.cput_fs_word(operand_address.offset, (unsigned short *) (d+0x0a));
offset1309arch/i386/math-emu/reg_ld_str.cput_fs_word((instruction_address.offset & 0xf0000) >> 4,
offset1311arch/i386/math-emu/reg_ld_str.cput_fs_word((operand_address.offset & 0xf0000) >> 4,
offset1336arch/i386/math-emu/reg_ld_str.cput_fs_long(instruction_address.offset, (unsigned long *) (d+0x0c));
offset1339arch/i386/math-emu/reg_ld_str.cput_fs_long(operand_address.offset, (unsigned long *) (d+0x14));
offset53arch/mips/kernel/ptrace.cstatic inline int get_stack_long(struct task_struct *task, int offset)
offset58arch/mips/kernel/ptrace.cstack += offset;
offset68arch/mips/kernel/ptrace.cstatic inline int put_stack_long(struct task_struct *task, int offset,
offset74arch/mips/kernel/ptrace.cstack += offset;
offset55arch/sparc/mm/srmmu.cunsigned long offset = PAGE_OFFSET;
offset62arch/sparc/mm/srmmu.creturn (paddr - sp_banks[i].base_addr) + offset;
offset64arch/sparc/mm/srmmu.coffset += sp_banks[i].num_bytes;
offset60arch/sparc/mm/sun4c.cunsigned long offset = PAGE_OFFSET;
offset67arch/sparc/mm/sun4c.creturn (paddr - sp_banks[i].base_addr) + offset;
offset69arch/sparc/mm/sun4c.coffset += sp_banks[i].num_bytes;
offset19arch/sparc/mm/vac-flush.cregister int entries_left, offset;
offset35arch/sparc/mm/vac-flush.coffset = vac_linesize;
offset39arch/sparc/mm/vac-flush.caddress += offset;
offset47arch/sparc/mm/vac-flush.cregister int entries_left, offset;
offset65arch/sparc/mm/vac-flush.coffset = vac_linesize;
offset69arch/sparc/mm/vac-flush.caddress += offset;
offset77arch/sparc/mm/vac-flush.cregister int entries_left, offset;
offset86arch/sparc/mm/vac-flush.coffset = vac_linesize;
offset90arch/sparc/mm/vac-flush.caddr += offset;
offset1087drivers/block/cdu31a.cunsigned int offset,
offset1121drivers/block/cdu31a.cinsb(sony_cd_read_reg, &buffer[offset], bytesleft);
offset1154drivers/block/cdu31a.cunsigned int offset;
offset1162drivers/block/cdu31a.coffset = 0;
offset1190drivers/block/cdu31a.coffset += readahead_dataleft;
offset1264drivers/block/cdu31a.cinput_data(buffer, bytesleft, nblocks, offset, skip);
offset146drivers/block/xd.cif (!memcmp(xd_bases[i] + xd_sigs[j].offset,xd_sigs[j].string,strlen(xd_sigs[j].string))) {
offset142drivers/char/console.cstatic void set_scrmem(int currcons, long offset);
offset557drivers/char/console.cstatic inline void __set_origin(unsigned short offset)
offset564drivers/char/console.c__origin = offset;
offset566drivers/char/console.coutb_p(offset >> 8, video_port_val);
offset568drivers/char/console.coutb_p(offset, video_port_val);
offset1053drivers/char/console.cstatic inline unsigned short *screenpos(int currcons, int offset, int viewed)
offset1055drivers/char/console.cunsigned short *p = (unsigned short *)(origin + offset);
offset1062drivers/char/console.cvoid invert_screen(int currcons, int offset, int count, int viewed)
offset1067drivers/char/console.cp = screenpos(currcons, offset, viewed);
offset1084drivers/char/console.cvoid complement_pos(int currcons, int offset)
offset1091drivers/char/console.cif (offset == -1)
offset1094drivers/char/console.cp = screenpos(currcons, offset, 1);
offset1101drivers/char/console.cunsigned short screen_word(int currcons, int offset, int viewed)
offset1103drivers/char/console.creturn scr_readw(screenpos(currcons, offset, viewed));
offset2190drivers/char/console.cstatic void set_scrmem(int currcons, long offset)
offset2223drivers/char/console.cif (video_mem_term - video_mem_base < offset + video_screen_size)
offset2224drivers/char/console.coffset = 0;  /* strange ... */
offset2225drivers/char/console.cmemcpyw((unsigned short *)(video_mem_base + offset),
offset2229drivers/char/console.corigin = video_mem_base + offset;
offset2265drivers/char/console.clong offset;
offset2281drivers/char/console.coffset = 0;
offset2287drivers/char/console.coffset = (blank_origin - video_mem_base)
offset2292drivers/char/console.cset_scrmem(fg_console, offset);
offset317drivers/char/lp.coff_t offset, int origin)
offset538drivers/char/lp.cint offset = 0;
offset551drivers/char/lp.cfor (offset = 0; offset < LP_NO; offset++) {
offset552drivers/char/lp.cif (check_region(LP_B(offset), 3))
offset555drivers/char/lp.coutb_p( LP_DUMMY, LP_B(offset));
offset558drivers/char/lp.ctestvalue = inb_p(LP_B(offset));
offset560drivers/char/lp.cLP_F(offset) |= LP_EXIST;
offset561drivers/char/lp.clp_reset(offset);
offset562drivers/char/lp.cprintk("lp%d at 0x%04x, ", offset,LP_B(offset));
offset563drivers/char/lp.crequest_region(LP_B(offset), 3, "lp");
offset564drivers/char/lp.cif (LP_IRQ(offset))
offset565drivers/char/lp.cprintk("(irq = %d)\n", LP_IRQ(offset));
offset585drivers/char/lp.cint offset;
offset590drivers/char/lp.cfor (offset = 0; offset < LP_NO; offset++) 
offset591drivers/char/lp.cif (LP_F(offset) & LP_EXIST) 
offset592drivers/char/lp.crelease_region(LP_B(offset),3);
offset196drivers/char/mem.cstatic int null_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset208drivers/char/mem.cstatic int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset212drivers/char/mem.cfile->f_pos = offset;
offset215drivers/char/mem.cfile->f_pos += offset;
offset21drivers/char/selection.hextern unsigned short screen_word(int currcons, int offset, int viewed);
offset22drivers/char/selection.hextern void complement_pos(int currcons, int offset);
offset23drivers/char/selection.hextern void invert_screen(int currcons, int offset, int count, int shift);
offset235drivers/char/serial.cstatic inline unsigned int serial_in(struct async_struct *info, int offset)
offset239drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset243drivers/char/serial.creturn inb(info->port + offset);
offset246drivers/char/serial.cstatic inline unsigned int serial_inp(struct async_struct *info, int offset)
offset250drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset255drivers/char/serial.creturn inb(info->port + offset);
offset257drivers/char/serial.creturn inb_p(info->port + offset);
offset261drivers/char/serial.cstatic inline void serial_out(struct async_struct *info, int offset, int value)
offset265drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset269drivers/char/serial.coutb(value, info->port+offset);
offset272drivers/char/serial.cstatic inline void serial_outp(struct async_struct *info, int offset,
offset277drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset282drivers/char/serial.coutb(value, info->port+offset);
offset284drivers/char/serial.coutb_p(value, info->port+offset);
offset1880drivers/char/tpqic02.cstatic int qic02_tape_lseek(struct inode * inode, struct file * file, off_t offset, int origin)
offset311drivers/char/tty_io.cstatic int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset40drivers/char/vc_screen.cvcs_lseek(struct inode *inode, struct file *file, off_t offset, int orig)
offset46drivers/char/vc_screen.cfile->f_pos = offset;
offset49drivers/char/vc_screen.cfile->f_pos += offset;
offset52drivers/char/vc_screen.cfile->f_pos = size + offset;
offset1208drivers/net/arcnet.cint offset;
offset1230drivers/net/arcnet.carcpacket->hardheader.offset1=offset=256-length
offset1233drivers/net/arcnet.c(&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
offset1240drivers/net/arcnet.carcpacket->hardheader.offset2=offset=512-length
offset1243drivers/net/arcnet.c(&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
offset1250drivers/net/arcnet.carcpacket->hardheader.offset2=offset=512-length-4
offset1253drivers/net/arcnet.c(&arcpacket->raw[offset+4-EXTRA_CLIENTDATA]);
offset1259drivers/net/arcnet.carcpacket->raw[offset+0]=hdr->protocol_id;
offset1260drivers/net/arcnet.carcpacket->raw[offset+1]=0xFF; /* FF flag */
offset1261drivers/net/arcnet.carcpacket->raw[offset+2]=0xFF; /* FF padding */
offset1262drivers/net/arcnet.carcpacket->raw[offset+3]=0xFF; /* FF padding */
offset1536drivers/net/arcnet.cshort length,offset;
offset1555drivers/net/arcnet.coffset=arcpacket->hardheader.offset1;
offset1557drivers/net/arcnet.c(&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
offset1558drivers/net/arcnet.clength=256-offset+EXTRA_CLIENTDATA;
offset1563drivers/net/arcnet.coffset=arcpacket->hardheader.offset2;
offset1565drivers/net/arcnet.c(&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
offset1569drivers/net/arcnet.clength=512-offset+EXTRA_CLIENTDATA;
offset1577drivers/net/arcnet.clength=512-offset+EXTRA_CLIENTDATA-4;
offset93drivers/net/atp.hextern inline unsigned char read_nibble(short port, unsigned char offset)
offset96drivers/net/atp.houtb(EOC+offset, port + PAR_DATA);
offset97drivers/net/atp.houtb(RdAddr+offset, port + PAR_DATA);
offset100drivers/net/atp.houtb(EOC+offset, port + PAR_DATA);
offset261drivers/net/atp.h#define EE_WRITE_CMD(offset)  (((5 << 6) + (offset)) << 17)
offset262drivers/net/atp.h#define EE_READ(offset)   (((6 << 6) + (offset)) << 17)
offset263drivers/net/atp.h#define EE_ERASE(offset)  (((7 << 6) + (offset)) << 17)
offset437drivers/net/de4x5.cstatic short   srom_rd(u_long address, u_char offset);
offset440drivers/net/de4x5.cstatic void    srom_address(u_int command, u_long address, u_char offset);
offset2312drivers/net/de4x5.cstatic short srom_rd(u_long addr, u_char offset)
offset2318drivers/net/de4x5.csrom_address(SROM_RD | SROM_SR | DT_CS, addr, offset);
offset2341drivers/net/de4x5.cstatic void srom_address(u_int command, u_long addr, u_char offset)
offset2346drivers/net/de4x5.ca = (char)(offset << 2);
offset453drivers/net/depca.cint i, j, offset, netRAM, mem_len, status=0;
offset491drivers/net/depca.coffset = 0x0000;
offset495drivers/net/depca.coffset = 0x8000;              /* 32kbyte RAM offset*/
offset499drivers/net/depca.cmem_start += offset;            /* (E)ISA start address */
offset197drivers/net/ne.cstruct {unsigned char value, offset; } program_seq[] = {
offset213drivers/net/ne.coutb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
offset2112drivers/net/wavelan.cwavelan_get_info(char *buffer, char **start, off_t offset, int length)
offset2143drivers/net/wavelan.cif (pos < offset)
offset2149drivers/net/wavelan.cif (pos > offset + length)
offset2157drivers/net/wavelan.c*start = buffer + (offset - begin);  /* Start of wanted data */
offset2158drivers/net/wavelan.clen -= (offset - begin);    /* Start slop */
offset1074drivers/scsi/53c7,8xx.chostdata->script[EXTERNAL_PATCHES[i].offset] +=
offset1358drivers/scsi/53c7,8xx.h#define patch_abs_32(script, offset, symbol, value)      \
offset1361drivers/scsi/53c7,8xx.h(script)[A_##symbol##_used[i] - (offset)] += (value);  \
offset1365drivers/scsi/53c7,8xx.h(int)(offset), #script, (script)[A_##symbol##_used[i] -  \
offset1366drivers/scsi/53c7,8xx.h(offset)]);            \
offset1369drivers/scsi/53c7,8xx.h#define patch_abs_rwri_data(script, offset, symbol, value)    \
offset1372drivers/scsi/53c7,8xx.h(script)[A_##symbol##_used[i] - (offset)] =      \
offset1373drivers/scsi/53c7,8xx.h((script)[A_##symbol##_used[i] - (offset)] &     \
offset2253drivers/scsi/53c8xx_d.hu32  offset;
offset1357drivers/scsi/aic7xxx.cunsigned char offset, int target)
offset1365drivers/scsi/aic7xxx.c*scsirate = (aic7xxx_syncrates[i].rate << 4) | (offset & 0x0F);
offset1367drivers/scsi/aic7xxx.ctarget, aic7xxx_syncrates[i].english, offset);
offset1397drivers/scsi/aic7xxx.cunsigned char offset, rate, scratch;
offset1537drivers/scsi/aic7xxx.coffset = inb(ACCUM(base));
offset1557drivers/scsi/aic7xxx.caic7xxx_scsirate(&rate, transfer, MIN(offset, max_offset), scsi_id);
offset65drivers/scsi/eata_dma_proc.cint eata_proc_info(char *buffer, char **start, off_t offset, int length, 
offset101drivers/scsi/eata_dma_proc.cif (offset == 0)
offset273drivers/scsi/eata_dma_proc.cif (pos < offset) {
offset277drivers/scsi/eata_dma_proc.cif (pos > offset + length)
offset337drivers/scsi/eata_dma_proc.cif (pos < offset) {
offset341drivers/scsi/eata_dma_proc.cif (pos > offset + length)
offset389drivers/scsi/eata_dma_proc.cif (pos < offset) {
offset393drivers/scsi/eata_dma_proc.cif (pos > offset + length)
offset400drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
offset401drivers/scsi/eata_dma_proc.c*start=buffer+(offset-begin);   /* Start of wanted data */
offset402drivers/scsi/eata_dma_proc.clen-=(offset-begin);      /* Start slop */
offset405drivers/scsi/eata_dma_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
offset126drivers/scsi/eata_dma_proc.h__u8  offset,
offset37drivers/scsi/eata_pio_proc.cint eata_pio_proc_info(char *buffer, char **start, off_t offset, int length, int hostno, int inout)
offset58drivers/scsi/eata_pio_proc.cif (offset == 0)
offset89drivers/scsi/eata_pio_proc.cif (pos < offset) {
offset93drivers/scsi/eata_pio_proc.cif (pos > offset + length)
offset141drivers/scsi/eata_pio_proc.cif (pos < offset) {
offset145drivers/scsi/eata_pio_proc.cif (pos > offset + length)
offset152drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("2pos: %ld offset: %ld len: %d\n", pos, offset, len));
offset153drivers/scsi/eata_pio_proc.c*start=buffer+(offset-begin);   /* Start of wanted data */
offset154drivers/scsi/eata_pio_proc.clen-=(offset-begin);            /* Start slop */
offset157drivers/scsi/eata_pio_proc.cDBG(DBG_PROC, printk("3pos: %ld offset: %ld len: %d\n", pos, offset, len));
offset109drivers/scsi/scsi.cextern int (* dispatch_scsi_info_ptr)(int ino, char *buffer, char **start, off_t offset, int length, int inout); 
offset110drivers/scsi/scsi.cextern int dispatch_scsi_info(int ino, char *buffer, char **start, off_t offset, int length, int inout); 
offset2111drivers/scsi/scsi.clong offset;
offset2118drivers/scsi/scsi.coffset = -1;
offset2124drivers/scsi/scsi.coffset = ((unsigned long) obj) - ((unsigned long)dma_malloc_pages[page]);
offset2129drivers/scsi/scsi.csector = offset >> 9;
offset2132drivers/scsi/scsi.csector = (offset >> 9) & (sizeof(*dma_malloc_freelist) * 8 - 1);
offset2423drivers/scsi/scsi.cint scsi_proc_info(char *buffer, char **start, off_t offset, int length, 
offset619drivers/scsi/scsi_debug.cint scsi_debug_proc_info(char *buffer, char **start, off_t offset, 
offset660drivers/scsi/scsi_debug.cif(pos < offset)
offset666drivers/scsi/scsi_debug.c*start = buffer + (offset - begin);   /* Start of wanted data */
offset667drivers/scsi/scsi_debug.clen -= (offset - begin);
offset78drivers/scsi/scsi_proc.cint generic_proc_info(char *buffer, char **start, off_t offset, 
offset89drivers/scsi/scsi_proc.cif(pos < offset) {
offset94drivers/scsi/scsi_proc.c*start = buffer + (offset - begin);   /* Start of wanted data */
offset95drivers/scsi/scsi_proc.clen -= (offset - begin);
offset106drivers/scsi/scsi_proc.coff_t offset, int length, int func)
offset117drivers/scsi/scsi_proc.creturn(scsi_proc_info(buffer, start, offset, length, 0, func));
offset123drivers/scsi/scsi_proc.creturn generic_proc_info(buffer, start, offset, length, 
offset126drivers/scsi/scsi_proc.creturn(hpnt->hostt->proc_info(buffer, start, offset, 
offset157drivers/scsi/seagate.cunsigned offset;
offset331drivers/scsi/seagate.csignatures[j].offset), (void *) signatures[j].signature,
offset166drivers/scsi/sr.cint offset;
offset167drivers/scsi/sr.coffset = (SCpnt->request.sector % 4) << 9;
offset169drivers/scsi/sr.c(char *)SCpnt->buffer + offset, 
offset175drivers/scsi/sr.cif((offset == 0) && this_count == 2 &&
offset295drivers/scsi/st.cint offset, transfer, blks;
offset320drivers/scsi/st.coffset = (STp->buffer)->buffer_bytes;
offset321drivers/scsi/st.ctransfer = ((offset + STp->block_size - 1) /
offset327drivers/scsi/st.cmemset((STp->buffer)->b_data + offset, 0, transfer - offset);
offset146drivers/scsi/t128.cint offset;
offset212drivers/scsi/t128.c(bases[current_base].address + signatures[sig].offset, 
offset534drivers/sound/audio.caudio_lseek (int dev, struct fileinfo *file, off_t offset, int orig)
offset1940drivers/sound/sequencer.csequencer_lseek (int dev, struct fileinfo *file, off_t offset, int orig)
offset33drivers/sound/sound_calls.hint audio_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset50drivers/sound/sound_calls.hint sequencer_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset72drivers/sound/sound_calls.hint MIDIbuf_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset252drivers/sound/sound_calls.hint pss_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset84drivers/sound/soundcard.csound_lseek (struct inode *inode, struct file *file, off_t offset, int orig)
offset908fs/binfmt_elf.coff_t offset = 0, dataoff;
offset995fs/binfmt_elf.coffset += sizeof(elf);        /* Elf header */
offset996fs/binfmt_elf.coffset += (segs+1) * sizeof(struct elf_phdr);  /* Program headers */
offset1094fs/binfmt_elf.cphdr.p_offset = offset;
offset1102fs/binfmt_elf.coffset += phdr.p_filesz;
offset1107fs/binfmt_elf.cdataoff = offset = roundup(offset, PAGE_SIZE);
offset1122fs/binfmt_elf.cphdr.p_offset = offset;
offset1127fs/binfmt_elf.coffset += sz;
offset1159fs/binfmt_elf.cif ((off_t) file.f_pos != offset) {
offset1162fs/binfmt_elf.c(off_t) file.f_pos, offset);
offset27fs/block_dev.cloff_t offset;
offset57fs/block_dev.coffset = filp->f_pos & (blocksize-1);
offset66fs/block_dev.cchars = blocksize - offset;
offset118fs/block_dev.cp = offset + bh->b_data;
offset119fs/block_dev.coffset = 0;
offset163fs/block_dev.cloff_t offset;
offset190fs/block_dev.coffset = filp->f_pos;
offset198fs/block_dev.cif (offset > size)
offset201fs/block_dev.cleft = size - offset;
offset207fs/block_dev.cblock = offset >> blocksize_bits;
offset208fs/block_dev.coffset &= blocksize-1;
offset210fs/block_dev.crblocks = blocks = (left + offset + blocksize - 1) >> blocksize_bits;
offset280fs/block_dev.cif (left < blocksize - offset)
offset283fs/block_dev.cchars = blocksize - offset;
offset288fs/block_dev.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset295fs/block_dev.coffset = 0;
offset936fs/buffer.cunsigned long offset;
offset939fs/buffer.coffset = PAGE_SIZE;
offset940fs/buffer.cwhile ((offset -= size) < PAGE_SIZE) {
offset946fs/buffer.cbh->b_data = (char *) (page+offset);
offset1004fs/buffer.cunsigned long offset;
offset1014fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
offset1022fs/buffer.cif (page+offset != (unsigned long) first->b_data)
offset1044fs/buffer.cunsigned long offset;
offset1054fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
offset1556fs/buffer.cunsigned long offset;
offset1569fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
offset1611fs/buffer.cint i, offset;
offset1613fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
offset150fs/exec.c#define DUMP_SEEK(offset) \
offset152fs/exec.cif (file.f_op->lseek(inode,&file,(offset),0) != (offset)) \
offset154fs/exec.c} else file.f_pos = (offset)    
offset391fs/exec.cint len, offset = 0;
offset417fs/exec.cif (--offset < 0) {
offset418fs/exec.coffset = p % PAGE_SIZE;
offset429fs/exec.c*(pag + offset) = get_user(tmp);
offset462fs/exec.cint read_exec(struct inode *inode, unsigned long offset,
offset483fs/exec.cif (file.f_op->lseek(inode,&file,offset,0) != offset)
offset486fs/exec.cfile.f_pos = offset;
offset69fs/ext/dir.coff_t offset;
offset79fs/ext/dir.coffset = filp->f_pos & 1023;
offset82fs/ext/dir.cfilp->f_pos += 1024-offset;
offset85fs/ext/dir.cfor (i = 0; i < 1024 && i < offset; ) {
offset91fs/ext/dir.coffset = i;
offset92fs/ext/dir.cde = (struct ext_dir_entry *) (offset + bh->b_data);
offset93fs/ext/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
offset99fs/ext/dir.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
offset100fs/ext/dir.cfilp->f_pos += 1024-offset;
offset110fs/ext/dir.coffset += de->rec_len;
offset75fs/ext/file.cint block, blocks, offset;
offset90fs/ext/file.coffset = filp->f_pos;
offset92fs/ext/file.cif (offset > size)
offset95fs/ext/file.cleft = size - offset;
offset101fs/ext/file.cblock = offset >> BLOCK_SIZE_BITS;
offset102fs/ext/file.coffset &= BLOCK_SIZE-1;
offset104fs/ext/file.cblocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
offset160fs/ext/file.cif (left < BLOCK_SIZE - offset)
offset163fs/ext/file.cchars = BLOCK_SIZE - offset;
offset168fs/ext/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset175fs/ext/file.coffset = 0;
offset83fs/ext/namei.clong offset;
offset104fs/ext/namei.coffset = 0;
offset106fs/ext/namei.cwhile (offset < dir->i_size) {
offset110fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
offset122fs/ext/namei.cdir->i_dev, dir->i_ino, offset, de->rec_len, de->name_len);
offset124fs/ext/namei.coffset = ((offset / BLOCK_SIZE) + 1) * BLOCK_SIZE;
offset132fs/ext/namei.cif (offset + de->rec_len < dir->i_size &&
offset140fs/ext/namei.coffset += de->rec_len;
offset191fs/ext/namei.clong offset;
offset212fs/ext/namei.coffset = 0;
offset215fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
offset221fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
offset226fs/ext/namei.cif (offset >= dir->i_size) {
offset228fs/ext/namei.cif (offset % BLOCK_SIZE == 0  ||
offset229fs/ext/namei.c(BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) {
offset230fs/ext/namei.cif ((offset % BLOCK_SIZE) != 0) {
offset236fs/ext/namei.c- (offset & (BLOCK_SIZE - 1));
offset238fs/ext/namei.coffset += de->rec_len;
offset251fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,1);
offset270fs/ext/namei.cdir->i_dev, dir->i_ino, offset, de->rec_len, de->name_len);
offset296fs/ext/namei.coffset += de->rec_len;
offset469fs/ext/namei.cunsigned long offset;
offset484fs/ext/namei.coffset = de->rec_len + de1->rec_len;
offset486fs/ext/namei.cwhile (offset < inode->i_size ) {
offset489fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
offset491fs/ext/namei.coffset += BLOCK_SIZE;
offset500fs/ext/namei.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
offset508fs/ext/namei.coffset += de->rec_len;
offset63fs/ext/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned long * p)
offset70fs/ext/truncate.c#define INDIRECT_BLOCK (DIRECT_BLOCK-offset)
offset126fs/ext/truncate.cstatic int trunc_dindirect(struct inode * inode, int offset, unsigned long * p)
offset132fs/ext/truncate.c#define DINDIRECT_BLOCK ((DIRECT_BLOCK-offset)>>8)
offset156fs/ext/truncate.cretry |= trunc_indirect(inode,offset+(i<<8),dind);
offset74fs/ext2/dir.cunsigned long offset)
offset93fs/ext2/dir.cdir->i_ino, error_msg, offset, (unsigned long) de->inode,
offset102fs/ext2/dir.cunsigned long offset, blk;
offset115fs/ext2/dir.coffset = filp->f_pos & (sb->s_blocksize - 1);
offset124fs/ext2/dir.cfilp->f_pos += sb->s_blocksize - offset;
offset131fs/ext2/dir.cif (!offset) {
offset153fs/ext2/dir.cfor (i = 0; i < sb->s_blocksize && i < offset; ) {
offset166fs/ext2/dir.coffset = i;
offset168fs/ext2/dir.c| offset;
offset173fs/ext2/dir.c&& offset < sb->s_blocksize) {
offset174fs/ext2/dir.cde = (struct ext2_dir_entry *) (bh->b_data + offset);
offset176fs/ext2/dir.cbh, offset)) {
offset184fs/ext2/dir.coffset += de->rec_len;
offset202fs/ext2/dir.coffset = 0;
offset84fs/ext2/file.cint block, blocks, offset;
offset104fs/ext2/file.coffset = filp->f_pos;
offset106fs/ext2/file.cif (offset > size)
offset109fs/ext2/file.cleft = size - offset;
offset115fs/ext2/file.cblock = offset >> EXT2_BLOCK_SIZE_BITS(sb);
offset116fs/ext2/file.coffset &= (sb->s_blocksize - 1);
offset117fs/ext2/file.cchars = sb->s_blocksize - offset;
offset119fs/ext2/file.cblocks = (left + offset + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
offset198fs/ext2/file.cmemcpy_tofs (buf, offset + (*bhe)->b_data,
offset206fs/ext2/file.coffset = 0;
offset238fs/ext2/file.cint offset;
offset277fs/ext2/file.coffset = pos2 & (sb->s_blocksize - 1);
offset278fs/ext2/file.cc = sb->s_blocksize - offset;
offset308fs/ext2/file.cmemcpy_fromfs (bh->b_data + offset, buf, c);
offset329fs/ext2/file.coffset = 0;
offset75fs/ext2/namei.cunsigned long offset;
offset104fs/ext2/namei.cfor (block = 0, offset = 0; offset < dir->i_size; block++) {
offset117fs/ext2/namei.cdir->i_ino, offset);
offset118fs/ext2/namei.coffset += sb->s_blocksize;
offset133fs/ext2/namei.cde, bh, offset))
offset143fs/ext2/namei.coffset += de->rec_len;
offset224fs/ext2/namei.cunsigned long offset;
offset256fs/ext2/namei.coffset = 0;
offset263fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
offset266fs/ext2/namei.cif (dir->i_size <= offset) {
offset277fs/ext2/namei.cdir->i_size = offset + sb->s_blocksize;
offset287fs/ext2/namei.coffset)) {
offset299fs/ext2/namei.coffset += de->rec_len;
offset330fs/ext2/namei.coffset += de->rec_len;
offset553fs/ext2/namei.cunsigned long offset;
offset576fs/ext2/namei.coffset = de->rec_len + de1->rec_len;
offset578fs/ext2/namei.cwhile (offset < inode->i_size ) {
offset581fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
offset585fs/ext2/namei.cinode->i_ino, offset);
offset586fs/ext2/namei.coffset += sb->s_blocksize;
offset592fs/ext2/namei.coffset)) {
offset600fs/ext2/namei.coffset += de->rec_len;
offset450fs/ext2/super.cunsigned long offset;
offset455fs/ext2/super.coffset = (sb_block*BLOCK_SIZE) % sb->s_blocksize;
offset459fs/ext2/super.ces = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
offset106fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, u32 * p)
offset117fs/ext2/truncate.c#define INDIRECT_BLOCK ((int)DIRECT_BLOCK - offset)
offset202fs/ext2/truncate.cstatic int trunc_dindirect (struct inode * inode, int offset,
offset211fs/ext2/truncate.c#define DINDIRECT_BLOCK (((int)DIRECT_BLOCK - offset) / addr_per_block)
offset236fs/ext2/truncate.cretry |= trunc_indirect (inode, offset + (i * addr_per_block),
offset326fs/ext2/truncate.cint offset;
offset357fs/ext2/truncate.coffset = inode->i_size & (inode->i_sb->s_blocksize - 1);
offset358fs/ext2/truncate.cif (offset) {
offset363fs/ext2/truncate.cmemset (bh->b_data + offset, 0,
offset364fs/ext2/truncate.cinode->i_sb->s_blocksize - offset);
offset117fs/isofs/dir.cunsigned int block, offset;
offset125fs/isofs/dir.coffset = filp->f_pos & (bufsize - 1);
offset138fs/isofs/dir.cblock, offset, filp->f_pos);
offset141fs/isofs/dir.cif (offset >= bufsize) {
offset143fs/isofs/dir.coffset = 0;
offset153fs/isofs/dir.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset154fs/isofs/dir.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
offset166fs/isofs/dir.coffset = 0;
offset179fs/isofs/dir.cnext_offset = offset + de_len;
offset182fs/isofs/dir.cmemcpy(tmpde, de, bufsize - offset);
offset190fs/isofs/dir.cmemcpy(bufsize - offset + (char *) tmpde, bh->b_data, next_offset);
offset193fs/isofs/dir.coffset = next_offset;
offset126fs/isofs/file.cint block, blocks, offset, total_blocks;
offset153fs/isofs/file.coffset = (inode->u.isofs_i.i_first_extent + filp->f_pos)
offset155fs/isofs/file.cblocks = (left + offset + ISOFS_BUFFER_SIZE(inode) - 1) / ISOFS_BUFFER_SIZE(inode);
offset225fs/isofs/file.cif (left < ISOFS_BUFFER_SIZE(inode) - offset)
offset228fs/isofs/file.cchars = ISOFS_BUFFER_SIZE(inode) - offset;
offset235fs/isofs/file.cunixify_to_fs(buf, offset+(*bhe)->b_data, chars, 
offset238fs/isofs/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset245fs/isofs/file.coffset = 0;
offset444fs/isofs/inode.cint frag1, offset;
offset446fs/isofs/inode.coffset = (inode->i_ino & (bufsize - 1));
offset447fs/isofs/inode.cfrag1 = bufsize - offset;
offset454fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
offset461fs/isofs/inode.coffset += *pnt - bufsize;
offset462fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset641fs/isofs/inode.cunsigned int block,offset;
offset650fs/isofs/inode.coffset = 0;
offset655fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset662fs/isofs/inode.coffset += *((unsigned char *) de);
offset664fs/isofs/inode.cif (offset >= bufsize) 
offset687fs/isofs/inode.coffset = 0;
offset694fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset695fs/isofs/inode.cinode_number = (block << bufbits)+(offset & (bufsize - 1));
offset704fs/isofs/inode.coffset = 0;
offset720fs/isofs/inode.cold_offset = offset;
offset721fs/isofs/inode.coffset += *((unsigned char *) de);
offset723fs/isofs/inode.cif (offset >= bufsize)
offset732fs/isofs/inode.coffset -= bufsize;
offset740fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset70fs/isofs/namei.cunsigned int block, i, f_pos, offset, inode_number;
offset87fs/isofs/namei.coffset = f_pos & (bufsize - 1);
offset93fs/isofs/namei.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset95fs/isofs/namei.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
offset102fs/isofs/namei.coffset = 0;
offset111fs/isofs/namei.cold_offset = offset;
offset112fs/isofs/namei.coffset += *((unsigned char *) de);
offset117fs/isofs/namei.cif (offset >= bufsize) {
offset126fs/isofs/namei.coffset = f_pos & (bufsize - 1);
offset132fs/isofs/namei.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset47fs/isofs/rock.ccont_offset = isonum_733(rr->u.CE.offset); \
offset59fs/isofs/rock.cint block, offset, offset1; \
offset64fs/isofs/rock.coffset = cont_offset; \
offset68fs/isofs/rock.cif (offset >= 1024) block++; \
offset69fs/isofs/rock.coffset &= 1023; \
offset70fs/isofs/rock.cif(offset + cont_size >= 1024) { \
offset75fs/isofs/rock.cmemcpy(buffer, bh->b_data + offset, 1024 - offset); \
offset77fs/isofs/rock.coffset1 = 1024 - offset; \
offset78fs/isofs/rock.coffset = 0;} \
offset84fs/isofs/rock.cmemcpy(buffer + offset1, bh->b_data + offset, cont_size - offset1); \
offset438fs/isofs/rock.cint frag1, offset;
offset440fs/isofs/rock.coffset = (inode->i_ino & (bufsize - 1));
offset441fs/isofs/rock.cfrag1 = bufsize - offset;
offset444fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
offset451fs/isofs/rock.coffset += *pnt - bufsize;
offset452fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset13fs/isofs/rock.hchar offset[8];
offset65fs/minix/dir.cunsigned int offset;
offset76fs/minix/dir.coffset = filp->f_pos & 1023;
offset79fs/minix/dir.cfilp->f_pos += 1024-offset;
offset83fs/minix/dir.cde = (struct minix_dir_entry *) (offset + bh->b_data);
offset91fs/minix/dir.coffset += info->s_dirsize;
offset93fs/minix/dir.c} while (offset < 1024 && filp->f_pos < inode->i_size);
offset73fs/minix/file.cint block, blocks, offset;
offset88fs/minix/file.coffset = filp->f_pos;
offset90fs/minix/file.cif (offset > size)
offset93fs/minix/file.cleft = size - offset;
offset99fs/minix/file.cblock = offset >> BLOCK_SIZE_BITS;
offset100fs/minix/file.coffset &= BLOCK_SIZE-1;
offset102fs/minix/file.cblocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
offset158fs/minix/file.cif (left < BLOCK_SIZE - offset)
offset161fs/minix/file.cchars = BLOCK_SIZE - offset;
offset166fs/minix/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset173fs/minix/file.coffset = 0;
offset45fs/minix/namei.cstruct buffer_head * bh, unsigned long * offset,
offset50fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + *offset);
offset51fs/minix/namei.c*offset += info->s_dirsize;
offset71fs/minix/namei.cunsigned long block, offset;
offset87fs/minix/namei.cblock = offset = 0;
offset88fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < dir->i_size) {
offset96fs/minix/namei.c*res_dir = (struct minix_dir_entry *) (bh->b_data + offset);
offset97fs/minix/namei.cif (minix_match(namelen,name,bh,&offset,info))
offset99fs/minix/namei.cif (offset < bh->b_size)
offset103fs/minix/namei.coffset = 0;
offset155fs/minix/namei.cunsigned long block, offset;
offset175fs/minix/namei.cblock = offset = 0;
offset182fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
offset183fs/minix/namei.coffset += info->s_dirsize;
offset184fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
offset186fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
offset204fs/minix/namei.cif (offset < bh->b_size)
offset208fs/minix/namei.coffset = 0;
offset380fs/minix/namei.cunsigned int block, offset;
offset390fs/minix/namei.coffset = 2*info->s_dirsize;
offset393fs/minix/namei.cif (inode->i_size < offset)
offset404fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
offset412fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
offset413fs/minix/namei.coffset += info->s_dirsize;
offset418fs/minix/namei.cif (offset < bh->b_size)
offset422fs/minix/namei.coffset = 0;
offset61fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
offset68fs/minix/truncate.c#define INDIRECT_BLOCK (DIRECT_BLOCK-offset)
offset244fs/msdos/fat.cint cluster,offset;
offset253fs/msdos/fat.coffset = sector % sb->cluster_size;
offset255fs/msdos/fat.creturn (cluster-2)*sb->cluster_size+sb->data_start+offset;
offset216fs/msdos/file.cint size,offset;
offset234fs/msdos/file.coffset = filp->f_pos & (SECTOR_SIZE-1);
offset235fs/msdos/file.cdata = bh->b_data + offset;
offset236fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,left_in_file);
offset274fs/msdos/file.cint sector,offset,size,left,written;
offset303fs/msdos/file.coffset = filp->f_pos & (SECTOR_SIZE-1);
offset304fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
offset306fs/msdos/file.c&& offset == 0
offset321fs/msdos/file.cmemcpy_fromfs(bh->b_data+offset,buf,written = size);
offset325fs/msdos/file.cwritten = left = SECTOR_SIZE-offset;
offset342fs/msdos/inode.cint cluster,offset;
offset349fs/msdos/inode.coffset = block % sb->cluster_size;
offset351fs/msdos/inode.creturn (cluster-2)*sb->cluster_size+sb->data_start+offset;
offset289fs/msdos/misc.cint sector,offset;
offset292fs/msdos/misc.coffset = *pos;
offset293fs/msdos/misc.cPRINTK (("get_entry offset %d\n",offset));
offset294fs/msdos/misc.cif ((sector = msdos_smap(dir,offset >> SECTOR_BITS)) == -1)
offset308fs/msdos/misc.c*de = (struct msdos_dir_entry *) ((*bh)->b_data+(offset &
offset310fs/msdos/misc.creturn (sector << MSDOS_DPS_BITS)+((offset & (SECTOR_SIZE-1)) >>
offset380fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr, int fs)
offset387fs/nfs/proc.cPRINTK("NFS call  read %d @ %d\n", count, offset);
offset393fs/nfs/proc.c*p++ = htonl(offset);
offset426fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
offset432fs/nfs/proc.cPRINTK("NFS call  write %d @ %d\n", count, offset);
offset438fs/nfs/proc.c*p++ = htonl(offset); /* traditional, could be any value */
offset439fs/nfs/proc.c*p++ = htonl(offset);
offset119fs/pipe.cstatic int pipe_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset156fs/proc/mem.cstatic int mem_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset160fs/proc/mem.cfile->f_pos = offset;
offset163fs/proc/mem.cfile->f_pos += offset;
offset201fs/proc/scsi.cint get_not_present_info(char *buffer, char **start, off_t offset, int length)
offset208fs/proc/scsi.cif(pos < offset) {
offset213fs/proc/scsi.c*start = buffer + (offset - begin);    /* Start of wanted data */
offset214fs/proc/scsi.clen -= (offset - begin);
offset311fs/proc/scsi.coff_t offset, int orig)
offset315fs/proc/scsi.cfile->f_pos = offset;
offset318fs/proc/scsi.cfile->f_pos += offset;
offset321fs/proc/scsi.cif (offset)       /* to determine the length of the */
offset16fs/read_write.casmlinkage int sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
offset26fs/read_write.creturn file->f_op->lseek(file->f_inode,file,offset,origin);
offset31fs/read_write.ctmp = offset;
offset34fs/read_write.ctmp = file->f_pos + offset;
offset39fs/read_write.ctmp = file->f_inode->i_size + offset;
offset58fs/read_write.cloff_t offset;
offset67fs/read_write.coffset = (loff_t) (((unsigned long long) offset_high << 32) | offset_low);
offset72fs/read_write.cif (offset != (long) offset)
offset74fs/read_write.creturn file->f_op->lseek(file->f_inode,file,offset,origin);
offset79fs/read_write.ctmp = offset;
offset82fs/read_write.ctmp = file->f_pos + offset;
offset87fs/read_write.ctmp = file->f_inode->i_size + offset;
offset39fs/readdir.cstatic int fillonedir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
offset49fs/readdir.cput_user(offset, &dirent->d_offset);
offset95fs/readdir.cstatic int filldir(void * __buf, const char * name, int namlen, off_t offset, ino_t ino)
offset106fs/readdir.cput_user(offset, &dirent->d_off);
offset626fs/smbfs/proc.coff_t offset, long count, char *data, int fs)
offset636fs/smbfs/proc.cDSET(buf, smb_vwv2, offset);
offset661fs/smbfs/proc.coff_t offset, int count, char *data)
offset670fs/smbfs/proc.cDSET(buf, smb_vwv2, offset);
offset72fs/sysv/dir.cunsigned int offset,i;
offset82fs/sysv/dir.coffset = filp->f_pos & sb->sv_block_size_1;
offset85fs/sysv/dir.cfilp->f_pos += sb->sv_block_size - offset;
offset89fs/sysv/dir.cwhile (offset < sb->sv_block_size && filp->f_pos < inode->i_size) {
offset90fs/sysv/dir.cde = (struct sysv_dir_entry *) (offset + bh_data);
offset107fs/sysv/dir.coffset += SYSV_DIRSIZE;
offset81fs/sysv/file.cint blocks, offset;
offset96fs/sysv/file.coffset = filp->f_pos;
offset98fs/sysv/file.cif (offset > size)
offset101fs/sysv/file.cleft = size - offset;
offset107fs/sysv/file.cblock = offset >> sb->sv_block_size_bits;
offset108fs/sysv/file.coffset &= sb->sv_block_size_1;
offset110fs/sysv/file.cblocks = (left + offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
offset166fs/sysv/file.cif (left < sb->sv_block_size - offset)
offset169fs/sysv/file.cchars = sb->sv_block_size - offset;
offset174fs/sysv/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset181fs/sysv/file.coffset = 0;
offset48fs/sysv/ialloc.cunsigned int offset = offsetof(struct xenix_super_block, s_inode[i]);
offset49fs/sysv/ialloc.cif (offset < 512)
offset50fs/sysv/ialloc.creturn (sysv_ino_t*)(sb->sv_sbd1 + offset);
offset52fs/sysv/ialloc.creturn (sysv_ino_t*)(sb->sv_sbd2 + offset);
offset68fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset81fs/sysv/namei.cpos = block = offset = 0;
offset92fs/sysv/namei.c*res_dir = (struct sysv_dir_entry *) (bh->b_data + offset) ))
offset95fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset96fs/sysv/namei.cif (offset < sb->sv_block_size)
offset100fs/sysv/namei.coffset = 0; block++;
offset152fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset169fs/sysv/namei.cpos = block = offset = 0;
offset176fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
offset178fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset198fs/sysv/namei.cif (offset < sb->sv_block_size)
offset202fs/sysv/namei.coffset = 0; block++;
offset372fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset380fs/sysv/namei.cpos = offset = 2*SYSV_DIRSIZE;
offset404fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh->b_data + offset);
offset406fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset411fs/sysv/namei.cif (offset < sb->sv_block_size)
offset415fs/sysv/namei.coffset = 0; block++;
offset78fs/sysv/truncate.cstatic int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset106fs/sysv/truncate.cif (inode->i_size < offset)
offset109fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
offset118fs/sysv/truncate.cif ((i << sb->sv_block_size_bits) + offset < inode->i_size) {
offset147fs/sysv/truncate.cstatic int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset173fs/sysv/truncate.cif (inode->i_size < offset)
offset176fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_ind_per_block_block_size_1) >> sb->sv_ind_per_block_block_size_bits;
offset184fs/sysv/truncate.cretry |= trunc_indirect(inode,offset+(i<<sb->sv_ind_per_block_bits),ind,sb->sv_convert,&indbh->b_dirt);
offset201fs/sysv/truncate.cstatic int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset227fs/sysv/truncate.cif (inode->i_size < offset)
offset230fs/sysv/truncate.ci = (inode->i_size - offset + sb->sv_ind_per_block_2_block_size_1) >> sb->sv_ind_per_block_2_block_size_bits;
offset238fs/sysv/truncate.cretry |= trunc_dindirect(inode,offset+(i<<sb->sv_ind_per_block_2_bits),ind,sb->sv_convert,&indbh->b_dirt);
offset55fs/umsdos/dir.coff_t offset,
offset65fs/umsdos/dir.cPrintk (("dir_once :%s: offset %Ld\n",zname,offset));
offset67fs/umsdos/dir.cret = d->filldir (d->dirbuf,name,name_len,offset,ino);
offset424fs/umsdos/dir.coff_t offset,
offset428fs/umsdos/dir.cd->f_pos = offset;
offset443fs/umsdos/dir.coff_t offset,
offset37fs/umsdos/ioctl.coff_t offset,
offset47fs/umsdos/ioctl.cput_user (offset,&d->ent->d_off);
offset41fs/umsdos/rdir.coff_t offset,
offset57fs/umsdos/rdir.cret = d->filldir (d->dirbuf,name,name_len,offset,ino);
offset61fs/umsdos/rdir.cret = d->filldir (d->dirbuf,name,name_len,offset,ino);
offset221fs/xiafs/bitmap.cunsigned int bit, offset;
offset240fs/xiafs/bitmap.coffset = bit & (XIAFS_BITS_PER_Z(sb) -1);
offset241fs/xiafs/bitmap.cif (!clear_bit(offset, bh->b_data))
offset72fs/xiafs/dir.cu_int offset, i;
offset81fs/xiafs/dir.coffset = filp->f_pos & (XIAFS_ZSIZE(inode->i_sb) - 1);
offset84fs/xiafs/dir.cfilp->f_pos += XIAFS_ZSIZE(inode->i_sb)-offset;
offset87fs/xiafs/dir.cfor (i = 0; i < XIAFS_ZSIZE(inode->i_sb) && i < offset; ) {
offset93fs/xiafs/dir.coffset = i;
offset94fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
offset96fs/xiafs/dir.cwhile (offset < XIAFS_ZSIZE(inode->i_sb) && filp->f_pos < inode->i_size) {
offset117fs/xiafs/dir.coffset += de->d_rec_len;
offset119fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
offset122fs/xiafs/dir.cif (offset > XIAFS_ZSIZE(inode->i_sb)) {
offset77fs/xiafs/file.cint zone_nr, zones, f_zones, offset;
offset91fs/xiafs/file.coffset = filp->f_pos;
offset92fs/xiafs/file.cleft = inode->i_size - offset;
offset98fs/xiafs/file.czone_nr = offset >> XIAFS_ZSIZE_BITS(inode->i_sb);
offset99fs/xiafs/file.coffset &= XIAFS_ZSIZE(inode->i_sb) -1 ;
offset101fs/xiafs/file.czones = (left+offset+XIAFS_ZSIZE(inode->i_sb)-1) >> XIAFS_ZSIZE_BITS(inode->i_sb);
offset156fs/xiafs/file.cif (left < XIAFS_ZSIZE(inode->i_sb) - offset)
offset159fs/xiafs/file.cchars = XIAFS_ZSIZE(inode->i_sb) - offset;
offset164fs/xiafs/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset171fs/xiafs/file.coffset = 0;
offset161fs/xiafs/namei.cint i, pos, offset;
offset186fs/xiafs/namei.coffset = 12;
offset189fs/xiafs/namei.coffset = 0;
offset190fs/xiafs/namei.cwhile (offset < XIAFS_ZSIZE(dir->i_sb)) {
offset234fs/xiafs/namei.coffset+=de->d_rec_len;
offset236fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
offset239fs/xiafs/namei.cif (offset > XIAFS_ZSIZE(dir->i_sb)) {
offset411fs/xiafs/namei.cint i, zones, offset;
offset441fs/xiafs/namei.coffset=de->d_rec_len+12;
offset444fs/xiafs/namei.coffset = 0;
offset447fs/xiafs/namei.cwhile (offset < XIAFS_ZSIZE(inode->i_sb)) {
offset448fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
offset462fs/xiafs/namei.coffset+=de->d_rec_len;
offset117include/asm-alpha/bitops.hextern inline unsigned long find_next_zero_bit(void * addr, unsigned long size, unsigned long offset)
offset119include/asm-alpha/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 6);
offset120include/asm-alpha/bitops.hunsigned long result = offset & ~63UL;
offset123include/asm-alpha/bitops.hif (offset >= size)
offset126include/asm-alpha/bitops.hoffset &= 63UL;
offset127include/asm-alpha/bitops.hif (offset) {
offset129include/asm-alpha/bitops.htmp |= ~0UL >> (64-offset);
offset416include/asm-alpha/pgtable.hextern inline pte_t mk_swap_pte(unsigned long type, unsigned long offset)
offset417include/asm-alpha/pgtable.h{ pte_t pte; pte_val(pte) = (type << 32) | (offset << 40); return pte; }
offset421include/asm-alpha/pgtable.h#define SWP_ENTRY(type,offset) pte_val(mk_swap_pte((type),(offset)))
offset93include/asm-i386/bitops.hextern inline int find_next_zero_bit (void * addr, int size, int offset)
offset95include/asm-i386/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
offset96include/asm-i386/bitops.hint set = 0, bit = offset & 31, res;
offset110include/asm-i386/bitops.hreturn set + offset;
offset118include/asm-i386/bitops.hreturn (offset + set + res);
offset335include/asm-i386/pgtable.h#define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << 8))
offset87include/asm-m68k/bitops.hint offset)
offset90include/asm-m68k/bitops.hunsigned long *p = addr + (offset >> 5);
offset91include/asm-m68k/bitops.hint set = 0, bit = offset & 31, res;
offset99include/asm-m68k/bitops.hreturn set + offset;
offset105include/asm-m68k/bitops.hreturn (offset + set + res);
offset183include/asm-mips/bitops.hextern __inline__ int find_next_zero_bit (void * addr, int size, int offset)
offset185include/asm-mips/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
offset186include/asm-mips/bitops.hint set = 0, bit = offset & 31, res;
offset207include/asm-mips/bitops.hreturn set + offset;
offset215include/asm-mips/bitops.hreturn (offset + set + res);
offset199include/asm-mips/processor.hasmlinkage void resume(struct task_struct *tsk, int offset);
offset284include/asm-sparc/bitops.hfind_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
offset291include/asm-sparc/bitops.hunsigned long *p = ((unsigned long *) addr) + (offset >> 6);
offset292include/asm-sparc/bitops.hunsigned long result = offset & ~31UL;
offset295include/asm-sparc/bitops.hif (offset >= size)
offset298include/asm-sparc/bitops.hoffset &= 31UL;
offset299include/asm-sparc/bitops.hif (offset) 
offset302include/asm-sparc/bitops.htmp |= ~0UL >> (32-offset);
offset66include/asm-sparc/mostek.hchar offset[6*1024];         /* Magic things may be here, who knows? */
offset25include/asm-sparc/sbus.hextern inline unsigned long sbus_devaddr(int slotnum, unsigned long offset)
offset27include/asm-sparc/sbus.hreturn (unsigned long) (SUN_SBUS_BVADDR+((slotnum)<<25)+(offset));
offset61include/asm-sparc/sbus.hunsigned long offset;                /* Offset given by PROM */
offset43include/linux/binfmts.hextern int read_exec(struct inode *inode, unsigned long offset,
offset120include/linux/mm.hunsigned long offset;
offset209include/linux/netdevice.hextern int    dev_get_info(char *buffer, char **start, off_t offset, int length);
offset63include/linux/nfs_fs.hint offset, int count, char *data,
offset66include/linux/nfs_fs.hint offset, int count, char *data,
offset360include/linux/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
offset131include/linux/smb_fs.hoff_t offset, long count, char *data, int fs);
offset133include/linux/smb_fs.hoff_t offset, int count, char *data);
offset79include/linux/timex.hlong offset;    /* time offset (usec) */
offset100include/linux/xd.hu_long offset;
offset53include/net/ip.hint    offset;    /* offset of fragment in IP datagram  */
offset11include/net/rarp.hoff_t offset, 
offset51include/net/route.hextern int    rt_get_info(char * buffer, char **start, off_t offset, int length);
offset605ipc/shm.cstatic pte_t shm_swap_in(struct vm_area_struct * shmd, unsigned long offset, unsigned long code)
offset627ipc/shm.cif (idx != (offset >> PAGE_SHIFT)) {
offset629ipc/shm.cidx, offset >> PAGE_SHIFT);
offset86kernel/ksyms.coff_t offset, int length, 
offset196kernel/time.cunsigned long offset = 0;
offset207kernel/time.coffset = TICK_SIZE;
offset211kernel/time.creturn offset + count;
offset370kernel/time.cif (txc.offset <= -(1 << (31 - SHIFT_UPDATE))
offset371kernel/time.c|| txc.offset >= (1 << (31 - SHIFT_UPDATE)))
offset413kernel/time.ctime_adjust = txc.offset;
offset417kernel/time.ctime_offset = txc.offset << SHIFT_UPDATE;
offset423kernel/time.cif (txc.offset < 0)
offset424kernel/time.ctime_freq -= (-txc.offset * mtemp) >>
offset427kernel/time.ctime_freq += (txc.offset * mtemp) >>
offset441kernel/time.ctxc.offset     = save_adjust;
offset66mm/filemap.cunsigned long offset,
offset84mm/filemap.cmulti_bmap(inode, offset, nr, inode->i_sb->s_blocksize_bits);
offset99mm/filemap.cunsigned long offset,
offset107mm/filemap.cfilemap_sync_page(vma, offset, page);
offset119mm/filemap.cunsigned long offset,
offset150mm/filemap.cstruct vm_area_struct *vma, unsigned long offset, unsigned int flags)
offset163mm/filemap.coffset += address & PMD_MASK;
offset169mm/filemap.cfilemap_sync_pte(pte, vma, address + offset, flags);
offset180mm/filemap.cunsigned long offset, end;
offset190mm/filemap.coffset = address & PMD_MASK;
offset196mm/filemap.cfilemap_sync_pte_range(pmd, address, end - address, vma, offset, flags);
offset494mm/memory.cunsigned long offset, pgprot_t prot)
offset505mm/memory.cif (offset >= high_memory || (mem_map[MAP_NR(offset)] & MAP_PAGE_RESERVED))
offset506mm/memory.c*pte = mk_pte(offset, prot);
offset509mm/memory.coffset += PAGE_SIZE;
offset515mm/memory.cunsigned long offset, pgprot_t prot)
offset523mm/memory.coffset -= address;
offset528mm/memory.cremap_pte_range(pte, address, end - address, address + offset, prot);
offset535mm/memory.cint remap_page_range(unsigned long from, unsigned long offset, unsigned long size, pgprot_t prot)
offset541mm/memory.coffset -= from;
offset548mm/memory.cerror = remap_pmd_range(pmd, from, end - from, offset + from, prot);
offset912mm/memory.cunsigned long offset;
offset926mm/memory.coffset = address - area->vm_start + area->vm_offset;
offset939mm/memory.cfrom_address = offset + mpnt->vm_start - mpnt->vm_offset;
offset111mm/swap.cunsigned long type, offset;
offset120mm/swap.coffset = SWP_OFFSET(entry);
offset121mm/swap.cif (offset >= p->max) {
offset125mm/swap.cif (p->swap_map && !p->swap_map[offset]) {
offset133mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
offset140mm/swap.cll_rw_page(rw,p->swap_device,offset,buf);
offset160mm/swap.cunsigned int block = offset << 3;
offset170mm/swap.cunsigned int block = offset
offset182mm/swap.cif (offset && !clear_bit(offset,p->swap_lockmap))
offset190mm/swap.cunsigned long offset, entry;
offset200mm/swap.cfor (offset = p->lowest_bit; offset <= p->highest_bit ; offset++) {
offset201mm/swap.cif (p->swap_map[offset])
offset203mm/swap.cif (test_bit(offset, p->swap_lockmap))
offset205mm/swap.cp->swap_map[offset] = 1;
offset207mm/swap.cif (offset == p->highest_bit)
offset209mm/swap.cp->lowest_bit = offset;
offset210mm/swap.centry = SWP_ENTRY(type,offset);
offset236mm/swap.cunsigned long offset, type;
offset240mm/swap.coffset = SWP_OFFSET(entry);
offset249mm/swap.cif (offset >= p->max) {
offset253mm/swap.cif (!p->swap_map[offset]) {
offset257mm/swap.cp->swap_map[offset]++;
offset264mm/swap.cunsigned long offset, type;
offset276mm/swap.coffset = SWP_OFFSET(entry);
offset277mm/swap.cif (offset >= p->max) {
offset285mm/swap.cif (offset < p->lowest_bit)
offset286mm/swap.cp->lowest_bit = offset;
offset287mm/swap.cif (offset > p->highest_bit)
offset288mm/swap.cp->highest_bit = offset;
offset289mm/swap.cif (!p->swap_map[offset])
offset292mm/swap.cif (!--p->swap_map[offset])
offset871mm/swap.cunsigned long address, unsigned long size, unsigned long offset,
offset885mm/swap.coffset += address & PMD_MASK;
offset891mm/swap.cif (unuse_pte(vma, offset+address-vma->vm_start, pte, type, page))
offset904mm/swap.cunsigned long offset, end;
offset914mm/swap.coffset = address & PGDIR_MASK;
offset920mm/swap.cif (unuse_pmd(vma, pmd, address, end - address, offset, type, page))
offset241net/802/tr.cint rif_get_info(char *buffer,char **start, off_t offset, int length) {
offset264net/802/tr.cif(pos<offset) {
offset268net/802/tr.cif(pos>offset+length)
offset271net/802/tr.cif(pos>offset+length)
offset275net/802/tr.c*start=buffer+(offset-begin); /* Start of wanted data */
offset276net/802/tr.clen-=(offset-begin);    /* Start slop */
offset211net/appletalk/ddp.cint atalk_get_info(char *buffer, char **start, off_t offset, int length)
offset238net/appletalk/ddp.cif(pos<offset)
offset243net/appletalk/ddp.cif(pos>offset+length)    /* We have dumped enough */
offset248net/appletalk/ddp.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset249net/appletalk/ddp.clen-=(offset-begin);    /* Remove unwanted header data from length */
offset810net/appletalk/ddp.cint atalk_if_get_info(char *buffer, char **start, off_t offset, int length)
offset826net/appletalk/ddp.cif(pos<offset)
offset831net/appletalk/ddp.cif(pos>offset+length)
offset834net/appletalk/ddp.c*start=buffer+(offset-begin);
offset835net/appletalk/ddp.clen-=(offset-begin);
offset843net/appletalk/ddp.cint atalk_rt_get_info(char *buffer, char **start, off_t offset, int length)
offset865net/appletalk/ddp.cif(pos<offset)
offset870net/appletalk/ddp.cif(pos>offset+length)
offset873net/appletalk/ddp.c*start=buffer+(offset-begin);
offset874net/appletalk/ddp.clen-=(offset-begin);
offset1866net/ax25/af_ax25.cint ax25_get_info(char *buffer, char **start, off_t offset, int length)
offset1911net/ax25/af_ax25.cif (pos < offset) {
offset1916net/ax25/af_ax25.cif (pos > offset + length)
offset1922net/ax25/af_ax25.c*start = buffer + (offset - begin);
offset1923net/ax25/af_ax25.clen   -= (offset - begin);
offset139net/ax25/ax25_route.cint ax25_rt_get_info(char *buffer, char **start, off_t offset, int length)
offset173net/ax25/ax25_route.cif (pos < offset) {
offset178net/ax25/ax25_route.cif (pos > offset + length)
offset184net/ax25/ax25_route.c*start = buffer + (offset - begin);
offset185net/ax25/ax25_route.clen   -= (offset - begin);
offset192net/ax25/ax25_route.cint ax25_cs_get_info(char *buffer, char **start, off_t offset, int length)
offset208net/ax25/ax25_route.cif (pos < offset) {
offset213net/ax25/ax25_route.cif (pos > offset + length)
offset219net/ax25/ax25_route.c*start = buffer + (offset - begin);
offset220net/ax25/ax25_route.clen   -= offset - begin;
offset164net/core/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
offset168net/core/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
offset904net/core/dev.cint dev_get_info(char *buffer, char **start, off_t offset, int length)
offset927net/core/dev.cif(pos<offset)
offset932net/core/dev.cif(pos>offset+length)
offset936net/core/dev.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset937net/core/dev.clen-=(offset-begin);    /* Start slop */
offset587net/core/skbuff.cunsigned long offset;
offset603net/core/skbuff.coffset=n->head-skb->head;
offset615net/core/skbuff.cn->h.raw=skb->h.raw+offset;
offset616net/core/skbuff.cn->mac.raw=skb->mac.raw+offset;
offset617net/core/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
offset1000net/ipv4/arp.cint arp_get_info(char *buffer, char **start, off_t offset, int length)
offset1061net/ipv4/arp.cif(pos<offset)
offset1066net/ipv4/arp.cif(pos>offset+length)
offset1072net/ipv4/arp.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset1073net/ipv4/arp.clen-=(offset-begin);    /* Start slop */
offset105net/ipv4/icmp.cint offset;
offset232net/ipv4/icmp.coffset = ip_build_header(skb, our_addr, iph->saddr,
offset235net/ipv4/icmp.cif (offset < 0) 
offset253net/ipv4/icmp.cicmph = (struct icmphdr *) (skb->data + offset);
offset433net/ipv4/icmp.cint size, offset;
offset450net/ipv4/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev,
offset452net/ipv4/icmp.cif (offset < 0) 
offset470net/ipv4/icmp.cicmphr = (struct icmphdr *) (skb2->data + offset);
offset499net/ipv4/icmp.cint size, offset;
offset527net/ipv4/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev, IPPROTO_ICMP, opt, len, 
offset529net/ipv4/icmp.cif (offset < 0) 
offset547net/ipv4/icmp.cicmphr = (struct icmphdr *) ((char *) (skb2 + 1) + offset);
offset597net/ipv4/icmp.cint size, offset;
offset617net/ipv4/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev,
offset619net/ipv4/icmp.cif (offset < 0) 
offset638net/ipv4/icmp.cicmphr = (struct icmphdr *) (skb2->data + offset);
offset350net/ipv4/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
offset363net/ipv4/ip.cfp->offset = offset;
offset365net/ipv4/ip.cfp->len = end - offset;
offset546net/ipv4/ip.cint offset;
offset554net/ipv4/ip.coffset = 0;
offset557net/ipv4/ip.cif (fp->offset > offset)
offset559net/ipv4/ip.coffset = fp->end;
offset621net/ipv4/ip.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
offset651net/ipv4/ip.cint flags, offset;
offset660net/ipv4/ip.coffset = ntohs(iph->frag_off);
offset661net/ipv4/ip.cflags = offset & ~IP_OFFSET;
offset662net/ipv4/ip.coffset &= IP_OFFSET;
offset663net/ipv4/ip.cif (((flags & IP_MF) == 0) && (offset == 0))
offset670net/ipv4/ip.coffset <<= 3;    /* offset is in 8-byte chunks */
offset705net/ipv4/ip.cend = offset + ntohs(iph->tot_len) - ihl;
offset729net/ipv4/ip.cif (next->offset > offset)
offset739net/ipv4/ip.cif (prev != NULL && offset < prev->end)
offset741net/ipv4/ip.ci = prev->end - offset;
offset742net/ipv4/ip.coffset += i;  /* ptr into datagram */
offset754net/ipv4/ip.cif (tmp->offset >= end)
offset757net/ipv4/ip.ci = end - next->offset;      /* overlap is 'i' bytes */
offset759net/ipv4/ip.ctmp->offset += i;      /* next fragment  */
offset787net/ipv4/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
offset845net/ipv4/ip.cint offset;
offset905net/ipv4/ip.coffset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
offset907net/ipv4/ip.coffset = 0;
offset981net/ipv4/ip.ciph->frag_off = htons((offset >> 3));
offset989net/ipv4/ip.coffset += len;
offset1933net/ipv4/ip.cint ip_mc_procinfo(char *buffer, char **start, off_t offset, int length)
offset1958net/ipv4/ip.cif(pos<offset)
offset1963net/ipv4/ip.cif(pos>offset+length)
offset1969net/ipv4/ip.c*start=buffer+(offset-begin);
offset1970net/ipv4/ip.clen-=(offset-begin);
offset2340net/ipv4/ip.cint offset, mf;
offset2439net/ipv4/ip.coffset = length - (length % (maxfraglen - fragheaderlen));
offset2445net/ipv4/ip.cfraglen = length - offset + fragheaderlen;
offset2450net/ipv4/ip.coffset -= maxfraglen-fragheaderlen;
offset2464net/ipv4/ip.cif (type == IPPROTO_RAW && offset > 0)
offset2543net/ipv4/ip.ciph->frag_off = htons(offset>>3);
offset2569net/ipv4/ip.cgetfrag(frag, saddr, data, offset, fraglen-fragheaderlen);
offset2576net/ipv4/ip.cif(!offset)
offset2579net/ipv4/ip.coffset -= (maxfraglen-fragheaderlen);
offset2646net/ipv4/ip.cwhile (offset >= 0);
offset1370net/ipv4/ip_fw.coff_t offset, int length, int reset)
offset1421net/ipv4/ip_fw.cif(pos<offset)
offset1432net/ipv4/ip_fw.cif(pos>offset+length)
offset1437net/ipv4/ip_fw.c*start=buffer+(offset-begin);
offset1438net/ipv4/ip_fw.clen-=(offset-begin);
offset1447net/ipv4/ip_fw.cint ip_acct_procinfo(char *buffer, char **start, off_t offset, int length, int reset)
offset1449net/ipv4/ip_fw.creturn ip_chain_procinfo(IP_INFO_ACCT, buffer,start,offset,length,reset);
offset1456net/ipv4/ip_fw.cint ip_fw_blk_procinfo(char *buffer, char **start, off_t offset, int length, int reset)
offset1458net/ipv4/ip_fw.creturn ip_chain_procinfo(IP_INFO_BLK, buffer,start,offset,length,reset);
offset1461net/ipv4/ip_fw.cint ip_fw_fwd_procinfo(char *buffer, char **start, off_t offset, int length, int reset)
offset1463net/ipv4/ip_fw.creturn ip_chain_procinfo(IP_INFO_FWD, buffer,start,offset,length,reset);
offset1469net/ipv4/ip_fw.cint ip_msqhst_procinfo(char *buffer, char **start, off_t offset, int length)
offset1496net/ipv4/ip_fw.cif(pos<offset) 
offset1501net/ipv4/ip_fw.cif(pos>offset+length)
offset1506net/ipv4/ip_fw.c*start=buffer+(offset-begin);
offset1507net/ipv4/ip_fw.clen-=(offset-begin);
offset58net/ipv4/proc.cget__netinfo(struct proto *pro, char *buffer, int format, char **start, off_t offset, int length)
offset126net/ipv4/proc.cif(pos<offset)
offset131net/ipv4/proc.cif(pos>offset+length)
offset136net/ipv4/proc.cif(pos>offset+length)
offset139net/ipv4/proc.c*start=buffer+(offset-begin);
offset140net/ipv4/proc.clen-=(offset-begin);
offset147net/ipv4/proc.cint tcp_get_info(char *buffer, char **start, off_t offset, int length)
offset149net/ipv4/proc.creturn get__netinfo(&tcp_prot, buffer,0, start, offset, length);
offset153net/ipv4/proc.cint udp_get_info(char *buffer, char **start, off_t offset, int length)
offset155net/ipv4/proc.creturn get__netinfo(&udp_prot, buffer,1, start, offset, length);
offset159net/ipv4/proc.cint raw_get_info(char *buffer, char **start, off_t offset, int length)
offset161net/ipv4/proc.creturn get__netinfo(&raw_prot, buffer,1, start, offset, length);
offset168net/ipv4/proc.cint afinet_get_info(char *buffer, char **start, off_t offset, int length)
offset174net/ipv4/proc.cint len  = socket_get_info(buffer,start,offset,length);
offset185net/ipv4/proc.c*start = buffer + offset;
offset186net/ipv4/proc.clen -= offset;
offset197net/ipv4/proc.cint snmp_get_info(char *buffer, char **start, off_t offset, int length)
offset257net/ipv4/proc.cif (offset >= len)
offset262net/ipv4/proc.c*start = buffer + offset;
offset263net/ipv4/proc.clen -= offset;
offset427net/ipv4/rarp.cint rarp_get_info(char *buffer, char **start, off_t offset, int length)
offset473net/ipv4/rarp.cif(pos<offset)
offset478net/ipv4/rarp.cif(pos>offset+length)
offset484net/ipv4/rarp.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset485net/ipv4/rarp.clen-=(offset-begin);    /* Start slop */
offset130net/ipv4/raw.cstatic void raw_getfrag(void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
offset132net/ipv4/raw.cmemcpy_fromfs(to, (unsigned char *)p+offset, fraglen);
offset139net/ipv4/raw.cstatic void raw_getrawfrag(void *p, int saddr, char *to, unsigned int offset, unsigned int fraglen)
offset141net/ipv4/raw.cmemcpy_fromfs(to, (unsigned char *)p+offset, fraglen);
offset142net/ipv4/raw.cif(offset==0)
offset511net/ipv4/route.cint rt_get_info(char *buffer, char **start, off_t offset, int length)
offset535net/ipv4/route.cif(pos<offset)
offset540net/ipv4/route.cif(pos>offset+length)
offset544net/ipv4/route.c*start=buffer+(offset-begin);
offset545net/ipv4/route.clen-=(offset-begin);
offset2023net/ipv4/tcp.cu32 offset;
offset2045net/ipv4/tcp.coffset = *seq - skb->h.th->seq;
offset2047net/ipv4/tcp.coffset--;
offset2048net/ipv4/tcp.cif (offset < skb->len)
offset2119net/ipv4/tcp.cused = skb->len - offset;
offset2136net/ipv4/tcp.coffset++;
offset2159net/ipv4/tcp.cskb->h.th->doff*4 + offset, used);
offset2174net/ipv4/tcp.cif (used + offset < skb->len)
offset188net/ipv4/udp.cstatic void udp_getfrag(void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen) 
offset194net/ipv4/udp.cif (offset) 
offset197net/ipv4/udp.csrc = ufh->from+(offset-sizeof(struct udphdr));
offset207net/ipv4/udp.cif (offset == 0) 
offset227net/ipv4/udp.cstatic void udp_getfrag_nosum(void *p, int saddr, char * to, unsigned int offset, unsigned int fraglen) 
offset233net/ipv4/udp.cif (offset) 
offset236net/ipv4/udp.csrc = ufh->from+(offset-sizeof(struct udphdr));
offset246net/ipv4/udp.cif (offset == 0) 
offset1121net/ipx/af_ipx.cipx_get_interface_info(char *buffer, char **start, off_t offset, int length)
offset1146net/ipx/af_ipx.cif(pos<offset) {
offset1150net/ipx/af_ipx.cif(pos>offset+length)    /* We have dumped enough */
offset1155net/ipx/af_ipx.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset1156net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
offset1164net/ipx/af_ipx.cipx_get_info(char *buffer, char **start, off_t offset, int length)
offset1201net/ipx/af_ipx.cif(pos<offset)
offset1206net/ipx/af_ipx.cif(pos>offset+length)    /* We have dumped enough */
offset1212net/ipx/af_ipx.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset1213net/ipx/af_ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
offset1220net/ipx/af_ipx.cint ipx_rt_get_info(char *buffer, char **start, off_t offset, int length)
offset1243net/ipx/af_ipx.cif(pos<offset)
offset1248net/ipx/af_ipx.cif(pos>offset+length)
offset1251net/ipx/af_ipx.c*start=buffer+(offset-begin);
offset1252net/ipx/af_ipx.clen-=(offset-begin);
offset1254net/netrom/af_netrom.cint nr_get_info(char *buffer, char **start, off_t offset, int length)
offset1287net/netrom/af_netrom.cif (pos < offset) {
offset1292net/netrom/af_netrom.cif (pos > offset + length)
offset1298net/netrom/af_netrom.c*start = buffer + (offset - begin);
offset1299net/netrom/af_netrom.clen   -= (offset - begin);
offset684net/netrom/nr_route.cint nr_nodes_get_info(char *buffer, char **start, off_t offset, int length)
offset714net/netrom/nr_route.cif (pos < offset) {
offset719net/netrom/nr_route.cif (pos > offset + length)
offset725net/netrom/nr_route.c*start = buffer + (offset - begin);
offset726net/netrom/nr_route.clen   -= (offset - begin);
offset733net/netrom/nr_route.cint nr_neigh_get_info(char *buffer, char **start, off_t offset, int length)
offset755net/netrom/nr_route.cif (pos < offset) {
offset760net/netrom/nr_route.cif (pos > offset + length)
offset766net/netrom/nr_route.c*start = buffer + (offset - begin);
offset767net/netrom/nr_route.clen   -= (offset - begin);
offset68net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset,
offset307net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
offset1305net/socket.cint socket_get_info(char *buffer, char **start, off_t offset, int length)
offset1308net/socket.cif (offset >= len)
offset1313net/socket.c*start = buffer + offset;
offset1314net/socket.clen -= offset;
offset39net/unix/proc.cint unix_get_info(char *buffer, char **start, off_t offset, int length)
offset83net/unix/proc.cif(pos<offset)
offset88net/unix/proc.cif(pos>offset+length)
offset95net/unix/proc.c*start=buffer+(offset-begin);
offset96net/unix/proc.clen-=(offset-begin);