tag | line | file | source code |
block | 20 | fs/block_dev.c | int block; |
block | 41 | fs/block_dev.c | block = filp->f_pos >> blocksize_bits; |
block | 49 | fs/block_dev.c | if (block >= size) |
block | 55 | fs/block_dev.c | bh = getblk(dev, block, blocksize); |
block | 57 | fs/block_dev.c | bh = breada(dev,block,block+1,block+2,-1); |
block | 58 | fs/block_dev.c | block++; |
block | 80 | fs/block_dev.c | unsigned int block; |
block | 120 | fs/block_dev.c | block = offset >> blocksize_bits; |
block | 127 | fs/block_dev.c | if (block + blocks > size) |
block | 128 | fs/block_dev.c | blocks = size - block; |
block | 146 | fs/block_dev.c | *bhb = getblk(dev, block++, blocksize); |
block | 258 | fs/buffer.c | #define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH) |
block | 259 | fs/buffer.c | #define hash(dev,block) hash_table[_hashfn(dev,block)] |
block | 336 | fs/buffer.c | static struct buffer_head * find_buffer(dev_t dev, int block, int size) |
block | 340 | fs/buffer.c | for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next) |
block | 341 | fs/buffer.c | if (tmp->b_dev==dev && tmp->b_blocknr==block) |
block | 359 | fs/buffer.c | struct buffer_head * get_hash_table(dev_t dev, int block, int size) |
block | 364 | fs/buffer.c | if (!(bh=find_buffer(dev,block,size))) |
block | 368 | fs/buffer.c | if (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size) |
block | 424 | fs/buffer.c | struct buffer_head * getblk(dev_t dev, int block, int size) |
block | 431 | fs/buffer.c | bh = get_hash_table(dev, block, size); |
block | 483 | fs/buffer.c | if (find_buffer(dev,block,size)) |
block | 493 | fs/buffer.c | bh->b_blocknr=block; |
block | 516 | fs/buffer.c | struct buffer_head * bread(dev_t dev, int block, int size) |
block | 520 | fs/buffer.c | if (!(bh = getblk(dev, block, size))) { |
block | 684 | fs/buffer.c | int block; |
block | 696 | fs/buffer.c | block = *++b; |
block | 697 | fs/buffer.c | if (!block) |
block | 699 | fs/buffer.c | first = get_hash_table(dev, block, size); |
block | 725 | fs/buffer.c | int block; |
block | 732 | fs/buffer.c | block = *(p++); |
block | 733 | fs/buffer.c | if (!block) |
block | 735 | fs/buffer.c | tmp = get_hash_table(dev, block, size); |
block | 743 | fs/buffer.c | block = 0; |
block | 745 | fs/buffer.c | arr[block++] = bh; |
block | 761 | fs/buffer.c | read_buffers(arr,block); |
block | 762 | fs/buffer.c | while (block-- > 0) |
block | 763 | fs/buffer.c | brelse(arr[block]); |
block | 789 | fs/buffer.c | int block; |
block | 791 | fs/buffer.c | block = b[0]; |
block | 792 | fs/buffer.c | if (!block) |
block | 794 | fs/buffer.c | bh = get_hash_table(dev, block, size); |
block | 75 | fs/ext/file.c | int block, blocks, offset; |
block | 101 | fs/ext/file.c | block = offset >> BLOCK_SIZE_BITS; |
block | 108 | fs/ext/file.c | if (block + blocks > size) |
block | 109 | fs/ext/file.c | blocks = size - block; |
block | 127 | fs/ext/file.c | *bhb = ext_getblk(inode, block++, 0); |
block | 47 | fs/ext/freelists.c | void ext_free_block(struct super_block * sb, int block) |
block | 57 | fs/ext/freelists.c | if (block < sb->u.ext_sb.s_firstdatazone || |
block | 58 | fs/ext/freelists.c | block >= sb->u.ext_sb.s_nzones) { |
block | 62 | fs/ext/freelists.c | bh = get_hash_table(sb->s_dev, block, sb->s_blocksize); |
block | 70 | fs/ext/freelists.c | printk("ext_free_block: block full, skipping to %d\n", block); |
block | 75 | fs/ext/freelists.c | block, sb->s_blocksize))) |
block | 80 | fs/ext/freelists.c | sb->u.ext_sb.s_firstfreeblocknumber = block; |
block | 82 | fs/ext/freelists.c | efb->free[efb->count++] = block; |
block | 152 | fs/ext/freelists.c | unsigned long count, block; |
block | 160 | fs/ext/freelists.c | block = efb->next; |
block | 161 | fs/ext/freelists.c | while (block) { |
block | 162 | fs/ext/freelists.c | if (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) { |
block | 164 | fs/ext/freelists.c | block = 0; |
block | 168 | fs/ext/freelists.c | block = efb->next; |
block | 187 | fs/ext/freelists.c | unsigned long block; |
block | 228 | fs/ext/freelists.c | block = 2 + (ino - 1) / EXT_INODES_PER_BLOCK; |
block | 229 | fs/ext/freelists.c | if (!(bh = bread(dev, block, sb->s_blocksize))) |
block | 251 | fs/ext/freelists.c | unsigned long block; |
block | 277 | fs/ext/freelists.c | block = 2 + (((unsigned long) efi->next) - 1) / EXT_INODES_PER_BLOCK; |
block | 283 | fs/ext/freelists.c | bread(sb->s_dev, block, sb->s_blocksize))) |
block | 312 | fs/ext/freelists.c | unsigned long count, block, ino; |
block | 328 | fs/ext/freelists.c | block = 2 + ((ino - 1) / EXT_INODES_PER_BLOCK); |
block | 329 | fs/ext/freelists.c | if (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) { |
block | 331 | fs/ext/freelists.c | block = 0; |
block | 31 | fs/ext/fsync.c | static int sync_block (struct inode * inode, unsigned long * block, int wait) |
block | 36 | fs/ext/fsync.c | if (!*block) |
block | 38 | fs/ext/fsync.c | tmp = *block; |
block | 39 | fs/ext/fsync.c | bh = get_hash_table(inode->i_dev, *block, blocksize); |
block | 42 | fs/ext/fsync.c | if (*block != tmp) { |
block | 62 | fs/ext/inode.c | int dev = s->s_dev,block; |
block | 107 | fs/ext/inode.c | block = 2 + (s->u.ext_sb.s_firstfreeinodenumber - 1) / EXT_INODES_PER_BLOCK; |
block | 108 | fs/ext/inode.c | if (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) { |
block | 177 | fs/ext/inode.c | int ext_bmap(struct inode * inode,int block) |
block | 181 | fs/ext/inode.c | if (block<0) { |
block | 185 | fs/ext/inode.c | if (block >= 9+256+256*256+256*256*256) { |
block | 189 | fs/ext/inode.c | if (block<9) |
block | 190 | fs/ext/inode.c | return inode_bmap(inode,block); |
block | 191 | fs/ext/inode.c | block -= 9; |
block | 192 | fs/ext/inode.c | if (block<256) { |
block | 196 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
block | 198 | fs/ext/inode.c | block -= 256; |
block | 199 | fs/ext/inode.c | if (block<256*256) { |
block | 203 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8); |
block | 206 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
block | 208 | fs/ext/inode.c | block -= 256*256; |
block | 212 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16); |
block | 215 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255); |
block | 218 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
block | 304 | fs/ext/inode.c | struct buffer_head * ext_getblk(struct inode * inode, int block, int create) |
block | 308 | fs/ext/inode.c | if (block<0) { |
block | 312 | fs/ext/inode.c | if (block >= 9+256+256*256+256*256*256) { |
block | 316 | fs/ext/inode.c | if (block<9) |
block | 317 | fs/ext/inode.c | return inode_getblk(inode,block,create); |
block | 318 | fs/ext/inode.c | block -= 9; |
block | 319 | fs/ext/inode.c | if (block<256) { |
block | 321 | fs/ext/inode.c | return block_getblk(inode,bh,block,create); |
block | 323 | fs/ext/inode.c | block -= 256; |
block | 324 | fs/ext/inode.c | if (block<256*256) { |
block | 326 | fs/ext/inode.c | bh = block_getblk(inode,bh,block>>8,create); |
block | 327 | fs/ext/inode.c | return block_getblk(inode,bh,block & 255,create); |
block | 329 | fs/ext/inode.c | block -= 256*256; |
block | 331 | fs/ext/inode.c | bh = block_getblk(inode,bh,block>>16,create); |
block | 332 | fs/ext/inode.c | bh = block_getblk(inode,bh,(block>>8) & 255,create); |
block | 333 | fs/ext/inode.c | return block_getblk(inode,bh,block & 255,create); |
block | 336 | fs/ext/inode.c | struct buffer_head * ext_bread(struct inode * inode, int block, int create) |
block | 340 | fs/ext/inode.c | bh = ext_getblk(inode,block,create); |
block | 355 | fs/ext/inode.c | int block; |
block | 357 | fs/ext/inode.c | block = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK; |
block | 358 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
block | 371 | fs/ext/inode.c | else for (block = 0; block < 12; block++) |
block | 372 | fs/ext/inode.c | inode->u.ext_i.i_data[block] = raw_inode->i_zone[block]; |
block | 393 | fs/ext/inode.c | int block; |
block | 395 | fs/ext/inode.c | block = 2 + (inode->i_ino-1)/EXT_INODES_PER_BLOCK; |
block | 396 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
block | 408 | fs/ext/inode.c | else for (block = 0; block < 12; block++) |
block | 409 | fs/ext/inode.c | raw_inode->i_zone[block] = inode->u.ext_i.i_data[block]; |
block | 225 | fs/ext2/balloc.c | void ext2_free_block (struct super_block * sb, unsigned long block) |
block | 242 | fs/ext2/balloc.c | if (block < sb->u.ext2_sb.s_first_data_block || |
block | 243 | fs/ext2/balloc.c | block >= sb->u.ext2_sb.s_blocks_count) { |
block | 250 | fs/ext2/balloc.c | printk ("ext2_free_block: freeing block %d\n", block); |
block | 252 | fs/ext2/balloc.c | bh = get_hash_table (sb->s_dev, block, sb->s_blocksize); |
block | 256 | fs/ext2/balloc.c | block_group = (block - sb->u.ext2_sb.s_first_data_block) / |
block | 258 | fs/ext2/balloc.c | bit = (block - sb->u.ext2_sb.s_first_data_block) % |
block | 268 | fs/ext2/balloc.c | sb->s_dev, block); |
block | 76 | fs/ext2/file.c | int block, blocks, offset; |
block | 105 | fs/ext2/file.c | block = offset >> EXT2_BLOCK_SIZE_BITS(sb); |
block | 113 | fs/ext2/file.c | if (block + blocks > size) |
block | 114 | fs/ext2/file.c | blocks = size - block; |
block | 132 | fs/ext2/file.c | *bhb = ext2_getblk (inode, block++, 0, &err); |
block | 30 | fs/ext2/fsync.c | static int sync_block (struct inode * inode, unsigned long * block, int wait) |
block | 35 | fs/ext2/fsync.c | if (!*block) |
block | 37 | fs/ext2/fsync.c | tmp = *block; |
block | 38 | fs/ext2/fsync.c | bh = get_hash_table(inode->i_dev, *block, blocksize); |
block | 41 | fs/ext2/fsync.c | if (*block != tmp) { |
block | 321 | fs/ext2/inode.c | unsigned long block; |
block | 331 | fs/ext2/inode.c | block = sb->u.ext2_sb.s_first_data_block + |
block | 333 | fs/ext2/inode.c | if (!(bh = bread (sb->s_dev, block, BLOCK_SIZE))) |
block | 337 | fs/ext2/inode.c | printk ("ext2_commit_super: writing super block backup in group %d at block %d\n", i, block); |
block | 344 | fs/ext2/inode.c | block ++; |
block | 346 | fs/ext2/inode.c | printk ("ext2_commit_super: writing descriptors (block %d) backup in group %d at block %d\n", j, i, block); |
block | 348 | fs/ext2/inode.c | if (!(bh = bread (sb->s_dev, block, sb->s_blocksize))) |
block | 435 | fs/ext2/inode.c | int ext2_bmap (struct inode * inode, int block) |
block | 440 | fs/ext2/inode.c | if (block < 0) { |
block | 444 | fs/ext2/inode.c | if (block >= EXT2_NDIR_BLOCKS + addr_per_block + |
block | 450 | fs/ext2/inode.c | if (block < EXT2_NDIR_BLOCKS) |
block | 451 | fs/ext2/inode.c | return inode_bmap (inode, block); |
block | 452 | fs/ext2/inode.c | block -= EXT2_NDIR_BLOCKS; |
block | 453 | fs/ext2/inode.c | if (block < addr_per_block) { |
block | 458 | fs/ext2/inode.c | inode->i_sb->s_blocksize), block); |
block | 460 | fs/ext2/inode.c | block -= addr_per_block; |
block | 461 | fs/ext2/inode.c | if (block < addr_per_block * addr_per_block) { |
block | 467 | fs/ext2/inode.c | block / addr_per_block); |
block | 472 | fs/ext2/inode.c | block & (addr_per_block - 1)); |
block | 474 | fs/ext2/inode.c | block -= addr_per_block * addr_per_block; |
block | 479 | fs/ext2/inode.c | block / (addr_per_block * addr_per_block)); |
block | 483 | fs/ext2/inode.c | (block / addr_per_block) & (addr_per_block - 1)); |
block | 487 | fs/ext2/inode.c | block & (addr_per_block - 1)); |
block | 629 | fs/ext2/inode.c | struct buffer_head * ext2_getblk (struct inode * inode, int block, |
block | 637 | fs/ext2/inode.c | if (block < 0) { |
block | 641 | fs/ext2/inode.c | if (block > EXT2_NDIR_BLOCKS + addr_per_block + |
block | 651 | fs/ext2/inode.c | printk ("ext2_getblk: block %d, next %d, goal %d.\n", block, |
block | 655 | fs/ext2/inode.c | if (block == inode->u.ext2_i.i_next_alloc_block + 1) { |
block | 661 | fs/ext2/inode.c | b = block; |
block | 662 | fs/ext2/inode.c | if (block < EXT2_NDIR_BLOCKS) |
block | 663 | fs/ext2/inode.c | return inode_getblk (inode, block, create, b, err); |
block | 664 | fs/ext2/inode.c | block -= EXT2_NDIR_BLOCKS; |
block | 665 | fs/ext2/inode.c | if (block < addr_per_block) { |
block | 667 | fs/ext2/inode.c | return block_getblk (inode, bh, block, create, |
block | 670 | fs/ext2/inode.c | block -= addr_per_block; |
block | 671 | fs/ext2/inode.c | if (block < addr_per_block * addr_per_block) { |
block | 673 | fs/ext2/inode.c | bh = block_getblk (inode, bh, block / addr_per_block, create, |
block | 675 | fs/ext2/inode.c | return block_getblk (inode, bh, block & (addr_per_block - 1), |
block | 678 | fs/ext2/inode.c | block -= addr_per_block * addr_per_block; |
block | 680 | fs/ext2/inode.c | bh = block_getblk (inode, bh, block/(addr_per_block * addr_per_block), |
block | 682 | fs/ext2/inode.c | bh = block_getblk (inode, bh, (block/addr_per_block) & (addr_per_block - 1), |
block | 684 | fs/ext2/inode.c | return block_getblk (inode, bh, block & (addr_per_block - 1), create, |
block | 688 | fs/ext2/inode.c | struct buffer_head * ext2_bread (struct inode * inode, int block, |
block | 693 | fs/ext2/inode.c | bh = ext2_getblk (inode, block, create, err); |
block | 712 | fs/ext2/inode.c | unsigned long block; |
block | 731 | fs/ext2/inode.c | block = gdp[desc].bg_inode_table + |
block | 734 | fs/ext2/inode.c | if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize))) |
block | 761 | fs/ext2/inode.c | else for (block = 0; block < EXT2_N_BLOCKS; block++) |
block | 762 | fs/ext2/inode.c | inode->u.ext2_i.i_data[block] = raw_inode->i_block[block]; |
block | 789 | fs/ext2/inode.c | unsigned long block; |
block | 807 | fs/ext2/inode.c | block = gdp[desc].bg_inode_table + |
block | 810 | fs/ext2/inode.c | if (!(bh = bread (inode->i_dev, block, inode->i_sb->s_blocksize))) |
block | 833 | fs/ext2/inode.c | else for (block = 0; block < EXT2_N_BLOCKS; block++) |
block | 834 | fs/ext2/inode.c | raw_inode->i_block[block] = inode->u.ext2_i.i_data[block]; |
block | 261 | fs/inode.c | int bmap(struct inode * inode, int block) |
block | 264 | fs/inode.c | return inode->i_op->bmap(inode,block); |
block | 19 | fs/ioctl.c | int block; |
block | 30 | fs/ioctl.c | block = get_fs_long((long *) arg); |
block | 31 | fs/ioctl.c | block = filp->f_inode->i_op->bmap(filp->f_inode,block); |
block | 32 | fs/ioctl.c | put_fs_long(block,(long *) arg); |
block | 66 | fs/isofs/dir.c | unsigned int block,offset,i, j; |
block | 80 | fs/isofs/dir.c | block = isofs_bmap(inode,(filp->f_pos)>>ISOFS_BUFFER_BITS(inode)); |
block | 81 | fs/isofs/dir.c | if (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode)))) |
block | 86 | fs/isofs/dir.c | printk("Block, offset: %x %x %x\n",block, offset, filp->f_pos); |
block | 89 | fs/isofs/dir.c | inode_number = (block << ISOFS_BUFFER_BITS(inode))+(offset & (ISOFS_BUFFER_SIZE(inode) - 1)); |
block | 98 | fs/isofs/dir.c | block = isofs_bmap(inode,(filp->f_pos)>>ISOFS_BUFFER_BITS(inode)); |
block | 99 | fs/isofs/dir.c | if (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode)))) |
block | 118 | fs/isofs/dir.c | block = isofs_bmap(inode,(filp->f_pos)>> ISOFS_BUFFER_BITS(inode)); |
block | 119 | fs/isofs/dir.c | if (!block || !(bh = bread(inode->i_dev,block,ISOFS_BUFFER_SIZE(inode)))) |
block | 91 | fs/isofs/file.c | int block; |
block | 96 | fs/isofs/file.c | block = isofs_bmap(inode,0); |
block | 97 | fs/isofs/file.c | if (block && (bh = bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) { |
block | 117 | fs/isofs/file.c | int block, blocks, offset; |
block | 143 | fs/isofs/file.c | block = filp->f_pos >> ISOFS_BUFFER_BITS(inode); |
block | 167 | fs/isofs/file.c | *bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode)); |
block | 190 | fs/isofs/file.c | if (block >= max_block) break; |
block | 193 | fs/isofs/file.c | *bhb = getblk(inode->i_dev,isofs_bmap(inode, block++), ISOFS_BUFFER_SIZE(inode)); |
block | 283 | fs/isofs/inode.c | int isofs_bmap(struct inode * inode,int block) |
block | 286 | fs/isofs/inode.c | if (block<0) { |
block | 290 | fs/isofs/inode.c | return inode->u.isofs_i.i_first_extent + block; |
block | 300 | fs/isofs/inode.c | int block; |
block | 303 | fs/isofs/inode.c | block = inode->i_ino >> ISOFS_BUFFER_BITS(inode); |
block | 304 | fs/isofs/inode.c | if (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) |
block | 317 | fs/isofs/inode.c | if (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE(inode)))) |
block | 396 | fs/isofs/inode.c | printk("Get inode %d: %d %d: %d\n",inode->i_ino, block, |
block | 474 | fs/isofs/inode.c | unsigned int block,offset; |
block | 483 | fs/isofs/inode.c | block = extent << (ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(parent)); |
block | 484 | fs/isofs/inode.c | if (!(bh = bread(parent->i_dev, block, ISOFS_BUFFER_SIZE(parent)))) return 0; |
block | 521 | fs/isofs/inode.c | block = parent_dir << (ISOFS_BLOCK_BITS - ISOFS_BUFFER_BITS(parent)); |
block | 522 | fs/isofs/inode.c | if (!block || !(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE(parent)))) |
block | 527 | fs/isofs/inode.c | inode_number = (block << ISOFS_BUFFER_BITS(parent))+(offset & (ISOFS_BUFFER_SIZE(parent) - 1)); |
block | 536 | fs/isofs/inode.c | block++; |
block | 537 | fs/isofs/inode.c | if(block & 1) return -1; |
block | 538 | fs/isofs/inode.c | if (!block || !(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE(parent)))) |
block | 557 | fs/isofs/inode.c | block++; |
block | 558 | fs/isofs/inode.c | if((block & 1) == 0) return -1; |
block | 559 | fs/isofs/inode.c | if (!(bh = bread(parent->i_dev,block, ISOFS_BUFFER_SIZE(parent)))) |
block | 607 | fs/isofs/inode.c | struct buffer_head * leak_check_bread(int dev, int block, int size){ |
block | 609 | fs/isofs/inode.c | return bread(dev, block, size); |
block | 67 | fs/isofs/namei.c | unsigned int block,i, f_pos, offset, inode_number; |
block | 80 | fs/isofs/namei.c | if (!(block = dir->u.isofs_i.i_first_extent)) return NULL; |
block | 85 | fs/isofs/namei.c | block = isofs_bmap(dir,f_pos >> ISOFS_BUFFER_BITS(dir)); |
block | 87 | fs/isofs/namei.c | if (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE(dir)))) return NULL; |
block | 92 | fs/isofs/namei.c | inode_number = (block << ISOFS_BUFFER_BITS(dir))+(offset & (ISOFS_BUFFER_SIZE(dir) - 1)); |
block | 101 | fs/isofs/namei.c | block = isofs_bmap(dir,(f_pos)>>ISOFS_BUFFER_BITS(dir)); |
block | 102 | fs/isofs/namei.c | if (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE(dir)))) |
block | 120 | fs/isofs/namei.c | block = isofs_bmap(dir,f_pos>>ISOFS_BUFFER_BITS(dir)); |
block | 121 | fs/isofs/namei.c | if (!block || !(bh = bread(dir->i_dev,block,ISOFS_BUFFER_SIZE(dir)))) |
block | 55 | fs/isofs/rock.c | int block, offset; \ |
block | 58 | fs/isofs/rock.c | block = cont_extent; \ |
block | 61 | fs/isofs/rock.c | block <<= 1; \ |
block | 62 | fs/isofs/rock.c | if (offset >= 1024) block++; \ |
block | 65 | fs/isofs/rock.c | bh = bread(DEV->i_dev, block, ISOFS_BUFFER_SIZE(DEV)); \ |
block | 372 | fs/isofs/rock.c | int block; |
block | 383 | fs/isofs/rock.c | block = inode->i_ino >> ISOFS_BUFFER_BITS(inode); |
block | 384 | fs/isofs/rock.c | if (!(bh=bread(inode->i_dev,block, ISOFS_BUFFER_SIZE(inode)))) |
block | 395 | fs/isofs/rock.c | if (!(bh = bread(inode->i_dev,++block, ISOFS_BUFFER_SIZE(inode)))) |
block | 68 | fs/minix/bitmap.c | void minix_free_block(struct super_block * sb, int block) |
block | 77 | fs/minix/bitmap.c | if (block < sb->u.minix_sb.s_firstdatazone || |
block | 78 | fs/minix/bitmap.c | block >= sb->u.minix_sb.s_nzones) { |
block | 82 | fs/minix/bitmap.c | bh = get_hash_table(sb->s_dev,block,BLOCK_SIZE); |
block | 86 | fs/minix/bitmap.c | zone = block - sb->u.minix_sb.s_firstdatazone + 1; |
block | 95 | fs/minix/bitmap.c | printk("free_block (%04x:%d): bit already cleared\n",sb->s_dev,block); |
block | 69 | fs/minix/file.c | int block, blocks, offset; |
block | 95 | fs/minix/file.c | block = offset >> BLOCK_SIZE_BITS; |
block | 102 | fs/minix/file.c | if (block + blocks > size) |
block | 103 | fs/minix/file.c | blocks = size - block; |
block | 121 | fs/minix/file.c | *bhb = minix_getblk(inode, block++, 0); |
block | 28 | fs/minix/fsync.c | static int sync_block (struct inode * inode, unsigned short * block, int wait) |
block | 33 | fs/minix/fsync.c | if (!*block) |
block | 35 | fs/minix/fsync.c | tmp = *block; |
block | 36 | fs/minix/fsync.c | bh = get_hash_table(inode->i_dev, *block, blocksize); |
block | 39 | fs/minix/fsync.c | if (*block != tmp) { |
block | 57 | fs/minix/inode.c | int i,dev=s->s_dev,block; |
block | 98 | fs/minix/inode.c | block=2; |
block | 100 | fs/minix/inode.c | if ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
block | 101 | fs/minix/inode.c | block++; |
block | 105 | fs/minix/inode.c | if ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
block | 106 | fs/minix/inode.c | block++; |
block | 109 | fs/minix/inode.c | if (block != 2+s->u.minix_sb.s_imap_blocks+s->u.minix_sb.s_zmap_blocks) { |
block | 165 | fs/minix/inode.c | int minix_bmap(struct inode * inode,int block) |
block | 169 | fs/minix/inode.c | if (block<0) { |
block | 173 | fs/minix/inode.c | if (block >= 7+512+512*512) { |
block | 177 | fs/minix/inode.c | if (block < 7) |
block | 178 | fs/minix/inode.c | return inode_bmap(inode,block); |
block | 179 | fs/minix/inode.c | block -= 7; |
block | 180 | fs/minix/inode.c | if (block < 512) { |
block | 184 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
block | 186 | fs/minix/inode.c | block -= 512; |
block | 190 | fs/minix/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9); |
block | 193 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511); |
block | 279 | fs/minix/inode.c | struct buffer_head * minix_getblk(struct inode * inode, int block, int create) |
block | 283 | fs/minix/inode.c | if (block<0) { |
block | 287 | fs/minix/inode.c | if (block >= 7+512+512*512) { |
block | 291 | fs/minix/inode.c | if (block < 7) |
block | 292 | fs/minix/inode.c | return inode_getblk(inode,block,create); |
block | 293 | fs/minix/inode.c | block -= 7; |
block | 294 | fs/minix/inode.c | if (block < 512) { |
block | 296 | fs/minix/inode.c | return block_getblk(inode, bh, block, create); |
block | 298 | fs/minix/inode.c | block -= 512; |
block | 300 | fs/minix/inode.c | bh = block_getblk(inode, bh, block>>9, create); |
block | 301 | fs/minix/inode.c | return block_getblk(inode, bh, block & 511, create); |
block | 304 | fs/minix/inode.c | struct buffer_head * minix_bread(struct inode * inode, int block, int create) |
block | 308 | fs/minix/inode.c | bh = minix_getblk(inode,block,create); |
block | 323 | fs/minix/inode.c | int block, ino; |
block | 333 | fs/minix/inode.c | block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + |
block | 336 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) { |
block | 352 | fs/minix/inode.c | else for (block = 0; block < 9; block++) |
block | 353 | fs/minix/inode.c | inode->u.minix_i.i_data[block] = raw_inode->i_zone[block]; |
block | 373 | fs/minix/inode.c | int ino, block; |
block | 382 | fs/minix/inode.c | block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks + inode->i_sb->u.minix_sb.s_zmap_blocks + |
block | 384 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) { |
block | 399 | fs/minix/inode.c | else for (block = 0; block < 9; block++) |
block | 400 | fs/minix/inode.c | raw_inode->i_zone[block] = inode->u.minix_i.i_data[block]; |
block | 71 | fs/minix/namei.c | unsigned long block, offset; |
block | 87 | fs/minix/namei.c | block = offset = 0; |
block | 88 | fs/minix/namei.c | while (block*BLOCK_SIZE+offset < dir->i_size) { |
block | 90 | fs/minix/namei.c | bh = minix_bread(dir,block,0); |
block | 92 | fs/minix/namei.c | block++; |
block | 104 | fs/minix/namei.c | block++; |
block | 155 | fs/minix/namei.c | unsigned long block, offset; |
block | 175 | fs/minix/namei.c | block = offset = 0; |
block | 178 | fs/minix/namei.c | bh = minix_bread(dir,block,1); |
block | 184 | fs/minix/namei.c | if (block*bh->b_size + offset > dir->i_size) { |
block | 186 | fs/minix/namei.c | dir->i_size = block*bh->b_size + offset; |
block | 208 | fs/minix/namei.c | block++; |
block | 381 | fs/minix/namei.c | unsigned int block, offset; |
block | 389 | fs/minix/namei.c | block = 0; |
block | 405 | fs/minix/namei.c | while (block*BLOCK_SIZE+offset < inode->i_size) { |
block | 407 | fs/minix/namei.c | bh = minix_bread(inode,block,0); |
block | 409 | fs/minix/namei.c | block++; |
block | 424 | fs/minix/namei.c | block++; |
block | 287 | fs/msdos/inode.c | int msdos_bmap(struct inode *inode,int block) |
block | 296 | fs/msdos/inode.c | return (sb->dir_start >> 1)+block; |
block | 298 | fs/msdos/inode.c | cluster = (block*2)/sb->cluster_size; |
block | 299 | fs/msdos/inode.c | offset = (block*2) % sb->cluster_size; |
block | 30 | fs/xiafs/fsync.c | static int sync_block (struct inode * inode, unsigned long * block, int wait) |
block | 35 | fs/xiafs/fsync.c | if (!*block) |
block | 37 | fs/xiafs/fsync.c | tmp = *block; |
block | 38 | fs/xiafs/fsync.c | bh = get_hash_table(inode->i_dev, *block, blocksize); |
block | 41 | fs/xiafs/fsync.c | if (*block != tmp) { |
block | 81 | include/linux/ext_fs.h | extern void ext_free_block(struct super_block * sb, int block); |
block | 364 | include/linux/fs.h | extern int bmap(struct inode * inode,int block); |
block | 379 | include/linux/fs.h | extern struct buffer_head * get_hash_table(dev_t dev, int block, int size); |
block | 380 | include/linux/fs.h | extern struct buffer_head * getblk(dev_t dev, int block, int size); |
block | 386 | include/linux/fs.h | extern struct buffer_head * bread(dev_t dev, int block, int size); |
block | 388 | include/linux/fs.h | extern struct buffer_head * breada(dev_t dev,int block,...); |
block | 173 | include/linux/iso_fs.h | extern int isofs_free_block(int dev, int block); |
block | 212 | include/linux/iso_fs.h | extern struct buffer_head * leak_check_bread(int dev, int block, int size); |
block | 92 | include/linux/minix_fs.h | extern void minix_free_block(struct super_block * sb, int block); |
block | 174 | include/linux/msdos_fs.h | extern int msdos_bmap(struct inode *inode,int block); |
block | 120 | include/linux/xd.h | static int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count); |
block | 85 | include/linux/xia_fs.h | extern void xiafs_free_zone(struct super_block * sb, int block); |
block | 69 | kernel/blk_drv/blk.h | #define SUBSECTOR(block) (CURRENT->current_nr_sectors > 0) |
block | 990 | kernel/blk_drv/floppy.c | unsigned int block; |
block | 1038 | kernel/blk_drv/floppy.c | block = CURRENT->sector; |
block | 1039 | kernel/blk_drv/floppy.c | if (block+2 > floppy->size) { |
block | 1043 | kernel/blk_drv/floppy.c | sector = block % floppy->sect; |
block | 1044 | kernel/blk_drv/floppy.c | block /= floppy->sect; |
block | 1045 | kernel/blk_drv/floppy.c | head = block % floppy->head; |
block | 1046 | kernel/blk_drv/floppy.c | track = block / floppy->head; |
block | 451 | kernel/blk_drv/hd.c | unsigned int block,dev; |
block | 464 | kernel/blk_drv/hd.c | block = CURRENT->sector; |
block | 466 | kernel/blk_drv/hd.c | if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) { |
block | 469 | kernel/blk_drv/hd.c | block, hd[dev].nr_sects); |
block | 474 | kernel/blk_drv/hd.c | block += hd[dev].start_sect; |
block | 476 | kernel/blk_drv/hd.c | sec = block % hd_info[dev].sect + 1; |
block | 477 | kernel/blk_drv/hd.c | track = block / hd_info[dev].sect; |
block | 107 | kernel/blk_drv/ramdisk.c | int block, try; |
block | 129 | kernel/blk_drv/ramdisk.c | block = try; |
block | 130 | kernel/blk_drv/ramdisk.c | bh = breada(ROOT_DEV,block+1,block,block+2,-1); |
block | 157 | kernel/blk_drv/ramdisk.c | bh = breada(ROOT_DEV, block, block+1, block+2, -1); |
block | 159 | kernel/blk_drv/ramdisk.c | bh = bread(ROOT_DEV, block, BLOCK_SIZE); |
block | 162 | kernel/blk_drv/ramdisk.c | block); |
block | 169 | kernel/blk_drv/ramdisk.c | block++; |
block | 52 | kernel/blk_drv/scsi/scsi_debug.c | if ((bh->b_blocknr << 1) + start != block) \ |
block | 53 | kernel/blk_drv/scsi/scsi_debug.c | { printk("Wrong bh block# %d %d ",bh->b_blocknr, block); \ |
block | 73 | kernel/blk_drv/scsi/scsi_debug.c | if (SCpnt->request.sector + start != block) panic("Wrong block."); \ |
block | 77 | kernel/blk_drv/scsi/scsi_debug.c | if ((SCpnt->request.bh->b_blocknr << 1) + start != block) \ |
block | 78 | kernel/blk_drv/scsi/scsi_debug.c | { printk("Wrong bh block# %d %d ",SCpnt->request.bh->b_blocknr, block); \ |
block | 141 | kernel/blk_drv/scsi/scsi_debug.c | int block, start; |
block | 218 | kernel/blk_drv/scsi/scsi_debug.c | block = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); |
block | 220 | kernel/blk_drv/scsi/scsi_debug.c | block = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16); |
block | 237 | kernel/blk_drv/scsi/scsi_debug.c | if(block == 0 && target == 0) { |
block | 252 | kernel/blk_drv/scsi/scsi_debug.c | if (SCpnt->use_sg) printk("Block %x (%d %d)\n",block, SCpnt->request.nr_sectors, |
block | 256 | kernel/blk_drv/scsi/scsi_debug.c | if(block == 0xfff0) { |
block | 276 | kernel/blk_drv/scsi/scsi_debug.c | memcpy(buff+60, &block, sizeof(block)); |
block | 281 | kernel/blk_drv/scsi/scsi_debug.c | block += bufflen >> 9; |
block | 300 | kernel/blk_drv/scsi/scsi_debug.c | block = cmd[5] + (cmd[4] << 8) + (cmd[3] << 16) + (cmd[2] << 24); |
block | 302 | kernel/blk_drv/scsi/scsi_debug.c | block = cmd[3] + (cmd[2] << 8) + ((cmd[1] & 0x1f) << 16); |
block | 312 | kernel/blk_drv/scsi/scsi_debug.c | if (block != *((unsigned long *) (buff+60))) { |
block | 313 | kernel/blk_drv/scsi/scsi_debug.c | printk("%x %x :",block, *((unsigned long *) (buff+60))); |
block | 391 | kernel/blk_drv/scsi/sd.c | int dev, block, this_count; |
block | 403 | kernel/blk_drv/scsi/sd.c | block = SCpnt->request.sector; |
block | 407 | kernel/blk_drv/scsi/sd.c | printk("Doing sd request, dev = %d, block = %d\n", dev, block); |
block | 410 | kernel/blk_drv/scsi/sd.c | if (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects) |
block | 416 | kernel/blk_drv/scsi/sd.c | block += sd[dev].start_sect; |
block | 430 | kernel/blk_drv/scsi/sd.c | printk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block); |
block | 575 | kernel/blk_drv/scsi/sd.c | if(block & 1) panic("sd.c:Bad block number requested"); |
block | 577 | kernel/blk_drv/scsi/sd.c | block = block >> 1; |
block | 582 | kernel/blk_drv/scsi/sd.c | block = block << 1; |
block | 586 | kernel/blk_drv/scsi/sd.c | if (((this_count > 0xff) || (block > 0x1fffff)) && rscsi_disks[dev].ten) |
block | 592 | kernel/blk_drv/scsi/sd.c | cmd[2] = (unsigned char) (block >> 24) & 0xff; |
block | 593 | kernel/blk_drv/scsi/sd.c | cmd[3] = (unsigned char) (block >> 16) & 0xff; |
block | 594 | kernel/blk_drv/scsi/sd.c | cmd[4] = (unsigned char) (block >> 8) & 0xff; |
block | 595 | kernel/blk_drv/scsi/sd.c | cmd[5] = (unsigned char) block & 0xff; |
block | 605 | kernel/blk_drv/scsi/sd.c | cmd[1] |= (unsigned char) ((block >> 16) & 0x1f); |
block | 606 | kernel/blk_drv/scsi/sd.c | cmd[2] = (unsigned char) ((block >> 8) & 0xff); |
block | 607 | kernel/blk_drv/scsi/sd.c | cmd[3] = (unsigned char) block & 0xff; |
block | 350 | kernel/blk_drv/scsi/sr.c | unsigned int dev, block, realcount; |
block | 363 | kernel/blk_drv/scsi/sr.c | block = SCpnt->request.sector; |
block | 544 | kernel/blk_drv/scsi/sr.c | start = block % 4; |
block | 566 | kernel/blk_drv/scsi/sr.c | block = block >> 2; /* These are the sectors that the cdrom uses */ |
block | 568 | kernel/blk_drv/scsi/sr.c | block = block & 0xfffffffc; |
block | 574 | kernel/blk_drv/scsi/sr.c | if (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) |
block | 583 | kernel/blk_drv/scsi/sr.c | cmd[2] = (unsigned char) (block >> 24) & 0xff; |
block | 584 | kernel/blk_drv/scsi/sr.c | cmd[3] = (unsigned char) (block >> 16) & 0xff; |
block | 585 | kernel/blk_drv/scsi/sr.c | cmd[4] = (unsigned char) (block >> 8) & 0xff; |
block | 586 | kernel/blk_drv/scsi/sr.c | cmd[5] = (unsigned char) block & 0xff; |
block | 599 | kernel/blk_drv/scsi/sr.c | cmd[1] |= (unsigned char) ((block >> 16) & 0x1f); |
block | 600 | kernel/blk_drv/scsi/sr.c | cmd[2] = (unsigned char) ((block >> 8) & 0xff); |
block | 601 | kernel/blk_drv/scsi/sr.c | cmd[3] = (unsigned char) block & 0xff; |
block | 607 | kernel/blk_drv/scsi/sr.c | printk("ReadCD: %d %d %d %d\n",block, realcount, buffer, this_count); |
block | 172 | kernel/blk_drv/xd.c | u_int block,count,retry; |
block | 180 | kernel/blk_drv/xd.c | block = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect; |
block | 186 | kernel/blk_drv/xd.c | code = xd_readwrite(CURRENT->cmd,CURRENT_DEV,CURRENT->buffer,block,count); |
block | 266 | kernel/blk_drv/xd.c | static int xd_readwrite (u_char operation,u_char drive,char *buffer,u_int block,u_int count) |
block | 273 | kernel/blk_drv/xd.c | printk("xd_readwrite: operation = %s, drive = %d, buffer = 0x%X, block = %d, count = %d\n",operation == READ ? "read" : "write",drive,buffer,block,count); |
block | 280 | kernel/blk_drv/xd.c | track = block / xd_info[drive].sectors; |
block | 283 | kernel/blk_drv/xd.c | sector = block % xd_info[drive].sectors; |
block | 306 | kernel/blk_drv/xd.c | count -= temp, buffer += temp * 0x200, block += temp; |
block | 834 | mm/memory.c | unsigned int block,i, j; |
block | 854 | mm/memory.c | block = 0xffffffff; |
block | 857 | mm/memory.c | block = 1 + address / BLOCK_SIZE; |
block | 894 | mm/memory.c | if (block != 0xffffffff) { |
block | 895 | mm/memory.c | for (i=0, j=0; i< PAGE_SIZE ; j++, block++,i +=inode->i_sb->s_blocksize) |
block | 896 | mm/memory.c | nr[j] = bmap(inode,block); |
block | 1173 | mm/memory.c | unsigned int block; |
block | 1182 | mm/memory.c | block = address - area->vm_start + area->vm_offset; |
block | 1183 | mm/memory.c | block >>= inode->i_sb->s_blocksize_bits; |
block | 1197 | mm/memory.c | for (i=0, j=0; i< PAGE_SIZE ; j++, block++, i += inode->i_sb->s_blocksize) |
block | 1198 | mm/memory.c | nr[j] = bmap(inode,block); |
block | 84 | mm/swap.c | unsigned int block; |
block | 87 | mm/swap.c | block = offset << (12 - p->swap_file->i_sb->s_blocksize_bits); |
block | 90 | mm/swap.c | if (!(zones[i] = bmap(p->swap_file,block++))) { |