taglinefilesource code
block18fs/block_dev.cint block = filp->f_pos >> BLOCK_SIZE_BITS;
block33fs/block_dev.cif (block >= size)
block39fs/block_dev.cbh = getblk(dev, block, BLOCK_SIZE);
block41fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
block42fs/block_dev.cblock++;
block64fs/block_dev.cunsigned int block;
block92fs/block_dev.cblock = offset >> BLOCK_SIZE_BITS;
block99fs/block_dev.cif (block + blocks > size)
block100fs/block_dev.cblocks = size - block;
block118fs/block_dev.c*bhb = getblk(dev, block++, BLOCK_SIZE);
block181fs/buffer.c#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
block182fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
block259fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
block263fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
block264fs/buffer.cif (tmp->b_dev==dev && tmp->b_blocknr==block)
block282fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
block287fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
block291fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
block308fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
block315fs/buffer.cbh = get_hash_table(dev, block, size);
block366fs/buffer.cif (find_buffer(dev,block,size))
block375fs/buffer.cbh->b_blocknr=block;
block398fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
block402fs/buffer.cif (!(bh = getblk(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);
block46fs/ext/freelists.cvoid ext_free_block(struct super_block * sb, int block)
block56fs/ext/freelists.cif (block < sb->u.ext_sb.s_firstdatazone ||
block57fs/ext/freelists.cblock >= sb->u.ext_sb.s_nzones) {
block61fs/ext/freelists.cbh = get_hash_table(sb->s_dev, block, sb->s_blocksize);
block69fs/ext/freelists.cprintk("ext_free_block: block full, skipping to %d\n", block);
block74fs/ext/freelists.cblock, sb->s_blocksize)))
block79fs/ext/freelists.csb->u.ext_sb.s_firstfreeblocknumber = block;
block81fs/ext/freelists.cefb->free[efb->count++] = block;
block151fs/ext/freelists.cunsigned long count, block;
block159fs/ext/freelists.cblock = efb->next;
block160fs/ext/freelists.cwhile (block) {
block161fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block163fs/ext/freelists.cblock = 0;
block167fs/ext/freelists.cblock = efb->next;
block185fs/ext/freelists.cunsigned long block;
block220fs/ext/freelists.cblock = 2 + (inode->i_ino - 1) / EXT_INODES_PER_BLOCK;
block221fs/ext/freelists.cif (!(bh = bread(inode->i_dev, block, inode->i_sb->s_blocksize)))
block244fs/ext/freelists.cunsigned long block;
block270fs/ext/freelists.cblock = 2 + (((unsigned long) efi->next) - 1) / EXT_INODES_PER_BLOCK;
block276fs/ext/freelists.cbread(sb->s_dev, block, sb->s_blocksize)))
block304fs/ext/freelists.cunsigned long count, block, ino;
block320fs/ext/freelists.cblock = 2 + ((ino - 1) / EXT_INODES_PER_BLOCK);
block321fs/ext/freelists.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) {
block323fs/ext/freelists.cblock = 0;
block60fs/ext/inode.cint dev = s->s_dev,block;
block101fs/ext/inode.cblock = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK;
block102fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
block170fs/ext/inode.cint ext_bmap(struct inode * inode,int block)
block174fs/ext/inode.cif (block<0) {
block178fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block182fs/ext/inode.cif (block<9)
block183fs/ext/inode.creturn inode_bmap(inode,block);
block184fs/ext/inode.cblock -= 9;
block185fs/ext/inode.cif (block<256) {
block189fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block191fs/ext/inode.cblock -= 256;
block192fs/ext/inode.cif (block<256*256) {
block196fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
block199fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block201fs/ext/inode.cblock -= 256*256;
block205fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
block208fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
block211fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
block297fs/ext/inode.cstruct buffer_head * ext_getblk(struct inode * inode, int block, int create)
block301fs/ext/inode.cif (block<0) {
block305fs/ext/inode.cif (block >= 9+256+256*256+256*256*256) {
block309fs/ext/inode.cif (block<9)
block310fs/ext/inode.creturn inode_getblk(inode,block,create);
block311fs/ext/inode.cblock -= 9;
block312fs/ext/inode.cif (block<256) {
block314fs/ext/inode.creturn block_getblk(inode,bh,block,create);
block316fs/ext/inode.cblock -= 256;
block317fs/ext/inode.cif (block<256*256) {
block319fs/ext/inode.cbh = block_getblk(inode,bh,block>>8,create);
block320fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block322fs/ext/inode.cblock -= 256*256;
block324fs/ext/inode.cbh = block_getblk(inode,bh,block>>16,create);
block325fs/ext/inode.cbh = block_getblk(inode,bh,(block>>8) & 255,create);
block326fs/ext/inode.creturn block_getblk(inode,bh,block & 255,create);
block329fs/ext/inode.cstruct buffer_head * ext_bread(struct inode * inode, int block, int create)
block333fs/ext/inode.cbh = ext_getblk(inode,block,create);
block348fs/ext/inode.cint block;
block350fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block351fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block364fs/ext/inode.celse for (block = 0; block < 12; block++)
block365fs/ext/inode.cinode->u.ext_i.i_data[block] = raw_inode->i_zone[block];
block392fs/ext/inode.cint block;
block394fs/ext/inode.cblock = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK;
block395fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
block407fs/ext/inode.celse for (block = 0; block < 12; block++)
block408fs/ext/inode.craw_inode->i_zone[block] = inode->u.ext_i.i_data[block];
block174fs/ext2/balloc.cvoid ext2_free_block (struct super_block * sb, unsigned long block)
block191fs/ext2/balloc.cif (block < sb->u.ext2_sb.s_first_data_block ||
block192fs/ext2/balloc.cblock >= sb->u.ext2_sb.s_blocks_count) {
block199fs/ext2/balloc.cprintk ("ext2_free_block: freeing block %d\n", block);
block201fs/ext2/balloc.cbh = get_hash_table (sb->s_dev, block, sb->s_blocksize);
block205fs/ext2/balloc.cblock_group = (block - sb->u.ext2_sb.s_first_data_block) /
block207fs/ext2/balloc.cbit = (block - sb->u.ext2_sb.s_first_data_block) %
block217fs/ext2/balloc.csb->s_dev, block);
block76fs/ext2/file.cint block, blocks, offset;
block104fs/ext2/file.cblock = offset >> EXT2_BLOCK_SIZE_BITS(sb);
block111fs/ext2/file.cif (block + blocks > size)
block112fs/ext2/file.cblocks = size - block;
block130fs/ext2/file.c*bhb = ext2_getblk (inode, block++, 0);
block269fs/ext2/inode.cunsigned long block;
block285fs/ext2/inode.cblock = sb->u.ext2_sb.s_first_data_block +
block287fs/ext2/inode.cif (!(bh = bread (sb->s_dev, block, BLOCK_SIZE)))
block291fs/ext2/inode.cprintk ("ext2_write_super: writing super block backup in group %d at block %d\n", i, block);
block298fs/ext2/inode.cblock ++;
block300fs/ext2/inode.cprintk ("ext2_write_super: writing descriptors (block %d) backup in group %d at block %d\n", j, i, block);
block302fs/ext2/inode.cif (!(bh = bread (sb->s_dev, block, sb->s_blocksize)))
block345fs/ext2/inode.cint ext2_bmap (struct inode * inode, int block)
block350fs/ext2/inode.cif (block < 0) {
block354fs/ext2/inode.cif (block >= EXT2_NDIR_BLOCKS + addr_per_block +
block360fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block361fs/ext2/inode.creturn inode_bmap (inode, block);
block362fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block363fs/ext2/inode.cif (block < addr_per_block) {
block368fs/ext2/inode.cinode->i_sb->s_blocksize), block);
block370fs/ext2/inode.cblock -= addr_per_block;
block371fs/ext2/inode.cif (block < addr_per_block * addr_per_block) {
block377fs/ext2/inode.cblock / addr_per_block);
block382fs/ext2/inode.cblock & (addr_per_block - 1));
block384fs/ext2/inode.cblock -= addr_per_block * addr_per_block;
block389fs/ext2/inode.cblock / (addr_per_block * addr_per_block));
block393fs/ext2/inode.c(block / addr_per_block) & (addr_per_block - 1));
block397fs/ext2/inode.cblock & (addr_per_block - 1));
block493fs/ext2/inode.cstruct buffer_head * ext2_getblk (struct inode * inode, int block,
block499fs/ext2/inode.cif (block < 0) {
block503fs/ext2/inode.cif (block > EXT2_NDIR_BLOCKS + addr_per_block  +
block509fs/ext2/inode.cif (block < EXT2_NDIR_BLOCKS)
block510fs/ext2/inode.creturn inode_getblk (inode, block, create);
block511fs/ext2/inode.cblock -= EXT2_NDIR_BLOCKS;
block512fs/ext2/inode.cif (block < addr_per_block) {
block514fs/ext2/inode.creturn block_getblk (inode, bh, block, create,
block517fs/ext2/inode.cblock -= addr_per_block;
block518fs/ext2/inode.cif (block < addr_per_block * addr_per_block) {
block520fs/ext2/inode.cbh = block_getblk (inode, bh, block / addr_per_block, create,
block522fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1),
block525fs/ext2/inode.cblock -= addr_per_block * addr_per_block;
block527fs/ext2/inode.cbh = block_getblk (inode, bh, block / (addr_per_block * addr_per_block),
block529fs/ext2/inode.cbh = block_getblk (inode, bh, (block / addr_per_block) & (addr_per_block - 1),
block531fs/ext2/inode.creturn block_getblk (inode, bh, block & (addr_per_block - 1), create,
block535fs/ext2/inode.cstruct buffer_head * ext2_bread (struct inode * inode, int block, int create)
block539fs/ext2/inode.cbh = ext2_getblk (inode, block, create);
block557fs/ext2/inode.cunsigned long block;
block575fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block578fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block603fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block604fs/ext2/inode.cinode->u.ext2_i.i_data[block] = raw_inode->i_block[block];
block634fs/ext2/inode.cunsigned long block;
block652fs/ext2/inode.cblock = gdp[desc].bg_inode_table +
block655fs/ext2/inode.cif (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize)))
block678fs/ext2/inode.celse for (block = 0; block < EXT2_N_BLOCKS; block++)
block679fs/ext2/inode.craw_inode->i_block[block] = inode->u.ext2_i.i_data[block];
block150fs/inode.cint bmap(struct inode * inode, int block)
block153fs/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);
block66fs/isofs/dir.cunsigned int block,offset,i, j;
block80fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
block81fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
block86fs/isofs/dir.cprintk("Block, offset: %x %x %x\n",block, offset, filp->f_pos);
block89fs/isofs/dir.cinode_number = (block << BLOCK_SIZE_BITS)+(offset & (BLOCK_SIZE - 1));
block98fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
block99fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
block117fs/isofs/dir.cblock = isofs_bmap(inode,(filp->f_pos)>>BLOCK_SIZE_BITS);
block118fs/isofs/dir.cif (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE)))
block90fs/isofs/file.cint block;
block95fs/isofs/file.cblock = isofs_bmap(inode,0);
block96fs/isofs/file.cif (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE))) {
block116fs/isofs/file.cint block, blocks, offset;
block142fs/isofs/file.cblock = filp->f_pos >> ISOFS_BUFFER_BITS;
block166fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE);
block189fs/isofs/file.cif (block >= max_block) break;
block192fs/isofs/file.c*bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE);
block253fs/isofs/inode.cint isofs_bmap(struct inode * inode,int block)
block256fs/isofs/inode.cif (block<0) {
block260fs/isofs/inode.creturn inode->u.isofs_i.i_first_extent + block;
block269fs/isofs/inode.cint block;
block272fs/isofs/inode.cblock = inode->i_ino >> ISOFS_BUFFER_BITS;
block273fs/isofs/inode.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE)))
block285fs/isofs/inode.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE)))
block364fs/isofs/inode.cprintk("Get inode %d: %d %d: %d\n",inode->i_ino, block, 
block448fs/isofs/inode.cunsigned int block,offset;
block457fs/isofs/inode.cblock = extent << (ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS);
block458fs/isofs/inode.cif (!(bh = bread(parent->i_dev, block, ISOFS_BUFFER_SIZE)))  return 0;
block495fs/isofs/inode.cblock = parent_dir << (ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS);
block496fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE)))
block501fs/isofs/inode.cinode_number = (block << ISOFS_BUFFER_BITS)+(offset & (ISOFS_BUFFER_SIZE - 1));
block510fs/isofs/inode.cblock++;
block511fs/isofs/inode.cif(block & 1) return -1;
block512fs/isofs/inode.cif (!block || !(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE)))
block530fs/isofs/inode.cblock++;
block531fs/isofs/inode.cif((block & 1) == 0) return -1;
block532fs/isofs/inode.cif (!(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE)))
block580fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
block582fs/isofs/inode.creturn bread(dev, block, size);
block67fs/isofs/namei.cunsigned int block,i, f_pos, offset, inode_number;
block80fs/isofs/namei.cif (!(block = dir->u.isofs_i.i_first_extent)) return NULL;
block85fs/isofs/namei.cblock = isofs_bmap(dir,f_pos >> ISOFS_BUFFER_BITS);
block86fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE))) return NULL;
block91fs/isofs/namei.cinode_number = (block << ISOFS_BUFFER_BITS)+(offset & (ISOFS_BUFFER_SIZE - 1));
block100fs/isofs/namei.cblock = isofs_bmap(dir,(f_pos)>>ISOFS_BUFFER_BITS);
block101fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE)))
block119fs/isofs/namei.cblock = isofs_bmap(dir,f_pos>>ISOFS_BUFFER_BITS);
block120fs/isofs/namei.cif (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE)))
block55fs/isofs/rock.cint block, offset; \
block58fs/isofs/rock.cblock = cont_extent << 1; \
block60fs/isofs/rock.cif (offset >= 1024) block++; \
block62fs/isofs/rock.cbh = bread(DEV, block, 1024); \
block369fs/isofs/rock.cint block;
block380fs/isofs/rock.cblock = inode->i_ino >> ISOFS_BUFFER_BITS;
block381fs/isofs/rock.cif (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE)))
block392fs/isofs/rock.cif (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE)))
block67fs/minix/bitmap.cvoid minix_free_block(struct super_block * sb, int block)
block76fs/minix/bitmap.cif (block < sb->u.minix_sb.s_firstdatazone ||
block77fs/minix/bitmap.cblock >= sb->u.minix_sb.s_nzones) {
block81fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
block85fs/minix/bitmap.czone = block - sb->u.minix_sb.s_firstdatazone + 1;
block94fs/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);
block55fs/minix/inode.cint i,dev=s->s_dev,block;
block93fs/minix/inode.cblock=2;
block95fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block96fs/minix/inode.cblock++;
block100fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
block101fs/minix/inode.cblock++;
block104fs/minix/inode.cif (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) {
block157fs/minix/inode.cint minix_bmap(struct inode * inode,int block)
block161fs/minix/inode.cif (block<0) {
block165fs/minix/inode.cif (block >= 7+512+512*512) {
block169fs/minix/inode.cif (block < 7)
block170fs/minix/inode.creturn inode_bmap(inode,block);
block171fs/minix/inode.cblock -= 7;
block172fs/minix/inode.cif (block < 512) {
block176fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
block178fs/minix/inode.cblock -= 512;
block182fs/minix/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
block185fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
block271fs/minix/inode.cstruct buffer_head * minix_getblk(struct inode * inode, int block, int create)
block275fs/minix/inode.cif (block<0) {
block279fs/minix/inode.cif (block >= 7+512+512*512) {
block283fs/minix/inode.cif (block < 7)
block284fs/minix/inode.creturn inode_getblk(inode,block,create);
block285fs/minix/inode.cblock -= 7;
block286fs/minix/inode.cif (block < 512) {
block288fs/minix/inode.creturn block_getblk(inode, bh, block, create);
block290fs/minix/inode.cblock -= 512;
block292fs/minix/inode.cbh = block_getblk(inode, bh, block>>9, create);
block293fs/minix/inode.creturn block_getblk(inode, bh, block & 511, create);
block296fs/minix/inode.cstruct buffer_head * minix_bread(struct inode * inode, int block, int create)
block300fs/minix/inode.cbh = minix_getblk(inode,block,create);
block315fs/minix/inode.cint block, ino;
block325fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
block328fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
block344fs/minix/inode.celse for (block = 0; block < 9; block++)
block345fs/minix/inode.cinode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
block371fs/minix/inode.cint ino, block;
block380fs/minix/inode.cblock = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks +
block382fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
block397fs/minix/inode.celse for (block = 0; block < 9; block++)
block398fs/minix/inode.craw_inode->i_zone[block] = inode->u.minix_i.i_data[block];
block66fs/minix/namei.cunsigned long block, offset;
block82fs/minix/namei.cblock = offset = 0;
block83fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < dir->i_size) {
block85fs/minix/namei.cbh = minix_bread(dir,block,0);
block87fs/minix/namei.cblock++;
block99fs/minix/namei.cblock++;
block148fs/minix/namei.cunsigned long block, offset;
block167fs/minix/namei.cblock = offset = 0;
block170fs/minix/namei.cbh = minix_bread(dir,block,1);
block176fs/minix/namei.cif (block*bh->b_size + offset > dir->i_size) {
block178fs/minix/namei.cdir->i_size = block*bh->b_size + offset;
block195fs/minix/namei.cblock++;
block370fs/minix/namei.cunsigned int block, offset;
block378fs/minix/namei.cblock = 0;
block393fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
block395fs/minix/namei.cbh = minix_bread(inode,block,0);
block397fs/minix/namei.cblock++;
block412fs/minix/namei.cblock++;
block216fs/msdos/inode.cint msdos_bmap(struct inode *inode,int block)
block225fs/msdos/inode.creturn (sb->dir_start >> 1)+block;
block227fs/msdos/inode.ccluster = (block*2)/sb->cluster_size;
block228fs/msdos/inode.coffset = (block*2) % sb->cluster_size;
block81include/linux/ext_fs.hextern void ext_free_block(struct super_block * sb, int block);
block348include/linux/fs.hextern int bmap(struct inode * inode,int block);
block362include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
block363include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
block368include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
block370include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block,...);
block162include/linux/iso_fs.hextern int isofs_free_block(int dev, int block);
block204include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
block92include/linux/minix_fs.hextern void minix_free_block(struct super_block * sb, int block);
block149include/linux/msdos_fs.hextern int msdos_bmap(struct inode *inode,int block);
block85include/linux/xia_fs.hextern void xiafs_free_zone(struct super_block * sb, int block);
block64kernel/blk_drv/blk.h#define SUBSECTOR(block) ((block) & SECTOR_MASK)
block924kernel/blk_drv/floppy.cunsigned int block;
block970kernel/blk_drv/floppy.cblock = CURRENT->sector;
block971kernel/blk_drv/floppy.cif (block+2 > floppy->size) {
block975kernel/blk_drv/floppy.csector = block % floppy->sect;
block976kernel/blk_drv/floppy.cblock /= floppy->sect;
block977kernel/blk_drv/floppy.chead = block % floppy->head;
block978kernel/blk_drv/floppy.ctrack = block / floppy->head;
block431kernel/blk_drv/hd.cunsigned int block,dev;
block444kernel/blk_drv/hd.cblock = CURRENT->sector;
block446kernel/blk_drv/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
block449kernel/blk_drv/hd.cblock, hd[dev].nr_sects);
block454kernel/blk_drv/hd.cblock += hd[dev].start_sect;
block456kernel/blk_drv/hd.csec = block % hd_info[dev].sect + 1;
block457kernel/blk_drv/hd.ctrack = block / hd_info[dev].sect;
block92kernel/blk_drv/ramdisk.cint    block = 512;  /* Start at block 512 */
block103kernel/blk_drv/ramdisk.cbh = breada(ROOT_DEV,block+1,block,block+2,-1);
block124kernel/blk_drv/ramdisk.cbh = breada(ROOT_DEV, block, block+1, block+2, -1);
block126kernel/blk_drv/ramdisk.cbh = bread(ROOT_DEV, block, BLOCK_SIZE);
block129kernel/blk_drv/ramdisk.cblock);
block137kernel/blk_drv/ramdisk.cblock++;
block52kernel/blk_drv/scsi/scsi_debug.cif ((bh->b_blocknr << 1) + start != block)           \
block53kernel/blk_drv/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",bh->b_blocknr, block);  \
block73kernel/blk_drv/scsi/scsi_debug.cif (SCpnt->request.sector + start != block) panic("Wrong block.");  \
block77kernel/blk_drv/scsi/scsi_debug.cif ((SCpnt->request.bh->b_blocknr << 1) + start != block)           \
block78kernel/blk_drv/scsi/scsi_debug.c{  printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block);  \
block141kernel/blk_drv/scsi/scsi_debug.cint block, start;
block218kernel/blk_drv/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block220kernel/blk_drv/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block237kernel/blk_drv/scsi/scsi_debug.cif(block == 0 && target == 0) {
block252kernel/blk_drv/scsi/scsi_debug.cif (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors,
block256kernel/blk_drv/scsi/scsi_debug.cif(block == 0xfff0) {
block276kernel/blk_drv/scsi/scsi_debug.cmemcpy(buff+60, &block, sizeof(block));
block281kernel/blk_drv/scsi/scsi_debug.cblock += bufflen >> 9;
block300kernel/blk_drv/scsi/scsi_debug.cblock = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); 
block302kernel/blk_drv/scsi/scsi_debug.cblock = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16);
block312kernel/blk_drv/scsi/scsi_debug.cif (block != *((unsigned long *) (buff+60))) {
block313kernel/blk_drv/scsi/scsi_debug.cprintk("%x %x :",block,  *((unsigned long *) (buff+60)));
block384kernel/blk_drv/scsi/sd.cint dev, block, this_count;
block394kernel/blk_drv/scsi/sd.cblock = SCpnt->request.sector;
block398kernel/blk_drv/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", dev, block);
block401kernel/blk_drv/scsi/sd.cif (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
block407kernel/blk_drv/scsi/sd.cblock += sd[dev].start_sect;
block421kernel/blk_drv/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
block565kernel/blk_drv/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
block571kernel/blk_drv/scsi/sd.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block572kernel/blk_drv/scsi/sd.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block573kernel/blk_drv/scsi/sd.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block574kernel/blk_drv/scsi/sd.ccmd[5] = (unsigned char) block & 0xff;
block584kernel/blk_drv/scsi/sd.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block585kernel/blk_drv/scsi/sd.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block586kernel/blk_drv/scsi/sd.ccmd[3] = (unsigned char) block & 0xff;
block332kernel/blk_drv/scsi/sr.cunsigned int dev, block, realcount;
block343kernel/blk_drv/scsi/sr.cblock = SCpnt->request.sector;  
block524kernel/blk_drv/scsi/sr.cstart = block % 4;
block545kernel/blk_drv/scsi/sr.cblock = block >> 2; /* These are the sectors that the cdrom uses */
block548kernel/blk_drv/scsi/sr.cif (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
block557kernel/blk_drv/scsi/sr.ccmd[2] = (unsigned char) (block >> 24) & 0xff;
block558kernel/blk_drv/scsi/sr.ccmd[3] = (unsigned char) (block >> 16) & 0xff;
block559kernel/blk_drv/scsi/sr.ccmd[4] = (unsigned char) (block >> 8) & 0xff;
block560kernel/blk_drv/scsi/sr.ccmd[5] = (unsigned char) block & 0xff;
block573kernel/blk_drv/scsi/sr.ccmd[1] |= (unsigned char) ((block >> 16) & 0x1f);
block574kernel/blk_drv/scsi/sr.ccmd[2] = (unsigned char) ((block >> 8) & 0xff);
block575kernel/blk_drv/scsi/sr.ccmd[3] = (unsigned char) block & 0xff;
block581kernel/blk_drv/scsi/sr.cprintk("ReadCD: %d %d %d\n",block, realcount, buffer);
block709mm/memory.cunsigned int block,i;
block728mm/memory.cblock = 0;
block731mm/memory.cblock = 1 + address / BLOCK_SIZE;
block737mm/memory.cblock = address - tsk->libraries[i].start;
block738mm/memory.cif (block >= tsk->libraries[i].length + tsk->libraries[i].bss)
block741mm/memory.cif (block < tsk->libraries[i].length)
block742mm/memory.cblock = 1 + block / BLOCK_SIZE;
block744mm/memory.cblock = 0;
block774mm/memory.cif (block) {
block775mm/memory.cfor (i=0 ; i<4 ; block++,i++)
block776mm/memory.cnr[i] = bmap(inode,block);
block94mm/swap.cunsigned int block = offset << 2;
block98mm/swap.cif (!(zones[i] = bmap(p->swap_file,block++))) {