taglinefilesource code
block71drivers/block/blk.h#define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0)
block981drivers/block/cdu31a.cint block;
block1011drivers/block/cdu31a.cblock = CURRENT->sector;
block1026drivers/block/cdu31a.cif ((block / 4) >= sony_toc->lead_out_start_lba)
block1031drivers/block/cdu31a.cif (((block + nsect) / 4) >= sony_toc->lead_out_start_lba)
block1043drivers/block/cdu31a.cif ((block < sony_first_block) || (block > sony_last_block))
block1045drivers/block/cdu31a.csony_first_block = (block / 4) * 4;
block1046drivers/block/cdu31a.clog_to_msf(block/4, params);
block1052drivers/block/cdu31a.cif (((block / 4) + sony_buffer_sectors) >= sony_toc->lead_out_start_lba)
block1054drivers/block/cdu31a.cread_size = sony_toc->lead_out_start_lba - (block / 4);
block1095drivers/block/cdu31a.ccopyoff = (block - sony_first_block) * 512;
block1098drivers/block/cdu31a.cblock += 1;
block993drivers/block/floppy.cunsigned int block;
block1041drivers/block/floppy.cblock = CURRENT->sector;
block1042drivers/block/floppy.cif (block+2 > floppy->size) {
block1046drivers/block/floppy.csector = block % floppy->sect;
block1047drivers/block/floppy.cblock /= floppy->sect;
block1048drivers/block/floppy.chead = block % floppy->head;
block1049drivers/block/floppy.ctrack = block / floppy->head;
block445drivers/block/hd.cunsigned int block,dev;
block458drivers/block/hd.cblock = CURRENT->sector;
block460drivers/block/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
block463drivers/block/hd.cblock, hd[dev].nr_sects);
block468drivers/block/hd.cblock += hd[dev].start_sect;
block470drivers/block/hd.csec = block % hd_info[dev].sect + 1;
block471drivers/block/hd.ctrack = block / hd_info[dev].sect;
block537drivers/block/mcd.cunsigned int block,dev;
block544drivers/block/mcd.cblock = CURRENT->sector;
block649drivers/block/mcd.clong block;
block674drivers/block/mcd.cblock = CURRENT -> sector / 4;
block675drivers/block/mcd.chsg2msf(block, &mcdcmd.start);  /* cvt to msf format */
block106drivers/block/ramdisk.cint    block, tries;
block128drivers/block/ramdisk.cblock = tries;
block129drivers/block/ramdisk.cbh = breada(ROOT_DEV,block+1,block,block+2,-1);
block157drivers/block/ramdisk.cbh = breada(ROOT_DEV, block, block+1, block+2, -1);
block159drivers/block/ramdisk.cbh = bread(ROOT_DEV, block, BLOCK_SIZE);
block162drivers/block/ramdisk.cblock);
block169drivers/block/ramdisk.cblock++;
block2341drivers/block/sbpcd.cu_int block;
block2362drivers/block/sbpcd.cblock = CURRENT->sector;
block2372drivers/block/sbpcd.cDPRINTF((DBG_MUL,"SBPCD: read LBA %d\n", block/4));
block2424drivers/block/sbpcd.cint block;
block2427drivers/block/sbpcd.cblock=CURRENT->sector/4;
block2432drivers/block/sbpcd.cDPRINTF((DBG_MUL,"SBPCD: read MSF %08X\n", blk2msf(block)));
block2436drivers/block/sbpcd.cblk2msf(DS[d].lba_multi+block),
block2437drivers/block/sbpcd.cblk2msf(block)));
block2438drivers/block/sbpcd.cblock=DS[d].lba_multi+block;
block2441drivers/block/sbpcd.cif ( (block==166) && (DS[d].f_multisession) && (multisession_valid) )
block2445drivers/block/sbpcd.cblk2msf(block)));
block2446drivers/block/sbpcd.cblock=DS[d].lba_multi+16;
block2451drivers/block/sbpcd.cif (block+SBP_BUFFER_FRAMES <= DS[d].CDsize_frm)
block2455drivers/block/sbpcd.cDS[d].sbp_read_frames=DS[d].CDsize_frm-block;
block2460drivers/block/sbpcd.cblock, DS[d].CDsize_frm));
block2475drivers/block/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bcd format required */
block2482drivers/block/sbpcd.cdrvcmd[1]=(block>>16)&0x000000ff;
block2483drivers/block/sbpcd.cdrvcmd[2]=(block>>8)&0x000000ff;
block2484drivers/block/sbpcd.cdrvcmd[3]=block&0x000000ff;
block2494drivers/block/sbpcd.clba2msf(block,&drvcmd[1]); /* msf-bin format required */
block177drivers/block/xd.cu_int block,count,retry;
block185drivers/block/xd.cblock = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect;
block191drivers/block/xd.ccode = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count);
block278drivers/block/xd.cstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count)
block285drivers/block/xd.cprintk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count);
block292drivers/block/xd.ctrack = block / xd_info[drive].sectors;
block295drivers/block/xd.csector = block % xd_info[drive].sectors;
block318drivers/block/xd.ccount -= temp, buffer += temp * 0x200, block += temp;
block52drivers/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)           \
block53drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
block73drivers/scsi/scsi_debug.cif (SCpnt->request.sector + start != block) panic("Wrong block.");  \
block77drivers/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
block78drivers/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
block141drivers/scsi/scsi_debug.cint block, start;
block218drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block220drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block237drivers/scsi/scsi_debug.cif(block == 0 && target == 0) {
block252drivers/scsi/scsi_debug.cif (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
block256drivers/scsi/scsi_debug.cif(block == 0xfff0) {
block276drivers/scsi/scsi_debug.cmemcpy(buff+60, &block, sizeof(block));
block281drivers/scsi/scsi_debug.cblock += bufflen >> 9;
block300drivers/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block302drivers/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block312drivers/scsi/scsi_debug.cif (block != *((unsigned long *) (buff+60))) {
block313drivers/scsi/scsi_debug.cprintk("%x %x :",block,  *((unsigned long *) (buff+60)));
block382drivers/scsi/sd.cint dev, block, this_count;
block394drivers/scsi/sd.cblock = SCpnt->request.sector;
block398drivers/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", dev, block);
block401drivers/scsi/sd.cif (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
block407drivers/scsi/sd.cblock += sd[dev].start_sect;
block421drivers/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
block565drivers/scsi/sd.cif(block & 1) panic("sd.c:Bad block number requested");
block567drivers/scsi/sd.cblock = block >> 1;
block572drivers/scsi/sd.cblock = block << 1;
block576drivers/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
block582drivers/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block583drivers/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block584drivers/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block585drivers/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
block595drivers/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block596drivers/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block597drivers/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
block348drivers/scsi/sr.cunsigned int dev, block, realcount;
block361drivers/scsi/sr.cblock = SCpnt->request.sector;  
block541drivers/scsi/sr.cstart = block % 4;
block563drivers/scsi/sr.cblock = block >> 2; /* These are the sectors that the cdrom uses */
block565drivers/scsi/sr.cblock = block & 0xfffffffc;
block571drivers/scsi/sr.cif (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
block580drivers/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block581drivers/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block582drivers/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block583drivers/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
block596drivers/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block597drivers/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block598drivers/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
block606drivers/scsi/sr.cprintk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count);
block76drivers/sound/opl3.cstatic void     freq_to_fnum (int freq, int *block, int *fnum);
block431drivers/sound/opl3.cint             block, fnum, freq, voice_mode;
block566drivers/sound/opl3.cfreq_to_fnum (freq, &block, &fnum);
block573drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
block583drivers/sound/opl3.cfreq_to_fnum (int freq, int *block, int *fnum)
block617drivers/sound/opl3.c*block = octave;
block826drivers/sound/opl3.cint             block, fnum, freq;
block849drivers/sound/opl3.cfreq_to_fnum (freq, &block, &fnum);
block854drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);  /* KEYON|OCTAVE|MS bits
block20fs/block_dev.cint block;
block41fs/block_dev.cblock = filp->f_pos >> blocksize_bits;
block49fs/block_dev.cif (block >= size)
block55fs/block_dev.cbh = getblk(dev, block, blocksize);
block57fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
block58fs/block_dev.cblock++;
block80fs/block_dev.cunsigned int block;
block121fs/block_dev.cblock = offset >> blocksize_bits;
block128fs/block_dev.cif (block + blocks > size)
block129fs/block_dev.cblocks = size - block;
block147fs/block_dev.c*bhb = getblk(dev, block++, blocksize);
block279fs/buffer.c#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
block280fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
block357fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
block361fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
block362fs/buffer.cif (tmp->b_dev==dev && tmp->b_blocknr==block)
block380fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
block385fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
block389fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
block447fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
block454fs/buffer.cbh = get_hash_table(dev, block, size);
block507fs/buffer.cif (find_buffer(dev,block,size))
block517fs/buffer.cbh->b_blocknr=block;
block540fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
block544fs/buffer.cif (!(bh = getblk(dev, block, size))) {
block707fs/buffer.cint block;
block719fs/buffer.cblock = *++b;
block720fs/buffer.cif (!block)
block722fs/buffer.cfirst = get_hash_table(dev, block, size);
block748fs/buffer.cint block;
block755fs/buffer.cblock = *(p++);
block756fs/buffer.cif (!block)
block758fs/buffer.ctmp = get_hash_table(dev, block, size);
block766fs/buffer.cblock = 0;
block768fs/buffer.carr[block++] = bh;
block784fs/buffer.cread_buffers(arr,block);
block785fs/buffer.cwhile (block-- > 0)
block786fs/buffer.cbrelse(arr[block]);
block812fs/buffer.cint block;
block814fs/buffer.cblock = b[0];
block815fs/buffer.cif (!block)
block817fs/buffer.cbh = get_hash_table(dev, block, size);
block75fs/ext/file.cint block, blocks, offset;
block101fs/ext/file.cblock = offset >> BLOCK_SIZE_BITS;
block108fs/ext/file.cif (block + blocks > size)
block109fs/ext/file.cblocks = size - block;
block127fs/ext/file.c*bhb = ext_getblk(inode, block++, 0);
block47fs/ext/freelists.cvoid ext_free_block(struct super_block * sb, int block)
block57fs/ext/freelists.cif (block < sb->u.ext_sb.s_firstdatazone ||
block58fs/ext/freelists.cblock >= sb->u.ext_sb.s_nzones) {
block62fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
block70fs/ext/freelists.cprintk("ext_free_block: block full, skipping to %d\n", block);
block75fs/ext/freelists.cblock, sb->s_blocksize)))
block80fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber = block;
block82fs/ext/freelists.cefb->free[efb->count++] = block;
block152fs/ext/freelists.cunsigned long count, block;
block160fs/ext/freelists.cblock = efb->next;
block161fs/ext/freelists.cwhile (block) {
block162fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block164fs/ext/freelists.cblock = 0;
block168fs/ext/freelists.cblock = efb->next;
block187fs/ext/freelists.cunsigned long block;
block228fs/ext/freelists.cblock = 2 + (ino - 1) / EXT_INODES_PER_BLOCK;
block229fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
block251fs/ext/freelists.cunsigned long block;
block277fs/ext/freelists.cblock = 2 + (((unsigned long) efi->next) - 1) / EXT_INODES_PER_BLOCK;
block283fs/ext/freelists.cbread(sb->s_dev, block, sb->s_blocksize)))
block312fs/ext/freelists.cunsigned long count, block, ino;
block328fs/ext/freelists.cblock = 2 + ((ino - 1) / EXT_INODES_PER_BLOCK);
block329fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block331fs/ext/freelists.cblock = 0;
block30fs/ext/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
block35fs/ext/fsync.cif (!*block)
block37fs/ext/fsync.ctmp = *block;
block38fs/ext/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block41fs/ext/fsync.cif (*block != tmp) {
block62fs/ext/inode.cint dev = s->s_dev,block;
block107fs/ext/inode.cblock = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK;
block108fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
block177fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
block181fs/ext/inode.cif (block<0) {
block185fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block189fs/ext/inode.cif (block<9)
block190fs/ext/inode.creturn inode_bmap(inode,block);
block191fs/ext/inode.cblock -= 9;
block192fs/ext/inode.cif (block<256) {
block196fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block198fs/ext/inode.cblock -= 256;
block199fs/ext/inode.cif (block<256*256) {
block203fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
block206fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block208fs/ext/inode.cblock -= 256*256;
block212fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
block215fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
block218fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block304fs/ext/inode.cstruct buffer_head * ext_getblk(struct inode * inode, int block, int create)
block308fs/ext/inode.cif (block<0) {
block312fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block316fs/ext/inode.cif (block<9)
block317fs/ext/inode.creturn inode_getblk(inode,block,create);
block318fs/ext/inode.cblock -= 9;
block319fs/ext/inode.cif (block<256) {
block321fs/ext/inode.creturn block_getblk(inode,bh,block,create);
block323fs/ext/inode.cblock -= 256;
block324fs/ext/inode.cif (block<256*256) {
block326fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
block327fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block329fs/ext/inode.cblock -= 256*256;
block331fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
block332fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
block333fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block336fs/ext/inode.cstruct buffer_head * ext_bread(struct inode * inode, int block, int create)
block340fs/ext/inode.cbh = ext_getblk(inode,block,create);
block355fs/ext/inode.cint block;
block357fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block358fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block371fs/ext/inode.celse for (block = 0; block < 12; block++)
block372fs/ext/inode.cinode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
block393fs/ext/inode.cint block;
block395fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block396fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block408fs/ext/inode.celse for (block = 0; block < 12; block++)
block409fs/ext/inode.craw_inode->i_zone[block] = inode->u.ext_i.i_data[block];
block249fs/ext2/balloc.cvoid ext2_free_blocks (struct super_block * sb, unsigned long block,
block267fs/ext2/balloc.cif (block < es->s_first_data_block || 
block268fs/ext2/balloc.c(block + count) > es->s_blocks_count) {
block275fs/ext2/balloc.cext2_debug ("freeing block %lu\n", block);
block277fs/ext2/balloc.cblock_group = (block - es->s_first_data_block) /
block279fs/ext2/balloc.cbit = (block - es->s_first_data_block) % EXT2_BLOCKS_PER_GROUP(sb);
block284fs/ext2/balloc.cblock, count);
block290fs/ext2/balloc.c(in_range (gdp->bg_block_bitmap, block, count) ||
block291fs/ext2/balloc.cin_range (gdp->bg_inode_bitmap, block, count) ||
block292fs/ext2/balloc.cin_range (block, gdp->bg_inode_table,
block294fs/ext2/balloc.cin_range (block + count - 1, gdp->bg_inode_table,
block299fs/ext2/balloc.cblock, count);
block305fs/ext2/balloc.cblock);
block590fs/ext2/balloc.cstatic inline int block_in_use (unsigned long block,
block594fs/ext2/balloc.creturn test_bit ((block - sb->u.ext2_sb.s_es->s_first_data_block) %
block79fs/ext2/file.cint block, blocks, offset;
block109fs/ext2/file.cblock = offset >> EXT2_BLOCK_SIZE_BITS(sb);
block117fs/ext2/file.cif (block + blocks > size)
block118fs/ext2/file.cblocks = size - block;
block138fs/ext2/file.c*bhb = ext2_getblk (inode, block++, 0, &err);
block30fs/ext2/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
block35fs/ext2/fsync.cif (!*block)
block37fs/ext2/fsync.ctmp = *block;
block38fs/ext2/fsync.cbh = get_hash_table (inode->i_dev, *block, blocksize);
block41fs/ext2/fsync.cif (*block != tmp) {
block133fs/ext2/inode.cint ext2_bmap (struct inode * inode, int block)
block138fs/ext2/inode.cif (block < 0) {
block142fs/ext2/inode.cif (block >= EXT2_NDIR_BLOCKS + addr_per_block +
block148fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block149fs/ext2/inode.creturn inode_bmap (inode, block);
block150fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block151fs/ext2/inode.cif (block < addr_per_block) {
block156fs/ext2/inode.cinode->i_sb->s_blocksize), block);
block158fs/ext2/inode.cblock -= addr_per_block;
block159fs/ext2/inode.cif (block < addr_per_block * addr_per_block) {
block165fs/ext2/inode.cblock / addr_per_block);
block170fs/ext2/inode.cblock & (addr_per_block - 1));
block172fs/ext2/inode.cblock -= addr_per_block * addr_per_block;
block177fs/ext2/inode.cblock / (addr_per_block * addr_per_block));
block181fs/ext2/inode.c(block / addr_per_block) & (addr_per_block - 1));
block185fs/ext2/inode.cblock & (addr_per_block - 1));
block330fs/ext2/inode.cstruct buffer_head * ext2_getblk (struct inode * inode, long block,
block338fs/ext2/inode.cif (block < 0) {
block342fs/ext2/inode.cif (block > EXT2_NDIR_BLOCKS + addr_per_block  +
block354fs/ext2/inode.cext2_debug ("block %lu, next %lu, goal %lu.\n", block, 
block358fs/ext2/inode.cif (block == inode->u.ext2_i.i_next_alloc_block + 1) {
block364fs/ext2/inode.cb = block;
block365fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block366fs/ext2/inode.creturn inode_getblk (inode, block, create, b, err);
block367fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block368fs/ext2/inode.cif (block < addr_per_block) {
block370fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
block373fs/ext2/inode.cblock -= addr_per_block;
block374fs/ext2/inode.cif (block < addr_per_block * addr_per_block) {
block376fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
block378fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
block381fs/ext2/inode.cblock -= addr_per_block * addr_per_block;
block383fs/ext2/inode.cbh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block),
block385fs/ext2/inode.cbh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1),
block387fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
block391fs/ext2/inode.cstruct buffer_head * ext2_bread (struct inode * inode, int block, 
block396fs/ext2/inode.cbh = ext2_getblk (inode, block, create, err);
block415fs/ext2/inode.cunsigned long block;
block436fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block439fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block442fs/ext2/inode.c"inode=%lu, block=%lu", inode->i_ino, block);
block471fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block472fs/ext2/inode.cinode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
block501fs/ext2/inode.cunsigned long block;
block521fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block524fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block527fs/ext2/inode.c"inode=%lu, block=%lu", inode->i_ino, block);
block549fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block550fs/ext2/inode.craw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
block83fs/ext2/namei.cint block, toread, i, err;
block100fs/ext2/namei.cfor (block = 0; block < NAMEI_RA_SIZE; ++block) {
block103fs/ext2/namei.cif ((block << EXT2_BLOCK_SIZE_BITS (sb)) >= dir->i_size)
block105fs/ext2/namei.cbh = ext2_getblk (dir, block, 0, &err);
block106fs/ext2/namei.cbh_use[block] = bh;
block111fs/ext2/namei.cblock = 0;
block118fs/ext2/namei.cif ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
block122fs/ext2/namei.cbh = bh_use[block % NAMEI_RA_SIZE];
block154fs/ext2/namei.cif (((block + NAMEI_RA_SIZE) << EXT2_BLOCK_SIZE_BITS (sb)) >=
block158fs/ext2/namei.cbh = ext2_getblk (dir, block + NAMEI_RA_SIZE, 0, &err);
block159fs/ext2/namei.cbh_use[block++ % NAMEI_RA_SIZE] = bh;
block308fs/ext2/super.cunsigned long block = sb->u.ext2_sb.s_es->s_first_data_block;
block317fs/ext2/super.cif (gdp->bg_block_bitmap < block ||
block318fs/ext2/super.cgdp->bg_block_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
block326fs/ext2/super.cif (gdp->bg_inode_bitmap < block ||
block327fs/ext2/super.cgdp->bg_inode_bitmap >= block + EXT2_BLOCKS_PER_GROUP(sb))
block335fs/ext2/super.cif (gdp->bg_inode_table < block ||
block337fs/ext2/super.cblock + EXT2_BLOCKS_PER_GROUP(sb))
block345fs/ext2/super.cblock += EXT2_BLOCKS_PER_GROUP(sb);
block867fs/hpfs/hpfs_fs.cchar *block;
block898fs/hpfs/hpfs_fs.cblock = map_sector(inode->i_dev, hpfs_bmap(inode, q), &bh);
block899fs/hpfs/hpfs_fs.cif (!block)
block907fs/hpfs/hpfs_fs.cinode->i_hpfs_conv = choose_conv(block + r, n);
block914fs/hpfs/hpfs_fs.cmemcpy_tofs(buf, block + r, n);
block921fs/hpfs/hpfs_fs.cn0 = convcpy_tofs(buf, block + r, n);
block262fs/inode.cint bmap(struct inode * inode, int block)
block265fs/inode.creturn inode->i_op->bmap(inode,block);
block19fs/ioctl.cint block;
block30fs/ioctl.cblock = get_fs_long((long *) arg);
block31fs/ioctl.cblock = filp->f_inode->i_op->bmap(filp->f_inode,block);
block32fs/ioctl.cput_fs_long(block,(long *) arg);
block69fs/isofs/dir.cunsigned int block,offset,i, j;
block83fs/isofs/dir.cblock = isofs_bmap(inode,filp->f_pos>>bufbits);
block84fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,bufsize)))
block90fs/isofs/dir.cblock, offset, filp->f_pos);
block93fs/isofs/dir.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
block104fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>bufbits);
block105fs/isofs/dir.cif (!block
block106fs/isofs/dir.c|| !(bh = bread(inode->i_dev,block,bufsize)))
block127fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>> bufbits);
block128fs/isofs/dir.cif (!block
block129fs/isofs/dir.c|| !(bh = bread(inode->i_dev,block,bufsize))) {
block91fs/isofs/file.cint block;
block96fs/isofs/file.cblock = isofs_bmap(inode,0);
block97fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) {
block117fs/isofs/file.cint block, blocks, offset;
block143fs/isofs/file.cblock = filp->f_pos >> ISOFS_BUFFER_BITS(inode);
block167fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode));
block190fs/isofs/file.cif (block >= max_block) break;
block193fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode));
block322fs/isofs/inode.cint isofs_bmap(struct inode * inode,int block)
block325fs/isofs/inode.cif (block<0) {
block329fs/isofs/inode.creturn inode->u.isofs_i.i_first_extent + block;
block340fs/isofs/inode.cint block;
block343fs/isofs/inode.cblock = inode->i_ino >> ISOFS_BUFFER_BITS(inode);
block344fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
block358fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
block437fs/isofs/inode.cprintk("Get inode %d: %d %d: %d\n",inode->i_ino, block, 
block535fs/isofs/inode.cunsigned int block,offset;
block544fs/isofs/inode.cblock = extent << (ISOFS_BLOCK_BITS - bufbits);
block545fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, bufsize)))  return -1;
block582fs/isofs/inode.cblock = parent_dir << (ISOFS_BLOCK_BITS - bufbits);
block583fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, bufsize)))
block589fs/isofs/inode.cinode_number = (block << bufbits)+(offset & (bufsize - 1));
block599fs/isofs/inode.cblock++;
block600fs/isofs/inode.cif(block & 1) return -1;
block601fs/isofs/inode.cif (!block
block602fs/isofs/inode.c|| !(bh = bread(parent->i_dev,block, bufsize)))
block616fs/isofs/inode.cif((block & 1) != 0) return -1;
block623fs/isofs/inode.cblock++;
block624fs/isofs/inode.cif (!(bh = bread(parent->i_dev,block,bufsize))) {
block675fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
block677fs/isofs/inode.creturn bread(dev, block, size);
block70fs/isofs/namei.cunsigned int block, i, f_pos, offset, inode_number;
block83fs/isofs/namei.cif (!(block = dir->u.isofs_i.i_first_extent)) return NULL;
block88fs/isofs/namei.cblock = isofs_bmap(dir,f_pos >> bufbits);
block90fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) return NULL;
block95fs/isofs/namei.cinode_number = (block << bufbits) + (offset & (bufsize - 1));
block105fs/isofs/namei.cblock = isofs_bmap(dir,f_pos>>bufbits);
block106fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize)))
block124fs/isofs/namei.cblock = isofs_bmap(dir,f_pos>>bufbits);
block125fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,bufsize))) {
block56fs/isofs/rock.cint block, offset, offset1; \
block59fs/isofs/rock.cblock = cont_extent; \
block63fs/isofs/rock.cblock <<= 1;    \
block64fs/isofs/rock.cif (offset >= 1024) block++; \
block67fs/isofs/rock.cbh = bread(DEV->i_dev, block++, ISOFS_BUFFER_SIZE(DEV)); \
block74fs/isofs/rock.cbh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \
block393fs/isofs/rock.cint block;
block405fs/isofs/rock.cblock = inode->i_ino >> bufbits;
block406fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, bufsize))) {
block419fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, bufsize))) {
block68fs/minix/bitmap.cvoid minix_free_block(struct super_block * sb, int block)
block77fs/minix/bitmap.cif (block < sb->u.minix_sb.s_firstdatazone ||
block78fs/minix/bitmap.cblock >= sb->u.minix_sb.s_nzones) {
block82fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
block86fs/minix/bitmap.czone = block - sb->u.minix_sb.s_firstdatazone + 1;
block95fs/minix/bitmap.cprintk("free_block (%04x:%d): bit already cleared\n",sb->s_dev,block);
block69fs/minix/file.cint block, blocks, offset;
block95fs/minix/file.cblock = offset >> BLOCK_SIZE_BITS;
block102fs/minix/file.cif (block + blocks > size)
block103fs/minix/file.cblocks = size - block;
block121fs/minix/file.c*bhb = minix_getblk(inode, block++, 0);
block27fs/minix/fsync.cstatic int sync_block (struct inode * inode, unsigned short * block, int wait)
block32fs/minix/fsync.cif (!*block)
block34fs/minix/fsync.ctmp = *block;
block35fs/minix/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block38fs/minix/fsync.cif (*block != tmp) {
block120fs/minix/inode.cint i,dev=s->s_dev,block;
block163fs/minix/inode.cblock=2;
block165fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block166fs/minix/inode.cblock++;
block170fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block171fs/minix/inode.cblock++;
block174fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
block243fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
block247fs/minix/inode.cif (block<0) {
block251fs/minix/inode.cif (block >= 7+512+512*512) {
block255fs/minix/inode.cif (block < 7)
block256fs/minix/inode.creturn inode_bmap(inode,block);
block257fs/minix/inode.cblock -= 7;
block258fs/minix/inode.cif (block < 512) {
block262fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block264fs/minix/inode.cblock -= 512;
block268fs/minix/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
block271fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
block357fs/minix/inode.cstruct buffer_head * minix_getblk(struct inode * inode, int block, int create)
block361fs/minix/inode.cif (block<0) {
block365fs/minix/inode.cif (block >= 7+512+512*512) {
block369fs/minix/inode.cif (block < 7)
block370fs/minix/inode.creturn inode_getblk(inode,block,create);
block371fs/minix/inode.cblock -= 7;
block372fs/minix/inode.cif (block < 512) {
block374fs/minix/inode.creturn block_getblk(inode, bh, block, create);
block376fs/minix/inode.cblock -= 512;
block378fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
block379fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
block382fs/minix/inode.cstruct buffer_head * minix_bread(struct inode * inode, int block, int create)
block386fs/minix/inode.cbh = minix_getblk(inode,block,create);
block401fs/minix/inode.cint block, ino;
block411fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block414fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
block430fs/minix/inode.celse for (block = 0; block < 9; block++)
block431fs/minix/inode.cinode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
block451fs/minix/inode.cint ino, block;
block460fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
block462fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
block477fs/minix/inode.celse for (block = 0; block < 9; block++)
block478fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.i_data[block];
block71fs/minix/namei.cunsigned long block, offset;
block87fs/minix/namei.cblock = offset = 0;
block88fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < dir->i_size) {
block90fs/minix/namei.cbh = minix_bread(dir,block,0);
block92fs/minix/namei.cblock++;
block104fs/minix/namei.cblock++;
block155fs/minix/namei.cunsigned long block, offset;
block175fs/minix/namei.cblock = offset = 0;
block178fs/minix/namei.cbh = minix_bread(dir,block,1);
block184fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
block186fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
block207fs/minix/namei.cblock++;
block378fs/minix/namei.cunsigned int block, offset;
block386fs/minix/namei.cblock = 0;
block402fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
block404fs/minix/namei.cbh = minix_bread(inode,block,0);
block406fs/minix/namei.cblock++;
block421fs/minix/namei.cblock++;
block287fs/msdos/inode.cint msdos_bmap(struct inode *inode,int block)
block296fs/msdos/inode.creturn (sb->dir_start >> 1)+block;
block298fs/msdos/inode.ccluster = (block*2)/sb->cluster_size;
block299fs/msdos/inode.coffset = (block*2) % sb->cluster_size;
block42fs/sysv/balloc.cvoid sysv_free_block(struct super_block * sb, unsigned int block)
block51fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block69fs/sysv/balloc.cbh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block71fs/sysv/balloc.cbh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block77fs/sysv/balloc.cbh_data = bh->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block109fs/sysv/balloc.cbh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block111fs/sysv/balloc.cbh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block117fs/sysv/balloc.cbh_data = bh->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block127fs/sysv/balloc.cbh = get_hash_table(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block134fs/sysv/balloc.cblock = to_coh_ulong(block);
block135fs/sysv/balloc.csb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)++] = block;
block148fs/sysv/balloc.cunsigned int block;
block161fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[(*sb->sv_sb_flc_count)-1];
block163fs/sysv/balloc.cblock = from_coh_ulong(block);
block164fs/sysv/balloc.cif (block == 0) { /* Applies only to Xenix FS, SystemV FS */
block169fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block170fs/sysv/balloc.cprintk("sysv_new_block: new block %d is not in data zone\n",block);
block178fs/sysv/balloc.cif (!(bh = sysv_bread(sb, sb->s_dev, block, &bh_data))) {
block216fs/sysv/balloc.cbh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block218fs/sysv/balloc.cbh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block224fs/sysv/balloc.cbh_data = bh->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block243fs/sysv/balloc.creturn block;
block250fs/sysv/balloc.cunsigned int block;
block260fs/sysv/balloc.cblock = sb->sv_sb_flc_blocks[--i];
block262fs/sysv/balloc.cblock = from_coh_ulong(block);
block263fs/sysv/balloc.cif (block == 0) /* block 0 terminates list */
block274fs/sysv/balloc.cif (block < sb->sv_firstdatazone || block >= sb->sv_nzones) {
block275fs/sysv/balloc.cprintk("sysv_count_free_blocks: new block %d is not in data zone\n",block);
block278fs/sysv/balloc.cif (!(bh = sysv_bread(sb, sb->s_dev, block, &bh_data))) {
block311fs/sysv/balloc.cblock = flc_blocks[--i];
block313fs/sysv/balloc.cblock = from_coh_ulong(block);
block314fs/sysv/balloc.cif (block == 0) /* block 0 terminates list */
block322fs/sysv/balloc.cif (block == 0) /* Applies only to Xenix FS and SystemV FS */
block113fs/sysv/file.cunsigned int block;
block140fs/sysv/file.cblock = offset >> sb->sv_block_size_bits;
block147fs/sysv/file.cif (block + blocks > size)
block148fs/sysv/file.cblocks = size - block;
block170fs/sysv/file.cbhb->bh = sysv_getblk(inode, block++, 0, &bhb->bh_data);
block32fs/sysv/fsync.cunsigned long tmp, block;
block35fs/sysv/fsync.cblock = tmp = *blockp;
block37fs/sysv/fsync.cblock = from_coh_ulong(block);
block38fs/sysv/fsync.cif (!block)
block41fs/sysv/fsync.cbh = get_hash_table(inode->i_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block66fs/sysv/fsync.cunsigned long tmp, block;
block69fs/sysv/fsync.cblock = tmp = *iblockp;
block71fs/sysv/fsync.cblock = from_coh_ulong(block);
block72fs/sysv/fsync.cif (!block)
block77fs/sysv/fsync.c*bh = sysv_bread(inode->i_sb, inode->i_dev, block, bh_data);
block93fs/sysv/ialloc.cint i,j,ino,block;
block111fs/sysv/ialloc.cfor (i = 0, ino = SYSV_ROOT_INO+1, block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; i < sb->sv_fic_size && block < sb->sv_firstdatazone ; block++, j = 0) {
block112fs/sysv/ialloc.cif (!(bh = sysv_bread(sb, sb->s_dev, block, &bh_data))) {
block167fs/sysv/ialloc.cint j,block,count;
block178fs/sysv/ialloc.cfor (block = sb->sv_firstinodezone, j = SYSV_ROOT_INO ; block < sb->sv_firstdatazone ; block++, j = 0) {
block179fs/sysv/ialloc.cif (!(bh = sysv_bread(sb, sb->s_dev, block, &bh_data))) {
block414fs/sysv/inode.cunsigned int block = block_nr;
block420fs/sysv/inode.cif (block < 10)
block421fs/sysv/inode.creturn inode_bmap(sb,inode,block);
block422fs/sysv/inode.cblock -= 10;
block424fs/sysv/inode.cif (block < IND_PER_BLOCK) {
block429fs/sysv/inode.creturn block_bmap(sb,bh,block,convert);
block431fs/sysv/inode.cblock -= IND_PER_BLOCK;
block432fs/sysv/inode.cif (block < IND_PER_BLOCK*IND_PER_BLOCK) {
block437fs/sysv/inode.ci = block_bmap(sb,bh,block/IND_PER_BLOCK,convert);
block441fs/sysv/inode.creturn block_bmap(sb,bh,block%IND_PER_BLOCK,convert);
block443fs/sysv/inode.cblock -= IND_PER_BLOCK*IND_PER_BLOCK;
block444fs/sysv/inode.cif (block < IND_PER_BLOCK*IND_PER_BLOCK*IND_PER_BLOCK) {
block449fs/sysv/inode.ci = block_bmap(sb,bh,block/(IND_PER_BLOCK*IND_PER_BLOCK),convert);
block453fs/sysv/inode.ci = block_bmap(sb,bh,(block/IND_PER_BLOCK)%IND_PER_BLOCK,convert);
block457fs/sysv/inode.creturn block_bmap(sb,bh,block%IND_PER_BLOCK,convert);
block459fs/sysv/inode.cif ((int)block<0) {
block514fs/sysv/inode.cunsigned long tmp, block;
block531fs/sysv/inode.cblock = tmp = *p;
block533fs/sysv/inode.cblock = from_coh_ulong(block);
block535fs/sysv/inode.cresult = getblk(bh->b_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block538fs/sysv/inode.c*start = result->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block548fs/sysv/inode.cblock = sysv_new_block(sb);
block549fs/sysv/inode.cif (!block) {
block553fs/sysv/inode.cresult = getblk(bh->b_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE);
block555fs/sysv/inode.csysv_free_block(sb,block);
block559fs/sysv/inode.c*p = (sb->sv_convert ? to_coh_ulong(block) : block);
block562fs/sysv/inode.c*start = result->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block566fs/sysv/inode.cstruct buffer_head * sysv_getblk(struct inode * inode, unsigned int block,
block572fs/sysv/inode.cif (block < 10)
block573fs/sysv/inode.creturn inode_getblk(inode,block,create,start);
block574fs/sysv/inode.cblock -= 10;
block575fs/sysv/inode.cif (block < sb->sv_ind_per_block) {
block577fs/sysv/inode.creturn block_getblk(inode, bh, block, create, start);
block579fs/sysv/inode.cblock -= sb->sv_ind_per_block;
block580fs/sysv/inode.cif (block < sb->sv_ind_per_block_2) {
block582fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_bits, create, start);
block583fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create, start);
block585fs/sysv/inode.cblock -= sb->sv_ind_per_block_2;
block586fs/sysv/inode.cif (block < sb->sv_ind_per_block_3) {
block588fs/sysv/inode.cbh = block_getblk(inode, bh, block >> sb->sv_ind_per_block_2_bits, create, start);
block589fs/sysv/inode.cbh = block_getblk(inode, bh, (block >> sb->sv_ind_per_block_bits) & sb->sv_ind_per_block_1, create, start);
block590fs/sysv/inode.creturn block_getblk(inode, bh, block & sb->sv_ind_per_block_1, create, start);
block592fs/sysv/inode.cif ((int)block<0) {
block600fs/sysv/inode.cstruct buffer_head * sysv_file_bread(struct inode * inode, int block, int create, char * *start)
block604fs/sysv/inode.cbh = sysv_getblk(inode,block,create,start);
block646fs/sysv/inode.cunsigned int block, ino;
block657fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
block658fs/sysv/inode.cif (!(bh=sysv_bread(sb,inode->i_dev,block,&bh_data))) {
block688fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block689fs/sysv/inode.cinode->u.sysv_i.i_data[block] =
block690fs/sysv/inode.ccoh_read3byte(&raw_inode->i_a.i_addb[3*block]);
block692fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block693fs/sysv/inode.cinode->u.sysv_i.i_data[block] =
block694fs/sysv/inode.cread3byte(&raw_inode->i_a.i_addb[3*block]);
block731fs/sysv/inode.cunsigned int ino, block;
block741fs/sysv/inode.cblock = sb->sv_firstinodezone + ((ino-1) >> sb->sv_inodes_per_block_bits);
block742fs/sysv/inode.cif (!(bh = sysv_bread(sb,inode->i_dev,block,&bh_data))) {
block770fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block771fs/sysv/inode.ccoh_write3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
block773fs/sysv/inode.cfor (block = 0; block < 10+1+1+1; block++)
block774fs/sysv/inode.cwrite3byte(&raw_inode->i_a.i_addb[3*block],inode->u.sysv_i.i_data[block]);
block69fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block83fs/sysv/namei.cpos = block = offset = 0;
block86fs/sysv/namei.cbh = sysv_file_bread(dir,block,0,&bh_data);
block88fs/sysv/namei.c/* offset = 0; */ block++;
block102fs/sysv/namei.coffset = 0; block++;
block154fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block172fs/sysv/namei.cpos = block = offset = 0;
block175fs/sysv/namei.cbh = sysv_file_bread(dir,block,1,&bh_data);
block204fs/sysv/namei.coffset = 0; block++;
block381fs/sysv/namei.cunsigned long pos, block, offset; /* pos = block * block_size + offset */
block388fs/sysv/namei.cblock = 0;
block407fs/sysv/namei.cbh = sysv_file_bread(inode,block,0,&bh_data);
block409fs/sysv/namei.c/* offset = 0; */ block++;
block425fs/sysv/namei.coffset = 0; block++;
block36fs/sysv/truncate.cunsigned long block;
block40fs/sysv/truncate.cblock = *p;
block41fs/sysv/truncate.cif (!block)
block45fs/sysv/truncate.csysv_free_block(inode->i_sb,block);
block56fs/sysv/truncate.cunsigned long tmp, block, indblock;
block64fs/sysv/truncate.cblock = tmp = *p;
block66fs/sysv/truncate.cblock = from_coh_ulong(block);
block67fs/sysv/truncate.cif (!block)
block69fs/sysv/truncate.cbh = sysv_bread(sb,inode->i_dev,block,&bh_data);
block99fs/sysv/truncate.csysv_free_block(sb,block);
block111fs/sysv/truncate.cunsigned long tmp, block, dindblock;
block120fs/sysv/truncate.cblock = tmp = *p;
block122fs/sysv/truncate.cblock = from_coh_ulong(block);
block123fs/sysv/truncate.cif (!block)
block125fs/sysv/truncate.cbh = sysv_bread(sb,inode->i_dev,block,&bh_data);
block156fs/sysv/truncate.csysv_free_block(sb,block);
block168fs/sysv/truncate.cunsigned long block, tindblock;
block177fs/sysv/truncate.cblock = *p;
block178fs/sysv/truncate.cif (!block)
block180fs/sysv/truncate.cbh = sysv_bread(sb,inode->i_dev,block,&bh_data);
block181fs/sysv/truncate.cif (block != *p) {
block205fs/sysv/truncate.cif (block != *p) {
block211fs/sysv/truncate.csysv_free_block(sb,block);
block260fs/sysv/truncate.cunsigned long block;
block268fs/sysv/truncate.cblock = *p;
block269fs/sysv/truncate.cif (!block)
block271fs/sysv/truncate.cbh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE);
block276fs/sysv/truncate.cif ((bh && bh->b_count != 1) || (block != *p)) {
block284fs/sysv/truncate.csysv_free_block(sb,block);
block298fs/sysv/truncate.cunsigned long tmp, block;
block325fs/sysv/truncate.cblock = tmp = *ind;
block327fs/sysv/truncate.cblock = from_coh_ulong(block);
block328fs/sysv/truncate.cif (!block)
block330fs/sysv/truncate.cbh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE);
block343fs/sysv/truncate.csysv_free_block(sb,block);
block367fs/sysv/truncate.cunsigned long tmp, block;
block392fs/sysv/truncate.cblock = tmp = *ind;
block394fs/sysv/truncate.cblock = from_coh_ulong(block);
block395fs/sysv/truncate.cif (!block)
block421fs/sysv/truncate.cunsigned long tmp, block;
block446fs/sysv/truncate.cblock = tmp = *ind;
block448fs/sysv/truncate.cblock = from_coh_ulong(block);
block449fs/sysv/truncate.cif (!block)
block29fs/xiafs/fsync.cstatic int sync_block (struct inode * inode, unsigned long * block, int wait)
block34fs/xiafs/fsync.cif (!*block)
block36fs/xiafs/fsync.ctmp = *block;
block37fs/xiafs/fsync.cbh = get_hash_table(inode->i_dev, *block, blocksize);
block40fs/xiafs/fsync.cif (*block != tmp) {
block81include/linux/ext_fs.hextern void ext_free_block(struct super_block * sb, int block);
block366include/linux/fs.hextern int bmap(struct inode * inode,int block);
block382include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
block383include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
block389include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
block391include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block,...);
block173include/linux/iso_fs.hextern int isofs_free_block(int dev, int block);
block211include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
block95include/linux/minix_fs.hextern void minix_free_block(struct super_block * sb, int block);
block174include/linux/msdos_fs.hextern int msdos_bmap(struct inode *inode,int block);
block352include/linux/sysv_fs.hsysv_bread (struct super_block *sb, int dev, unsigned int block, char* * data)
block356include/linux/sysv_fs.hif (!(bh = bread (dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE)))
block358include/linux/sysv_fs.h*data = bh->b_data + ((block & sb->sv_block_size_ratio_1) << sb->sv_block_size_bits);
block408include/linux/sysv_fs.hextern void sysv_free_block(struct super_block * sb, unsigned int block);
block118include/linux/xd.hstatic int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count);
block85include/linux/xia_fs.hextern void xiafs_free_zone(struct super_block * sb, int block);
block1150mm/memory.cunsigned int block;
block1157mm/memory.cblock = address - area->vm_start + area->vm_offset;
block1158mm/memory.cblock >>= inode->i_sb->s_blocksize_bits;
block1172mm/memory.cfor (i=0, j=0; i< PAGE_SIZE ; j++, block++, i += inode->i_sb->s_blocksize)
block1173mm/memory.cnr[j] = bmap(inode,block);
block88mm/swap.cunsigned int block;
block91mm/swap.cblock = offset << (12 - p->swap_file->i_sb->s_blocksize_bits);
block94mm/swap.cif (!(zones[i] = bmap(p->swap_file,block++))) {