taglinefilesource code
offset45drivers/FPU-emu/fpu_aux.coperand_address.offset = 0;
offset47drivers/FPU-emu/fpu_aux.cinstruction_address.offset = 0;
offset97drivers/FPU-emu/fpu_emu.hunsigned int offset;
offset315drivers/FPU-emu/fpu_entry.centry_sel_off.offset = FPU_ORIG_EIP;
offset516drivers/FPU-emu/fpu_entry.coperand_address.offset = 0;
offset77drivers/FPU-emu/get_address.clong offset;
offset89drivers/FPU-emu/get_address.coffset = 0;              /* No base register */
offset91drivers/FPU-emu/get_address.coffset = REG_(base);
offset102drivers/FPU-emu/get_address.coffset += (REG_(index)) << ss;
offset110drivers/FPU-emu/get_address.coffset += (signed char) get_fs_byte((char *) (*fpu_eip));
offset119drivers/FPU-emu/get_address.coffset += (signed) get_fs_long((unsigned long *) (*fpu_eip));
offset124drivers/FPU-emu/get_address.creturn offset;
offset146drivers/FPU-emu/get_address.cunsigned short *selector, long offset)
offset164drivers/FPU-emu/get_address.caddress = base_address + offset;
offset254drivers/FPU-emu/get_address.caddr->offset = address;
offset261drivers/FPU-emu/get_address.caddr->offset = address;
offset287drivers/FPU-emu/get_address.caddr->offset = address;
offset403drivers/FPU-emu/get_address.caddr->offset = address;
offset1164drivers/FPU-emu/reg_ld_str.cinstruction_address.offset = get_fs_word((unsigned short *) (s+6));
offset1166drivers/FPU-emu/reg_ld_str.coperand_address.offset = get_fs_word((unsigned short *) (s+0x0a));
offset1172drivers/FPU-emu/reg_ld_str.cinstruction_address.offset
offset1174drivers/FPU-emu/reg_ld_str.coperand_address.offset += (operand_address.selector & 0xf000) << 4;
offset1184drivers/FPU-emu/reg_ld_str.cinstruction_address.offset = get_fs_long((unsigned long *) (s+0x0c));
offset1187drivers/FPU-emu/reg_ld_str.coperand_address.offset = get_fs_long((unsigned long *) (s+0x14));
offset1305drivers/FPU-emu/reg_ld_str.cput_fs_word(instruction_address.offset, (unsigned short *) (d+6));
offset1306drivers/FPU-emu/reg_ld_str.cput_fs_word(operand_address.offset, (unsigned short *) (d+0x0a));
offset1309drivers/FPU-emu/reg_ld_str.cput_fs_word((instruction_address.offset & 0xf0000) >> 4,
offset1311drivers/FPU-emu/reg_ld_str.cput_fs_word((operand_address.offset & 0xf0000) >> 4,
offset1336drivers/FPU-emu/reg_ld_str.cput_fs_long(instruction_address.offset, (unsigned long *) (d+0x0c));
offset1339drivers/FPU-emu/reg_ld_str.cput_fs_long(operand_address.offset, (unsigned long *) (d+0x14));
offset145drivers/block/xd.cif (!memcmp(xd_bases[i] + xd_sigs[j].offset,xd_sigs[j].string,strlen(xd_sigs[j].string))) {
offset362drivers/char/console.cstatic inline void __set_origin(unsigned short offset)
offset369drivers/char/console.c__origin = offset;
offset371drivers/char/console.coutb_p(offset >> 8, video_port_val);
offset373drivers/char/console.coutb_p(offset, video_port_val);
offset294drivers/char/lp.coff_t offset, int origin)
offset449drivers/char/lp.cint offset = 0;
offset458drivers/char/lp.cfor (offset = 0; offset < LP_NO; offset++) {
offset460drivers/char/lp.coutb_p( LP_DUMMY, LP_B(offset));
offset463drivers/char/lp.ctestvalue = inb_p(LP_B(offset));
offset465drivers/char/lp.cLP_F(offset) |= LP_EXIST;
offset466drivers/char/lp.clp_reset(offset);
offset467drivers/char/lp.cprintk("lp_init: lp%d exists, ", offset);
offset468drivers/char/lp.cif (LP_IRQ(offset))
offset469drivers/char/lp.cprintk("using IRQ%d\n", LP_IRQ(offset));
offset486drivers/char/lp.cint offset = 0;
offset495drivers/char/lp.cfor (offset = 0; offset < LP_NO; offset++) {
offset497drivers/char/lp.coutb_p( LP_DUMMY, LP_B(offset));
offset500drivers/char/lp.ctestvalue = inb_p(LP_B(offset));
offset502drivers/char/lp.cLP_F(offset) |= LP_EXIST;
offset503drivers/char/lp.clp_reset(offset);
offset504drivers/char/lp.cprintk("lp_init: lp%d exists, ", offset);
offset505drivers/char/lp.cif (LP_IRQ(offset))
offset506drivers/char/lp.cprintk("using IRQ%d\n", LP_IRQ(offset));
offset186drivers/char/mem.cstatic int null_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset198drivers/char/mem.cstatic int memory_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset202drivers/char/mem.cfile->f_pos = offset;
offset205drivers/char/mem.cfile->f_pos += offset;
offset230drivers/char/serial.cstatic inline unsigned int serial_in(struct async_struct *info, int offset)
offset234drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset238drivers/char/serial.creturn inb(info->port + offset);
offset241drivers/char/serial.cstatic inline unsigned int serial_inp(struct async_struct *info, int offset)
offset245drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset250drivers/char/serial.creturn inb(info->port + offset);
offset252drivers/char/serial.creturn inb_p(info->port + offset);
offset256drivers/char/serial.cstatic inline void serial_out(struct async_struct *info, int offset, int value)
offset260drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset264drivers/char/serial.coutb(value, info->port+offset);
offset267drivers/char/serial.cstatic inline void serial_outp(struct async_struct *info, int offset,
offset272drivers/char/serial.coutb(info->hub6 - 1 + offset, info->port);
offset277drivers/char/serial.coutb(value, info->port+offset);
offset279drivers/char/serial.coutb_p(value, info->port+offset);
offset1878drivers/char/tpqic02.cstatic int qic02_tape_lseek(struct inode * inode, struct file * file, off_t offset, int origin)
offset274drivers/char/tty_io.cstatic int tty_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
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)
offset398drivers/net/depca.cunsigned int nicsr, offset, netRAM;
offset486drivers/net/depca.coffset = 0x8000;              /* 32kbyte RAM offset*/
offset490drivers/net/depca.coffset = 0x0000;
offset493drivers/net/depca.coffset = 0x0000;              /* 64k/48k bytes RAM */
offset497drivers/net/depca.cmem_start += offset;            /* (E)ISA start address */
offset517drivers/net/depca.cj = (((netRAM << 10) - offset - sizeof(struct depca_private)) / 
offset132drivers/net/ne.cstruct {unsigned char value, offset; } program_seq[] = {
offset148drivers/net/ne.coutb_p(program_seq[i].value, ioaddr + program_seq[i].offset);
offset1297drivers/scsi/53c7,8xx.h#define patch_abs_32(script, offset, symbol, value)      \
offset1300drivers/scsi/53c7,8xx.h(script)[A_##symbol##_used[i] - (offset)] += (value);  \
offset1304drivers/scsi/53c7,8xx.h(offset), #script, (script)[A_##symbol##_used[i] -   \
offset1305drivers/scsi/53c7,8xx.h(offset)]);            \
offset1308drivers/scsi/53c7,8xx.h#define patch_abs_rwri_data(script, offset, symbol, value)          \
offset1311drivers/scsi/53c7,8xx.h(script)[A_##symbol##_used[i] - (offset)] =      \
offset1312drivers/scsi/53c7,8xx.h((script)[A_##symbol##_used[i] - (offset)] &     \
offset1670drivers/scsi/scsi.cint offset;
offset1677drivers/scsi/scsi.coffset = ((int) obj) - ((int) dma_malloc_buffer);
offset1679drivers/scsi/scsi.cif (offset < 0) panic("Bad offset");
offset1680drivers/scsi/scsi.cpage = offset >> 13;
offset1681drivers/scsi/scsi.csector = offset >> 9;
offset1684drivers/scsi/scsi.csector = (offset >> 9) & 15;
offset149drivers/scsi/seagate.cunsigned offset;
offset322drivers/scsi/seagate.csignatures[j].offset), (void *) signatures[j].signature,
offset145drivers/scsi/sr.cint offset;
offset146drivers/scsi/sr.coffset = (SCpnt->request.sector % 4) << 9;
offset148drivers/scsi/sr.c(char *)SCpnt->buffer + offset, 
offset154drivers/scsi/sr.cif((offset == 0) && this_count == 2 &&
offset264drivers/scsi/st.cint offset, transfer, blks;
offset288drivers/scsi/st.coffset = (STp->buffer)->buffer_bytes;
offset289drivers/scsi/st.ctransfer = ((offset + STp->block_size - 1) /
offset295drivers/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, 
offset411drivers/sound/audio.caudio_lseek (int dev, struct fileinfo *file, off_t offset, int orig)
offset1844drivers/sound/sequencer.csequencer_lseek (int dev, struct fileinfo *file, off_t offset, int orig)
offset30drivers/sound/sound_calls.hint audio_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset43drivers/sound/sound_calls.hint sequencer_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset65drivers/sound/sound_calls.hint MIDIbuf_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset242drivers/sound/sound_calls.hint pss_lseek (int dev, struct fileinfo *file, off_t offset, int orig);
offset76drivers/sound/soundcard.csound_lseek (struct inode *inode, struct file *file, off_t offset, int orig)
offset24fs/block_dev.cloff_t offset;
offset53fs/block_dev.coffset = filp->f_pos & (blocksize-1);
offset62fs/block_dev.cchars = blocksize - offset;
offset112fs/block_dev.cp = offset + bh->b_data;
offset113fs/block_dev.coffset = 0;
offset157fs/block_dev.cloff_t offset;
offset183fs/block_dev.coffset = filp->f_pos;
offset191fs/block_dev.cif (offset > size)
offset194fs/block_dev.cleft = size - offset;
offset200fs/block_dev.cblock = offset >> blocksize_bits;
offset201fs/block_dev.coffset &= blocksize-1;
offset203fs/block_dev.crblocks = blocks = (left + offset + blocksize - 1) >> blocksize_bits;
offset271fs/block_dev.cif (left < blocksize - offset)
offset274fs/block_dev.cchars = blocksize - offset;
offset279fs/block_dev.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset286fs/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);
offset988fs/buffer.cunsigned long offset;
offset1000fs/buffer.cfor (offset = size ; offset < PAGE_SIZE ; offset += size) {
offset1008fs/buffer.cif (page+offset != (unsigned long) first->b_data)
offset1028fs/buffer.cunsigned long offset;
offset1038fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
offset1507fs/buffer.cunsigned long offset;
offset1520fs/buffer.cfor (offset = 0 ; offset < PAGE_SIZE ; offset += size) {
offset1562fs/buffer.cint i, offset;
offset1564fs/buffer.cfor (i = 0, offset = 0 ; offset < PAGE_SIZE ; i++, offset += size) {
offset144fs/exec.c#define DUMP_SEEK(offset) \
offset146fs/exec.cif (file.f_op->lseek(inode,&file,(offset),0) != (offset)) \
offset148fs/exec.c} else file.f_pos = (offset)    
offset393fs/exec.cint len, offset = 0;
offset419fs/exec.cif (--offset < 0) {
offset420fs/exec.coffset = p % PAGE_SIZE;
offset431fs/exec.c*(pag + offset) = get_fs_byte(tmp);
offset464fs/exec.cint read_exec(struct inode *inode, unsigned long offset,
offset485fs/exec.cif (file.f_op->lseek(inode,&file,offset,0) != offset)
offset488fs/exec.cfile.f_pos = offset;
offset68fs/ext/dir.coff_t offset;
offset78fs/ext/dir.coffset = filp->f_pos & 1023;
offset81fs/ext/dir.cfilp->f_pos += 1024-offset;
offset84fs/ext/dir.cde = (struct ext_dir_entry *) (offset + bh->b_data);
offset85fs/ext/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
offset91fs/ext/dir.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
offset92fs/ext/dir.cfilp->f_pos += 1024-offset;
offset97fs/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;
offset92fs/ext/namei.clong offset;
offset113fs/ext/namei.coffset = 0;
offset115fs/ext/namei.cwhile (offset < dir->i_size) {
offset119fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
offset131fs/ext/namei.cdir->i_dev, dir->i_ino, offset, de->rec_len, de->name_len);
offset133fs/ext/namei.coffset = ((offset / BLOCK_SIZE) + 1) * BLOCK_SIZE;
offset141fs/ext/namei.cif (offset + de->rec_len < dir->i_size &&
offset149fs/ext/namei.coffset += de->rec_len;
offset200fs/ext/namei.clong offset;
offset221fs/ext/namei.coffset = 0;
offset224fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
offset230fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,0);
offset235fs/ext/namei.cif (offset >= dir->i_size) {
offset237fs/ext/namei.cif (offset % BLOCK_SIZE == 0  ||
offset238fs/ext/namei.c(BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) {
offset239fs/ext/namei.cif ((offset % BLOCK_SIZE) != 0) {
offset245fs/ext/namei.c- (offset & (BLOCK_SIZE - 1));
offset247fs/ext/namei.coffset += de->rec_len;
offset260fs/ext/namei.cbh = ext_bread(dir,offset>>BLOCK_SIZE_BITS,1);
offset279fs/ext/namei.cdir->i_dev, dir->i_ino, offset, de->rec_len, de->name_len);
offset304fs/ext/namei.coffset += de->rec_len;
offset477fs/ext/namei.cunsigned long offset;
offset492fs/ext/namei.coffset = de->rec_len + de1->rec_len;
offset494fs/ext/namei.cwhile (offset < inode->i_size ) {
offset497fs/ext/namei.cbh = ext_bread(inode, offset >> BLOCK_SIZE_BITS,1);
offset499fs/ext/namei.coffset += BLOCK_SIZE;
offset508fs/ext/namei.cinode->i_dev, inode->i_ino, offset, de->rec_len, de->name_len);
offset516fs/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);
offset73fs/ext2/dir.cunsigned long offset)
offset92fs/ext2/dir.cerror_msg, offset, de->inode, de->rec_len,
offset100fs/ext2/dir.cunsigned long offset, blk;
offset111fs/ext2/dir.coffset = filp->f_pos & (sb->s_blocksize - 1);
offset115fs/ext2/dir.cfilp->f_pos += sb->s_blocksize - offset;
offset122fs/ext2/dir.cif (!offset) {
offset138fs/ext2/dir.cde = (struct ext2_dir_entry *) (offset + bh->b_data);
offset139fs/ext2/dir.cwhile (offset < sb->s_blocksize && filp->f_pos < inode->i_size) {
offset141fs/ext2/dir.cbh, offset)) {
offset145fs/ext2/dir.coffset += de->rec_len;
offset83fs/ext2/file.cint block, blocks, offset;
offset103fs/ext2/file.coffset = filp->f_pos;
offset105fs/ext2/file.cif (offset > size)
offset108fs/ext2/file.cleft = size - offset;
offset114fs/ext2/file.cblock = offset >> EXT2_BLOCK_SIZE_BITS(sb);
offset115fs/ext2/file.coffset &= (sb->s_blocksize - 1);
offset117fs/ext2/file.cblocks = (left + offset + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
offset190fs/ext2/file.cif (left < sb->s_blocksize - offset)
offset193fs/ext2/file.cchars = sb->s_blocksize - offset;
offset198fs/ext2/file.cmemcpy_tofs (buf, offset + (*bhe)->b_data,
offset206fs/ext2/file.coffset = 0;
offset74fs/ext2/namei.cunsigned long offset;
offset104fs/ext2/namei.coffset = 0;
offset105fs/ext2/namei.cwhile (offset < dir->i_size) {
offset130fs/ext2/namei.cde, bh, offset))
offset140fs/ext2/namei.coffset += de->rec_len;
offset221fs/ext2/namei.cunsigned long offset;
offset253fs/ext2/namei.coffset = 0;
offset260fs/ext2/namei.cbh = ext2_bread (dir, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, err);
offset263fs/ext2/namei.cif (dir->i_size <= offset) {
offset274fs/ext2/namei.cdir->i_size = offset + sb->s_blocksize;
offset284fs/ext2/namei.coffset)) {
offset296fs/ext2/namei.coffset += de->rec_len;
offset326fs/ext2/namei.coffset += de->rec_len;
offset549fs/ext2/namei.cunsigned long offset;
offset570fs/ext2/namei.coffset = de->rec_len + de1->rec_len;
offset572fs/ext2/namei.cwhile (offset < inode->i_size ) {
offset575fs/ext2/namei.cbh = ext2_bread (inode, offset >> EXT2_BLOCK_SIZE_BITS(sb), 1, &err);
offset577fs/ext2/namei.coffset += sb->s_blocksize;
offset583fs/ext2/namei.coffset)) {
offset591fs/ext2/namei.coffset += de->rec_len;
offset413fs/ext2/super.cunsigned long offset;
offset418fs/ext2/super.coffset = (sb_block*BLOCK_SIZE) % sb->s_blocksize;
offset422fs/ext2/super.ces = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
offset105fs/ext2/truncate.cstatic int trunc_indirect (struct inode * inode, int offset, unsigned long * p)
offset116fs/ext2/truncate.c#define INDIRECT_BLOCK ((int)DIRECT_BLOCK - offset)
offset201fs/ext2/truncate.cstatic int trunc_dindirect (struct inode * inode, int offset,
offset210fs/ext2/truncate.c#define DINDIRECT_BLOCK (((int)DIRECT_BLOCK - offset) / addr_per_block)
offset235fs/ext2/truncate.cretry |= trunc_indirect (inode, offset + (i * addr_per_block),
offset65fs/isofs/dir.cunsigned int block,offset,i, j;
offset79fs/isofs/dir.coffset = filp->f_pos & (bufsize - 1);
offset90fs/isofs/dir.cblock, offset, filp->f_pos);
offset92fs/isofs/dir.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset93fs/isofs/dir.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
offset101fs/isofs/dir.coffset = 0;
offset117fs/isofs/dir.cold_offset = offset;
offset118fs/isofs/dir.coffset += *((unsigned char *) de);
offset121fs/isofs/dir.cif (offset >=  bufsize) {
offset128fs/isofs/dir.coffset = filp->f_pos & (bufsize - 1);
offset136fs/isofs/dir.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset122fs/isofs/file.cint block, blocks, offset;
offset149fs/isofs/file.coffset = filp->f_pos & (ISOFS_BUFFER_SIZE(inode)-1);
offset150fs/isofs/file.cblocks = (left + offset + ISOFS_BUFFER_SIZE(inode) - 1) / ISOFS_BUFFER_SIZE(inode);
offset208fs/isofs/file.cif (left < ISOFS_BUFFER_SIZE(inode) - offset)
offset211fs/isofs/file.cchars = ISOFS_BUFFER_SIZE(inode) - offset;
offset218fs/isofs/file.cunixify_to_fs(buf, offset+(*bhe)->b_data, chars, 
offset221fs/isofs/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset228fs/isofs/file.coffset = 0;
offset349fs/isofs/inode.cint frag1, offset;
offset351fs/isofs/inode.coffset = (inode->i_ino & (bufsize - 1));
offset352fs/isofs/inode.cfrag1 = bufsize - offset;
offset359fs/isofs/inode.cmemcpy(cpnt, bh->b_data + offset, frag1);
offset366fs/isofs/inode.coffset += *pnt - bufsize;
offset367fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset541fs/isofs/inode.cunsigned int block,offset;
offset550fs/isofs/inode.coffset = 0;
offset555fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset562fs/isofs/inode.coffset += *((unsigned char *) de);
offset564fs/isofs/inode.cif (offset >= bufsize) 
offset587fs/isofs/inode.coffset = 0;
offset594fs/isofs/inode.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset595fs/isofs/inode.cinode_number = (block << bufbits)+(offset & (bufsize - 1));
offset604fs/isofs/inode.coffset = 0;
offset620fs/isofs/inode.cold_offset = offset;
offset621fs/isofs/inode.coffset += *((unsigned char *) de);
offset623fs/isofs/inode.cif (offset >= bufsize)
offset631fs/isofs/inode.coffset -= bufsize;
offset639fs/isofs/inode.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset71fs/isofs/namei.cunsigned int block, i, f_pos, offset, inode_number;
offset88fs/isofs/namei.coffset = f_pos & (bufsize - 1);
offset94fs/isofs/namei.cde = (struct iso_directory_record *) (bh->b_data + offset);
offset96fs/isofs/namei.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
offset103fs/isofs/namei.coffset = 0;
offset112fs/isofs/namei.cold_offset = offset;
offset113fs/isofs/namei.coffset += *((unsigned char *) de);
offset118fs/isofs/namei.cif (offset >= bufsize) {
offset126fs/isofs/namei.coffset = f_pos & (bufsize - 1);
offset132fs/isofs/namei.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset44fs/isofs/rock.ccont_offset = isonum_733(rr->u.CE.offset); \
offset56fs/isofs/rock.cint block, offset, offset1; \
offset60fs/isofs/rock.coffset = cont_offset; \
offset64fs/isofs/rock.cif (offset >= 1024) block++; \
offset65fs/isofs/rock.coffset &= 1023; \
offset66fs/isofs/rock.cif(offset + cont_size >= 1024) { \
offset71fs/isofs/rock.cmemcpy(buffer, bh->b_data + offset, 1024 - offset); \
offset73fs/isofs/rock.coffset1 = 1024 - offset; \
offset74fs/isofs/rock.coffset = 0;} \
offset80fs/isofs/rock.cmemcpy(buffer + offset1, bh->b_data + offset, cont_size - offset1); \
offset422fs/isofs/rock.cint frag1, offset;
offset424fs/isofs/rock.coffset = (inode->i_ino & (bufsize - 1));
offset425fs/isofs/rock.cfrag1 = bufsize - offset;
offset428fs/isofs/rock.cmemcpy(cpnt, bh->b_data + offset, frag1);
offset435fs/isofs/rock.coffset += *pnt - bufsize;
offset436fs/isofs/rock.cmemcpy((char *)cpnt+frag1, bh->b_data, offset);
offset13fs/isofs/rock.hchar offset[8];
offset60fs/minix/dir.cunsigned int offset,i;
offset72fs/minix/dir.coffset = filp->f_pos & 1023;
offset75fs/minix/dir.cfilp->f_pos += 1024-offset;
offset78fs/minix/dir.cwhile (offset < 1024 && filp->f_pos < inode->i_size) {
offset79fs/minix/dir.cde = (struct minix_dir_entry *) (offset + bh->b_data);
offset80fs/minix/dir.coffset += info->s_dirsize;
offset69fs/minix/file.cint block, blocks, offset;
offset84fs/minix/file.coffset = filp->f_pos;
offset86fs/minix/file.cif (offset > size)
offset89fs/minix/file.cleft = size - offset;
offset95fs/minix/file.cblock = offset >> BLOCK_SIZE_BITS;
offset96fs/minix/file.coffset &= BLOCK_SIZE-1;
offset98fs/minix/file.cblocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
offset154fs/minix/file.cif (left < BLOCK_SIZE - offset)
offset157fs/minix/file.cchars = BLOCK_SIZE - offset;
offset162fs/minix/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset169fs/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;
offset202fs/minix/namei.cif (offset < bh->b_size)
offset206fs/minix/namei.coffset = 0;
offset378fs/minix/namei.cunsigned int block, offset;
offset388fs/minix/namei.coffset = 2*info->s_dirsize;
offset391fs/minix/namei.cif (inode->i_size < offset)
offset402fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
offset410fs/minix/namei.cde = (struct minix_dir_entry *) (bh->b_data + offset);
offset411fs/minix/namei.coffset += info->s_dirsize;
offset416fs/minix/namei.cif (offset < bh->b_size)
offset420fs/minix/namei.coffset = 0;
offset57fs/minix/truncate.cstatic int trunc_indirect(struct inode * inode, int offset, unsigned short * p)
offset64fs/minix/truncate.c#define INDIRECT_BLOCK (DIRECT_BLOCK-offset)
offset242fs/msdos/fat.cint cluster,offset;
offset251fs/msdos/fat.coffset = sector % sb->cluster_size;
offset253fs/msdos/fat.creturn (cluster-2)*sb->cluster_size+sb->data_start+offset;
offset87fs/msdos/file.cint left,offset,size,sector,cnt;
offset107fs/msdos/file.coffset = filp->f_pos & (SECTOR_SIZE-1);
offset109fs/msdos/file.cfilp->f_pos += (size = MIN(SECTOR_SIZE-offset,left));
offset111fs/msdos/file.cmemcpy_tofs(buf,data+offset,size);
offset115fs/msdos/file.cif ((ch = *((char *) data+offset++)) == '\r')
offset147fs/msdos/file.cint sector,offset,size,left,written;
offset176fs/msdos/file.coffset = filp->f_pos & (SECTOR_SIZE-1);
offset177fs/msdos/file.csize = MIN(SECTOR_SIZE-offset,MAX(carry,count));
offset188fs/msdos/file.cwritten = left = SECTOR_SIZE-offset;
offset290fs/msdos/inode.cint cluster,offset;
offset299fs/msdos/inode.coffset = (block*2) % sb->cluster_size;
offset301fs/msdos/inode.creturn ((cluster-2)*sb->cluster_size+sb->data_start+offset) >> 1;
offset271fs/msdos/misc.cint sector,offset;
offset275fs/msdos/misc.coffset = *pos;
offset276fs/msdos/misc.cif ((sector = msdos_smap(dir,offset >> SECTOR_BITS)) == -1)
offset287fs/msdos/misc.c*de = (struct msdos_dir_entry *) (data+(offset &
offset289fs/msdos/misc.creturn (sector << MSDOS_DPS_BITS)+((offset & (SECTOR_SIZE-1)) >>
offset390fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr, int fs)
offset397fs/nfs/proc.cPRINTK("NFS call  read %d @ %d\n", count, offset);
offset403fs/nfs/proc.c*p++ = htonl(offset);
offset436fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
offset442fs/nfs/proc.cPRINTK("NFS call  write %d @ %d\n", count, offset);
offset448fs/nfs/proc.c*p++ = htonl(offset); /* traditional, could be any value */
offset449fs/nfs/proc.c*p++ = htonl(offset);
offset118fs/pipe.cstatic int pipe_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset129fs/proc/mem.cstatic int mem_lseek(struct inode * inode, struct file * file, off_t offset, int orig)
offset133fs/proc/mem.cfile->f_pos = offset;
offset136fs/proc/mem.cfile->f_pos += offset;
offset37fs/read_write.casmlinkage int sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
offset47fs/read_write.creturn file->f_op->lseek(file->f_inode,file,offset,origin);
offset52fs/read_write.ctmp = offset;
offset55fs/read_write.ctmp = file->f_pos + offset;
offset60fs/read_write.ctmp = file->f_inode->i_size + offset;
offset76fs/read_write.cloff_t offset;
offset85fs/read_write.coffset = (loff_t) (((unsigned long long) offset_high << 32) | offset_low);
offset89fs/read_write.ctmp = offset;
offset92fs/read_write.ctmp = file->f_pos + offset;
offset97fs/read_write.ctmp = file->f_inode->i_size + offset;
offset68fs/sysv/dir.cunsigned int offset,i;
offset79fs/sysv/dir.coffset = filp->f_pos & sb->sv_block_size_1;
offset82fs/sysv/dir.cfilp->f_pos += sb->sv_block_size - offset;
offset85fs/sysv/dir.cwhile (offset < sb->sv_block_size && filp->f_pos < inode->i_size) {
offset86fs/sysv/dir.cde = (struct sysv_dir_entry *) (offset + bh_data);
offset87fs/sysv/dir.coffset += SYSV_DIRSIZE;
offset113fs/sysv/file.cint blocks, offset;
offset128fs/sysv/file.coffset = filp->f_pos;
offset130fs/sysv/file.cif (offset > size)
offset133fs/sysv/file.cleft = size - offset;
offset139fs/sysv/file.cblock = offset >> sb->sv_block_size_bits;
offset140fs/sysv/file.coffset &= sb->sv_block_size_1;
offset142fs/sysv/file.cblocks = (left + offset + sb->sv_block_size_1) >> sb->sv_block_size_bits;
offset206fs/sysv/file.cif (left < sb->sv_block_size - offset)
offset209fs/sysv/file.cchars = sb->sv_block_size - offset;
offset214fs/sysv/file.cmemcpy_tofs(buf,offset+bhe->bh_data,chars);
offset221fs/sysv/file.coffset = 0;
offset69fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset83fs/sysv/namei.cpos = block = offset = 0;
offset94fs/sysv/namei.c*res_dir = (struct sysv_dir_entry *) (bh_data + offset) ))
offset97fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset98fs/sysv/namei.cif (offset < sb->sv_block_size)
offset102fs/sysv/namei.coffset = 0; block++;
offset154fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset172fs/sysv/namei.cpos = block = offset = 0;
offset179fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh_data + offset);
offset181fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset200fs/sysv/namei.cif (offset < sb->sv_block_size)
offset204fs/sysv/namei.coffset = 0; block++;
offset381fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
offset390fs/sysv/namei.cpos = offset = 2*SYSV_DIRSIZE;
offset414fs/sysv/namei.cde = (struct sysv_dir_entry *) (bh_data + offset);
offset416fs/sysv/namei.coffset += SYSV_DIRSIZE;
offset421fs/sysv/namei.cif (offset < sb->sv_block_size)
offset425fs/sysv/namei.coffset = 0; block++;
offset291fs/sysv/truncate.cstatic int trunc_indirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset319fs/sysv/truncate.cif (inode->i_size < offset)
offset322fs/sysv/truncate.ci = (inode->i_size - offset + BLOCK_SIZE-1) / BLOCK_SIZE;
offset331fs/sysv/truncate.cif (i*BLOCK_SIZE + offset < inode->i_size) {
offset360fs/sysv/truncate.cstatic int trunc_dindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset386fs/sysv/truncate.cif (inode->i_size < offset)
offset389fs/sysv/truncate.ci = (inode->i_size - offset + IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*BLOCK_SIZE);
offset397fs/sysv/truncate.cretry |= trunc_indirect(inode,offset+i*IND_PER_BLOCK,ind,sb->sv_convert,&indbh->b_dirt);
offset414fs/sysv/truncate.cstatic int trunc_tindirect(struct inode * inode, unsigned long offset, unsigned long * p, int convert, unsigned char * dirt)
offset440fs/sysv/truncate.cif (inode->i_size < offset)
offset443fs/sysv/truncate.ci = (inode->i_size - offset + IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE);
offset451fs/sysv/truncate.cretry |= trunc_dindirect(inode,offset+i*IND_PER_BLOCK*IND_PER_BLOCK,ind,sb->sv_convert,&indbh->b_dirt);
offset224fs/xiafs/bitmap.cunsigned int bit, offset;
offset243fs/xiafs/bitmap.coffset = bit & (XIAFS_BITS_PER_Z(sb) -1);
offset244fs/xiafs/bitmap.cif (clear_bit(offset, bh->b_data))
offset68fs/xiafs/dir.cu_int offset, i;
offset77fs/xiafs/dir.coffset = filp->f_pos & (XIAFS_ZSIZE(inode->i_sb) - 1);
offset80fs/xiafs/dir.cfilp->f_pos += XIAFS_ZSIZE(inode->i_sb)-offset;
offset83fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
offset84fs/xiafs/dir.cwhile (offset < XIAFS_ZSIZE(inode->i_sb) && filp->f_pos < inode->i_size) {
offset95fs/xiafs/dir.coffset += de->d_rec_len;
offset110fs/xiafs/dir.cde = (struct xiafs_direct *) (offset + bh->b_data);
offset113fs/xiafs/dir.cif (offset > XIAFS_ZSIZE(inode->i_sb)) {
offset73fs/xiafs/file.cint zone_nr, zones, f_zones, offset;
offset87fs/xiafs/file.coffset = filp->f_pos;
offset88fs/xiafs/file.cleft = inode->i_size - offset;
offset94fs/xiafs/file.czone_nr = offset >> XIAFS_ZSIZE_BITS(inode->i_sb);
offset95fs/xiafs/file.coffset &= XIAFS_ZSIZE(inode->i_sb) -1 ;
offset97fs/xiafs/file.czones = (left+offset+XIAFS_ZSIZE(inode->i_sb)-1) >> XIAFS_ZSIZE_BITS(inode->i_sb);
offset152fs/xiafs/file.cif (left < XIAFS_ZSIZE(inode->i_sb) - offset)
offset155fs/xiafs/file.cchars = XIAFS_ZSIZE(inode->i_sb) - offset;
offset160fs/xiafs/file.cmemcpy_tofs(buf,offset+(*bhe)->b_data,chars);
offset167fs/xiafs/file.coffset = 0;
offset157fs/xiafs/namei.cint i, pos, offset;
offset182fs/xiafs/namei.coffset = 12;
offset185fs/xiafs/namei.coffset = 0;
offset186fs/xiafs/namei.cwhile (offset < XIAFS_ZSIZE(dir->i_sb)) {
offset230fs/xiafs/namei.coffset+=de->d_rec_len;
offset232fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
offset235fs/xiafs/namei.cif (offset > XIAFS_ZSIZE(dir->i_sb)) {
offset406fs/xiafs/namei.cint i, zones, offset;
offset436fs/xiafs/namei.coffset=de->d_rec_len+12;
offset439fs/xiafs/namei.coffset = 0;
offset442fs/xiafs/namei.cwhile (offset < XIAFS_ZSIZE(inode->i_sb)) {
offset443fs/xiafs/namei.cde=(struct xiafs_direct *)(bh->b_data+offset);
offset457fs/xiafs/namei.coffset+=de->d_rec_len;
offset95include/asm-i386/bitops.hextern inline int find_next_zero_bit (void * addr, int size, int offset)
offset97include/asm-i386/bitops.hunsigned long * p = ((unsigned long *) addr) + (offset >> 5);
offset98include/asm-i386/bitops.hint set = 0, bit = offset & 31, res;
offset112include/asm-i386/bitops.hreturn set + offset;
offset120include/asm-i386/bitops.hreturn (offset + set + res);
offset42include/linux/binfmts.hextern int read_exec(struct inode *inode, unsigned long offset,
offset104include/linux/elf.hunsigned int * offset;
offset109include/linux/elf.hunsigned int * offset;
offset102include/linux/mm.hunsigned long offset;
offset191include/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,
offset140include/linux/skbuff.hextern void      skb_copy_datagram(struct sk_buff *from, int offset, char *to,int size);
offset79include/linux/timex.hlong offset;    /* time offset (usec) */
offset100include/linux/xd.hu_long offset;
offset53kernel/ptrace.cstatic inline int get_stack_long(struct task_struct *task, int offset)
offset58kernel/ptrace.cstack += offset;
offset68kernel/ptrace.cstatic inline int put_stack_long(struct task_struct *task, int offset,
offset74kernel/ptrace.cstack += offset;
offset180kernel/time.cunsigned long offset = 0;
offset191kernel/time.coffset = TICK_SIZE;
offset195kernel/time.creturn offset + count;
offset356kernel/time.cif (txc.offset <= -(1 << (31 - SHIFT_UPDATE))
offset357kernel/time.c|| txc.offset >= (1 << (31 - SHIFT_UPDATE)))
offset399kernel/time.ctime_adjust = txc.offset;
offset403kernel/time.ctime_offset = txc.offset << SHIFT_UPDATE;
offset409kernel/time.cif (txc.offset < 0)
offset410kernel/time.ctime_freq -= (-txc.offset * mtemp) >>
offset413kernel/time.ctime_freq += (txc.offset * mtemp) >>
offset427kernel/time.ctxc.offset     = save_adjust;
offset809mm/memory.cunsigned long offset;
offset822mm/memory.coffset = address - area->vm_start + area->vm_offset;
offset839mm/memory.cfrom_address = offset + mpnt->vm_start - mpnt->vm_offset;
offset24mm/mprotect.cunsigned long page, offset;
offset28mm/mprotect.coffset = (start >> PAGE_SHIFT) & (PTRS_PER_PAGE-1);
offset34mm/mprotect.cnr = nr - PTRS_PER_PAGE + offset;
offset35mm/mprotect.coffset = 0;
offset38mm/mprotect.cpage_table = offset + (unsigned long *) (page & PAGE_MASK);
offset39mm/mprotect.coffset = PTRS_PER_PAGE - offset;
offset40mm/mprotect.cif (offset > nr)
offset41mm/mprotect.coffset = nr;
offset42mm/mprotect.cnr = nr - offset;
offset48mm/mprotect.c} while (--offset);
offset32mm/swap.c#define SWP_ENTRY(type,offset) (((type) << 1) | ((offset) << PAGE_SHIFT))
offset110mm/swap.cunsigned long type, offset;
offset119mm/swap.coffset = SWP_OFFSET(entry);
offset120mm/swap.cif (offset >= p->max) {
offset128mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
offset135mm/swap.cll_rw_page(rw,p->swap_device,offset,buf);
offset155mm/swap.cunsigned int block = offset << 3;
offset165mm/swap.cunsigned int block = offset
offset177mm/swap.cif (offset && !clear_bit(offset,p->swap_lockmap))
offset185mm/swap.cunsigned int offset, type;
offset191mm/swap.cfor (offset = p->lowest_bit; offset <= p->highest_bit ; offset++) {
offset192mm/swap.cif (p->swap_map[offset])
offset194mm/swap.cp->swap_map[offset] = 1;
offset196mm/swap.cif (offset == p->highest_bit)
offset198mm/swap.cp->lowest_bit = offset;
offset199mm/swap.creturn SWP_ENTRY(type,offset);
offset208mm/swap.cunsigned long offset, type;
offset212mm/swap.coffset = SWP_OFFSET(entry);
offset221mm/swap.cif (offset >= p->max) {
offset225mm/swap.cif (!p->swap_map[offset]) {
offset229mm/swap.cp->swap_map[offset]++;
offset236mm/swap.cunsigned long offset, type;
offset248mm/swap.coffset = SWP_OFFSET(entry);
offset249mm/swap.cif (offset >= p->max) {
offset257mm/swap.cwhile (set_bit(offset,p->swap_lockmap))
offset259mm/swap.cif (offset < p->lowest_bit)
offset260mm/swap.cp->lowest_bit = offset;
offset261mm/swap.cif (offset > p->highest_bit)
offset262mm/swap.cp->highest_bit = offset;
offset263mm/swap.cif (!p->swap_map[offset])
offset266mm/swap.cif (!--p->swap_map[offset])
offset268mm/swap.cif (!clear_bit(offset,p->swap_lockmap))
offset368mm/swap.cunsigned long offset;
offset377mm/swap.coffset = address & ~PGDIR_MASK;
offset380mm/swap.cpgdir++, address = address + PGDIR_SIZE, offset = 0) {
offset388mm/swap.cp->comm, address + offset, pg_table);
offset397mm/swap.cfor( ; offset < ~PGDIR_MASK ; offset += PAGE_SIZE) {
offset398mm/swap.cswitch(try_to_swap_out((unsigned long *) (pg_table + (offset >> 10)))) {
offset405mm/swap.cp->mm->swap_address = address + offset + PAGE_SIZE;
offset866net/inet/arp.cint arp_get_info(char *buffer, char **start, off_t offset, int length)
offset917net/inet/arp.cif(pos<offset)
offset922net/inet/arp.cif(pos>offset+length)
offset928net/inet/arp.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset929net/inet/arp.clen-=(offset-begin);    /* Start slop */
offset162net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
offset166net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
offset974net/inet/dev.cint dev_get_info(char *buffer, char **start, off_t offset, int length)
offset997net/inet/dev.cif(pos<offset)
offset1002net/inet/dev.cif(pos>offset+length)
offset1006net/inet/dev.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset1007net/inet/dev.clen-=(offset-begin);    /* Start slop */
offset96net/inet/icmp.cint offset;
offset178net/inet/icmp.coffset = ip_build_header(skb, dev->pa_addr, iph->saddr,
offset181net/inet/icmp.cif (offset < 0) 
offset193net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
offset199net/inet/icmp.cicmph = (struct icmphdr *) (skb->data + offset);
offset358net/inet/icmp.cint size, offset;
offset375net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev,
offset377net/inet/icmp.cif (offset < 0) 
offset390net/inet/icmp.cskb2->len = offset + len;
offset395net/inet/icmp.cicmphr = (struct icmphdr *) (skb2->data + offset);
offset424net/inet/icmp.cint size, offset;
offset443net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev, IPPROTO_ICMP, opt, len, 
offset445net/inet/icmp.cif (offset < 0) 
offset457net/inet/icmp.cskb2->len = offset + len;
offset463net/inet/icmp.cicmphr = (struct icmphdr *) ((char *) (skb2 + 1) + offset);
offset513net/inet/icmp.cint size, offset;
offset533net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &ndev,
offset535net/inet/icmp.cif (offset < 0) 
offset548net/inet/icmp.cskb2->len = offset + len;
offset554net/inet/icmp.cicmphr = (struct icmphdr *) (skb2->data + offset);
offset570net/inet/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
offset583net/inet/ip.cfp->offset = offset;
offset585net/inet/ip.cfp->len = end - offset;
offset790net/inet/ip.cint offset;
offset798net/inet/ip.coffset = 0;
offset801net/inet/ip.cif (fp->offset > offset)
offset803net/inet/ip.coffset = fp->end;
offset870net/inet/ip.cmemcpy((ptr + fp->offset), fp->ptr, fp->len);
offset900net/inet/ip.cint flags, offset;
offset909net/inet/ip.coffset = ntohs(iph->frag_off);
offset910net/inet/ip.cflags = offset & ~IP_OFFSET;
offset911net/inet/ip.coffset &= IP_OFFSET;
offset912net/inet/ip.cif (((flags & IP_MF) == 0) && (offset == 0))
offset919net/inet/ip.coffset <<= 3;    /* offset is in 8-byte chunks */
offset954net/inet/ip.cend = offset + ntohs(iph->tot_len) - ihl;
offset978net/inet/ip.cif (next->offset > offset)
offset988net/inet/ip.cif (prev != NULL && offset < prev->end)
offset990net/inet/ip.ci = prev->end - offset;
offset991net/inet/ip.coffset += i;  /* ptr into datagram */
offset1003net/inet/ip.cif (next->offset >= end)
offset1006net/inet/ip.ci = end - next->offset;      /* overlap is 'i' bytes */
offset1008net/inet/ip.cnext->offset += i;      /* next fragment  */
offset1035net/inet/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
offset1092net/inet/ip.cint offset;
offset1149net/inet/ip.coffset = (ntohs(iph->frag_off) & 0x1fff) << 3;
offset1151net/inet/ip.coffset = 0;
offset1225net/inet/ip.ciph->frag_off = htons((offset >> 3));
offset1233net/inet/ip.coffset += len;
offset42net/inet/ip.hint    offset;    /* offset of fragment in IP datagram  */
offset145net/inet/ipx.cint ipx_get_info(char *buffer, char **start, off_t offset, int length)
offset172net/inet/ipx.cif(pos<offset)
offset177net/inet/ipx.cif(pos>offset+length)    /* We have dumped enough */
offset182net/inet/ipx.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset183net/inet/ipx.clen-=(offset-begin);    /* Remove unwanted header data from length */
offset431net/inet/ipx.cint ipx_rt_get_info(char *buffer, char **start, off_t offset, int length)
offset445net/inet/ipx.cif(pos<offset)
offset450net/inet/ipx.cif(pos>offset+length)
offset453net/inet/ipx.c*start=buffer+(offset-begin);
offset454net/inet/ipx.clen-=(offset-begin);
offset57net/inet/proc.cget__netinfo(struct proto *pro, char *buffer, int format, char **start, off_t offset, int length)
offset108net/inet/proc.cif(pos<offset)
offset113net/inet/proc.cif(pos>offset+length)
offset118net/inet/proc.cif(pos>offset+length)
offset121net/inet/proc.c*start=buffer+(offset-begin);
offset122net/inet/proc.clen-=(offset-begin);
offset129net/inet/proc.cint tcp_get_info(char *buffer, char **start, off_t offset, int length)
offset131net/inet/proc.creturn get__netinfo(&tcp_prot, buffer,0, start, offset, length);
offset135net/inet/proc.cint udp_get_info(char *buffer, char **start, off_t offset, int length)
offset137net/inet/proc.creturn get__netinfo(&udp_prot, buffer,1, start, offset, length);
offset141net/inet/proc.cint raw_get_info(char *buffer, char **start, off_t offset, int length)
offset143net/inet/proc.creturn get__netinfo(&raw_prot, buffer,1, start, offset, length);
offset151net/inet/proc.cint snmp_get_info(char *buffer, char **start, off_t offset, int length)
offset211net/inet/proc.cif (offset >= len)
offset216net/inet/proc.c*start = buffer + offset;
offset217net/inet/proc.clen -= offset;
offset426net/inet/rarp.cint rarp_get_info(char *buffer, char **start, off_t offset, int length)
offset472net/inet/rarp.cif(pos<offset)
offset477net/inet/rarp.cif(pos>offset+length)
offset483net/inet/rarp.c*start=buffer+(offset-begin);  /* Start of wanted data */
offset484net/inet/rarp.clen-=(offset-begin);    /* Start slop */
offset11net/inet/rarp.hoff_t offset, 
offset481net/inet/route.cint rt_get_info(char *buffer, char **start, off_t offset, int length)
offset505net/inet/route.cif(pos<offset)
offset510net/inet/route.cif(pos>offset+length)
offset514net/inet/route.c*start=buffer+(offset-begin);
offset515net/inet/route.clen-=(offset-begin);
offset50net/inet/route.hextern int    rt_get_info(char * buffer, char **start, off_t offset, int length);
offset494net/inet/skbuff.cunsigned long offset;
offset500net/inet/skbuff.coffset=((char *)n)-((char *)skb);
offset508net/inet/skbuff.cn->h.raw=skb->h.raw+offset;
offset509net/inet/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
offset1489net/inet/tcp.cunsigned long offset;
offset1506net/inet/tcp.coffset = 1 + *seq - skb->h.th->seq;
offset1508net/inet/tcp.coffset--;
offset1509net/inet/tcp.cif (offset < skb->len)
offset1564net/inet/tcp.cused = skb->len - offset;
offset1578net/inet/tcp.coffset++;
offset1588net/inet/tcp.cskb->h.th->doff*4 + offset, used);
offset1595net/inet/tcp.cif (!(flags & MSG_PEEK) && (used + offset >= skb->len))
offset53net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset,
offset360net/socket.cstatic int sock_lseek(struct inode *inode, struct file *file, off_t offset, int whence)
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);