taglinefilesource code
BLOCK_SIZE30drivers/block/blk.h#define SECTOR_MASK ((BLOCK_SIZE >> 9) - 1)
BLOCK_SIZE35drivers/block/blk.h((BLOCK_SIZE >> 9)  -  1))
BLOCK_SIZE298drivers/block/blk.hreq->sector += (BLOCK_SIZE / 512);
BLOCK_SIZE470drivers/block/ll_rw_blk.ccorrect_size = BLOCK_SIZE;
BLOCK_SIZE129drivers/block/ramdisk.cbh = breada(ROOT_DEV,block+1,BLOCK_SIZE, 0,  PAGE_SIZE);
BLOCK_SIZE177drivers/block/ramdisk.cbh = breada(ROOT_DEV, block, BLOCK_SIZE, 0,  PAGE_SIZE);
BLOCK_SIZE179drivers/block/ramdisk.cbh = bread(ROOT_DEV, block, BLOCK_SIZE);
BLOCK_SIZE185drivers/block/ramdisk.c(void) memcpy(cp, bh->b_data, BLOCK_SIZE);
BLOCK_SIZE188drivers/block/ramdisk.ccp += BLOCK_SIZE;
BLOCK_SIZE43fs/block_dev.cblocksize = BLOCK_SIZE;
BLOCK_SIZE180fs/block_dev.cblocksize = BLOCK_SIZE;
BLOCK_SIZE464fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
BLOCK_SIZE1618fs/buffer.cint isize = BUFSIZE_INDEX(BLOCK_SIZE);
BLOCK_SIZE1641fs/buffer.cgrow_buffers(GFP_KERNEL, BLOCK_SIZE);
BLOCK_SIZE755fs/exec.cif (N_MAGIC(ex) == ZMAGIC && fd_offset != BLOCK_SIZE) {
BLOCK_SIZE102fs/ext/file.coffset &= BLOCK_SIZE-1;
BLOCK_SIZE103fs/ext/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
BLOCK_SIZE104fs/ext/file.cblocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
BLOCK_SIZE107fs/ext/file.cif(blocks < read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9))
BLOCK_SIZE108fs/ext/file.cblocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
BLOCK_SIZE160fs/ext/file.cif (left < BLOCK_SIZE - offset)
BLOCK_SIZE163fs/ext/file.cchars = BLOCK_SIZE - offset;
BLOCK_SIZE222fs/ext/file.cbh = ext_getblk(inode,pos/BLOCK_SIZE,1);
BLOCK_SIZE228fs/ext/file.cc = BLOCK_SIZE - (pos % BLOCK_SIZE);
BLOCK_SIZE231fs/ext/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
BLOCK_SIZE241fs/ext/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
BLOCK_SIZE129fs/ext/freelists.cmemset(bh->b_data, 0, BLOCK_SIZE);
BLOCK_SIZE27fs/ext/fsync.c#define blocksize BLOCK_SIZE
BLOCK_SIZE65fs/ext/inode.cset_blocksize(dev, BLOCK_SIZE);
BLOCK_SIZE66fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
BLOCK_SIZE98fs/ext/inode.cs->u.ext_sb.s_firstfreeblocknumber, BLOCK_SIZE))) {
BLOCK_SIZE108fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
BLOCK_SIZE133fs/ext/inode.cif (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) {
BLOCK_SIZE196fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
BLOCK_SIZE203fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8);
BLOCK_SIZE206fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
BLOCK_SIZE212fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16);
BLOCK_SIZE215fs/ext/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255);
BLOCK_SIZE218fs/ext/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255);
BLOCK_SIZE231fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE242fs/ext/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE275fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE292fs/ext/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE358fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
BLOCK_SIZE396fs/ext/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE)))
BLOCK_SIZE107fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data) {
BLOCK_SIZE119fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
BLOCK_SIZE123fs/ext/namei.cde = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE);
BLOCK_SIZE124fs/ext/namei.coffset = ((offset / BLOCK_SIZE) + 1) * BLOCK_SIZE;
BLOCK_SIZE133fs/ext/namei.c((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data)
BLOCK_SIZE215fs/ext/namei.cif ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) {
BLOCK_SIZE228fs/ext/namei.cif (offset % BLOCK_SIZE == 0  ||
BLOCK_SIZE229fs/ext/namei.c(BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) {
BLOCK_SIZE230fs/ext/namei.cif ((offset % BLOCK_SIZE) != 0) {
BLOCK_SIZE235fs/ext/namei.cde->rec_len = BLOCK_SIZE
BLOCK_SIZE236fs/ext/namei.c- (offset & (BLOCK_SIZE - 1));
BLOCK_SIZE267fs/ext/namei.c(((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) {
BLOCK_SIZE487fs/ext/namei.cif ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) {
BLOCK_SIZE491fs/ext/namei.coffset += BLOCK_SIZE;
BLOCK_SIZE45fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
BLOCK_SIZE75fs/ext/truncate.cind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE94fs/ext/truncate.cbh = getblk(inode->i_dev,tmp,BLOCK_SIZE);
BLOCK_SIZE137fs/ext/truncate.cdind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE187fs/ext/truncate.ctind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE136fs/ext2/super.cstruct ext2_old_group_desc old_group_desc [BLOCK_SIZE / sizeof (struct ext2_old_group_desc)];
BLOCK_SIZE143fs/ext2/super.cbh2 = bread (sb->s_dev, 2, BLOCK_SIZE);
BLOCK_SIZE148fs/ext2/super.cmemcpy (old_group_desc, bh2->b_data, BLOCK_SIZE);
BLOCK_SIZE153fs/ext2/super.cmemset (bh2->b_data, 0, BLOCK_SIZE);
BLOCK_SIZE415fs/ext2/super.cset_blocksize (dev, BLOCK_SIZE);
BLOCK_SIZE416fs/ext2/super.cif (!(bh = bread (dev, sb_block, BLOCK_SIZE))) {
BLOCK_SIZE444fs/ext2/super.cif (sb->s_blocksize != BLOCK_SIZE && 
BLOCK_SIZE451fs/ext2/super.clogic_sb_block = (sb_block*BLOCK_SIZE) / sb->s_blocksize;
BLOCK_SIZE452fs/ext2/super.coffset = (sb_block*BLOCK_SIZE) % sb->s_blocksize;
BLOCK_SIZE158fs/isofs/file.cra_blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
BLOCK_SIZE173fs/isofs/file.cmax_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE;
BLOCK_SIZE32fs/minix/bitmap.cif (numbits >= (8*BLOCK_SIZE)) { 
BLOCK_SIZE33fs/minix/bitmap.cend = BLOCK_SIZE;
BLOCK_SIZE34fs/minix/bitmap.cnumbits -= 8*BLOCK_SIZE;
BLOCK_SIZE64fs/minix/bitmap.cbh = get_hash_table(sb->s_dev,block,BLOCK_SIZE);
BLOCK_SIZE108fs/minix/bitmap.cif (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) {
BLOCK_SIZE112fs/minix/bitmap.cmemset(bh->b_data, 0, BLOCK_SIZE);
BLOCK_SIZE100fs/minix/file.coffset &= BLOCK_SIZE-1;
BLOCK_SIZE101fs/minix/file.csize = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS;
BLOCK_SIZE102fs/minix/file.cblocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS;
BLOCK_SIZE105fs/minix/file.cif(blocks < read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9))
BLOCK_SIZE106fs/minix/file.cblocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9);
BLOCK_SIZE158fs/minix/file.cif (left < BLOCK_SIZE - offset)
BLOCK_SIZE161fs/minix/file.cchars = BLOCK_SIZE - offset;
BLOCK_SIZE215fs/minix/file.cbh = minix_getblk(inode,pos/BLOCK_SIZE,1);
BLOCK_SIZE221fs/minix/file.cc = BLOCK_SIZE - (pos % BLOCK_SIZE);
BLOCK_SIZE224fs/minix/file.cif (c != BLOCK_SIZE && !bh->b_uptodate) {
BLOCK_SIZE234fs/minix/file.cp = (pos % BLOCK_SIZE) + bh->b_data;
BLOCK_SIZE28fs/minix/fsync.c#define blocksize BLOCK_SIZE
BLOCK_SIZE135fs/minix/inode.cset_blocksize(dev, BLOCK_SIZE);
BLOCK_SIZE136fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
BLOCK_SIZE178fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
BLOCK_SIZE183fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
BLOCK_SIZE277fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block);
BLOCK_SIZE283fs/minix/inode.ci = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9);
BLOCK_SIZE286fs/minix/inode.creturn block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511);
BLOCK_SIZE299fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE310fs/minix/inode.cresult = getblk(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE343fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE360fs/minix/inode.cresult = getblk(bh->b_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE429fs/minix/inode.cif (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
BLOCK_SIZE477fs/minix/inode.cif (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) {
BLOCK_SIZE88fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < dir->i_size) {
BLOCK_SIZE404fs/minix/namei.cwhile (block*BLOCK_SIZE+offset < inode->i_size) {
BLOCK_SIZE43fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
BLOCK_SIZE73fs/minix/truncate.cind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE92fs/minix/truncate.cbh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE);
BLOCK_SIZE134fs/minix/truncate.cdind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE);
BLOCK_SIZE63fs/msdos/inode.cset_blocksize (sb->s_dev,BLOCK_SIZE);
BLOCK_SIZE74fs/stat.c#define I_B   (BLOCK_SIZE / sizeof(unsigned short))
BLOCK_SIZE77fs/stat.cblocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
BLOCK_SIZE88fs/stat.ctmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
BLOCK_SIZE89fs/stat.ctmp.st_blksize = BLOCK_SIZE;
BLOCK_SIZE145fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
BLOCK_SIZE151fs/sysv/inode.csbd2 = (struct xenix_super_block *) (bh2->b_data - BLOCK_SIZE/2);
BLOCK_SIZE186fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
BLOCK_SIZE203fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
BLOCK_SIZE204fs/sysv/inode.csbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2);
BLOCK_SIZE244fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
BLOCK_SIZE261fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE)
BLOCK_SIZE262fs/sysv/inode.csbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2);
BLOCK_SIZE302fs/sysv/inode.csbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2);
BLOCK_SIZE363fs/sysv/inode.cset_blocksize(dev,BLOCK_SIZE);
BLOCK_SIZE366fs/sysv/inode.cif ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) {
BLOCK_SIZE371fs/sysv/inode.cif ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) {
BLOCK_SIZE387fs/sysv/inode.cif ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) {
BLOCK_SIZE409fs/sysv/inode.cif (sb->sv_block_size == BLOCK_SIZE) {
BLOCK_SIZE471fs/sysv/inode.cset_blocksize(sb->s_dev,BLOCK_SIZE);
BLOCK_SIZE532fs/sysv/inode.cif (sb->s_blocksize != BLOCK_SIZE)
BLOCK_SIZE533fs/sysv/inode.cset_blocksize(sb->s_dev,BLOCK_SIZE);
BLOCK_SIZE79fs/xiafs/inode.cset_blocksize(dev, BLOCK_SIZE);
BLOCK_SIZE81fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
BLOCK_SIZE102fs/xiafs/inode.cif (s->s_blocksize != BLOCK_SIZE && 
BLOCK_SIZE112fs/xiafs/inode.csp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
BLOCK_SIZE617fs/xiafs/namei.cfor (i = 0; i < BLOCK_SIZE-1 && (c=*symname++); i++)
BLOCK_SIZE61fs/xiafs/symlink.cif (buflen > BLOCK_SIZE)
BLOCK_SIZE62fs/xiafs/symlink.cbuflen = BLOCK_SIZE;
BLOCK_SIZE12fs/xiafs/xiafs_mac.h#define XIAFS_ZSIZE(sp)    (BLOCK_SIZE << XIAFS_ZSHIFT(sp))
BLOCK_SIZE14fs/xiafs/xiafs_mac.h#define XIAFS_ADDRS_PER_Z(sp)     (BLOCK_SIZE >> (2 - XIAFS_ZSHIFT(sp)))
BLOCK_SIZE16fs/xiafs/xiafs_mac.h#define XIAFS_BITS_PER_Z(sp)  (BLOCK_SIZE  << (3 + XIAFS_ZSHIFT(sp)))
BLOCK_SIZE13include/linux/ext_fs.h#define EXT_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct ext_inode)))
BLOCK_SIZE28include/linux/minix_fs.h#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
BLOCK_SIZE19include/linux/xia_fs.h#define _XIAFS_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof(struct xiafs_inode)))