tag | line | file | source code |
BLOCK_SIZE | 69 | drivers/block/blk.h | ((BLOCK_SIZE >> 9) - 1)) |
BLOCK_SIZE | 257 | drivers/block/blk.h | req->sector += (BLOCK_SIZE / 512); |
BLOCK_SIZE | 129 | drivers/block/floppy.c | #define LAST_DMA_ADDR (0x100000 - BLOCK_SIZE) |
BLOCK_SIZE | 268 | drivers/block/floppy.c | extern char tmp_floppy_area[BLOCK_SIZE]; |
BLOCK_SIZE | 434 | drivers/block/floppy.c | :"c" (BLOCK_SIZE/4),"S" ((long)(from)),"D" ((long)(to)) \ |
BLOCK_SIZE | 370 | drivers/block/ll_rw_blk.c | correct_size = BLOCK_SIZE; |
BLOCK_SIZE | 159 | drivers/block/ramdisk.c | bh = bread(ROOT_DEV, block, BLOCK_SIZE); |
BLOCK_SIZE | 165 | drivers/block/ramdisk.c | (void) memcpy(cp, bh->b_data, BLOCK_SIZE); |
BLOCK_SIZE | 168 | drivers/block/ramdisk.c | cp += BLOCK_SIZE; |
BLOCK_SIZE | 30 | fs/block_dev.c | blocksize = BLOCK_SIZE; |
BLOCK_SIZE | 96 | fs/block_dev.c | blocksize = BLOCK_SIZE; |
BLOCK_SIZE | 408 | fs/buffer.c | if (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) { |
BLOCK_SIZE | 570 | fs/buffer.c | blocksize = BLOCK_SIZE; |
BLOCK_SIZE | 1021 | fs/buffer.c | grow_buffers(GFP_KERNEL, BLOCK_SIZE); |
BLOCK_SIZE | 783 | fs/exec.c | if (N_TXTOFF(ex) != BLOCK_SIZE && N_MAGIC(ex) == ZMAGIC) { |
BLOCK_SIZE | 102 | fs/ext/file.c | offset &= BLOCK_SIZE-1; |
BLOCK_SIZE | 103 | fs/ext/file.c | size = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS; |
BLOCK_SIZE | 104 | fs/ext/file.c | blocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS; |
BLOCK_SIZE | 107 | fs/ext/file.c | blocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 159 | fs/ext/file.c | if (left < BLOCK_SIZE - offset) |
BLOCK_SIZE | 162 | fs/ext/file.c | chars = BLOCK_SIZE - offset; |
BLOCK_SIZE | 221 | fs/ext/file.c | bh = ext_getblk(inode,pos/BLOCK_SIZE,1); |
BLOCK_SIZE | 227 | fs/ext/file.c | c = BLOCK_SIZE - (pos % BLOCK_SIZE); |
BLOCK_SIZE | 230 | fs/ext/file.c | if (c != BLOCK_SIZE && !bh->b_uptodate) { |
BLOCK_SIZE | 240 | fs/ext/file.c | p = (pos % BLOCK_SIZE) + bh->b_data; |
BLOCK_SIZE | 45 | fs/ext/freelists.c | :"a" (0),"c" (BLOCK_SIZE/4),"D" ((long) (addr)):"cx","di") |
BLOCK_SIZE | 27 | fs/ext/fsync.c | #define blocksize BLOCK_SIZE |
BLOCK_SIZE | 65 | fs/ext/inode.c | set_blocksize(dev, BLOCK_SIZE); |
BLOCK_SIZE | 66 | fs/ext/inode.c | if (!(bh = bread(dev, 1, BLOCK_SIZE))) { |
BLOCK_SIZE | 98 | fs/ext/inode.c | s->u.ext_sb.s_firstfreeblocknumber, BLOCK_SIZE))) { |
BLOCK_SIZE | 108 | fs/ext/inode.c | if (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) { |
BLOCK_SIZE | 133 | fs/ext/inode.c | if (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) { |
BLOCK_SIZE | 196 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
BLOCK_SIZE | 203 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8); |
BLOCK_SIZE | 206 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
BLOCK_SIZE | 212 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16); |
BLOCK_SIZE | 215 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255); |
BLOCK_SIZE | 218 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
BLOCK_SIZE | 231 | fs/ext/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 242 | fs/ext/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 275 | fs/ext/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 292 | fs/ext/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 358 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
BLOCK_SIZE | 396 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
BLOCK_SIZE | 115 | fs/ext/namei.c | if ((char *)de >= BLOCK_SIZE+bh->b_data) { |
BLOCK_SIZE | 127 | fs/ext/namei.c | (((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) { |
BLOCK_SIZE | 131 | fs/ext/namei.c | de = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE); |
BLOCK_SIZE | 132 | fs/ext/namei.c | offset = ((offset / BLOCK_SIZE) + 1) * BLOCK_SIZE; |
BLOCK_SIZE | 141 | fs/ext/namei.c | ((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data) |
BLOCK_SIZE | 223 | fs/ext/namei.c | if ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) { |
BLOCK_SIZE | 236 | fs/ext/namei.c | if (offset % BLOCK_SIZE == 0 || |
BLOCK_SIZE | 237 | fs/ext/namei.c | (BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) { |
BLOCK_SIZE | 238 | fs/ext/namei.c | if ((offset % BLOCK_SIZE) != 0) { |
BLOCK_SIZE | 243 | fs/ext/namei.c | de->rec_len = BLOCK_SIZE |
BLOCK_SIZE | 244 | fs/ext/namei.c | - (offset & (BLOCK_SIZE - 1)); |
BLOCK_SIZE | 275 | fs/ext/namei.c | (((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) { |
BLOCK_SIZE | 494 | fs/ext/namei.c | if ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) { |
BLOCK_SIZE | 498 | fs/ext/namei.c | offset += BLOCK_SIZE; |
BLOCK_SIZE | 45 | fs/ext/truncate.c | bh = getblk(inode->i_dev,tmp,BLOCK_SIZE); |
BLOCK_SIZE | 75 | fs/ext/truncate.c | ind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 94 | fs/ext/truncate.c | bh = getblk(inode->i_dev,tmp,BLOCK_SIZE); |
BLOCK_SIZE | 137 | fs/ext/truncate.c | dind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 187 | fs/ext/truncate.c | tind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 136 | fs/ext2/super.c | struct ext2_old_group_desc old_group_desc [BLOCK_SIZE / sizeof (struct ext2_old_group_desc)]; |
BLOCK_SIZE | 143 | fs/ext2/super.c | bh2 = bread (sb->s_dev, 2, BLOCK_SIZE); |
BLOCK_SIZE | 148 | fs/ext2/super.c | memcpy (old_group_desc, bh2->b_data, BLOCK_SIZE); |
BLOCK_SIZE | 153 | fs/ext2/super.c | memset (bh2->b_data, 0, BLOCK_SIZE); |
BLOCK_SIZE | 377 | fs/ext2/super.c | set_blocksize (dev, BLOCK_SIZE); |
BLOCK_SIZE | 378 | fs/ext2/super.c | if (!(bh = bread (dev, sb_block, BLOCK_SIZE))) { |
BLOCK_SIZE | 406 | fs/ext2/super.c | if (sb->s_blocksize != BLOCK_SIZE && |
BLOCK_SIZE | 148 | fs/isofs/file.c | ra_blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 149 | fs/isofs/file.c | max_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE; |
BLOCK_SIZE | 22 | fs/minix/bitmap.c | :"a" (0),"c" (BLOCK_SIZE/4),"D" ((long) (addr)):"cx","di") |
BLOCK_SIZE | 50 | fs/minix/bitmap.c | if (numbits >= (8*BLOCK_SIZE)) { |
BLOCK_SIZE | 51 | fs/minix/bitmap.c | end = BLOCK_SIZE; |
BLOCK_SIZE | 52 | fs/minix/bitmap.c | numbits -= 8*BLOCK_SIZE; |
BLOCK_SIZE | 82 | fs/minix/bitmap.c | bh = get_hash_table(sb->s_dev,block,BLOCK_SIZE); |
BLOCK_SIZE | 126 | fs/minix/bitmap.c | if (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) { |
BLOCK_SIZE | 96 | fs/minix/file.c | offset &= BLOCK_SIZE-1; |
BLOCK_SIZE | 97 | fs/minix/file.c | size = (size + (BLOCK_SIZE-1)) >> BLOCK_SIZE_BITS; |
BLOCK_SIZE | 98 | fs/minix/file.c | blocks = (left + offset + BLOCK_SIZE - 1) >> BLOCK_SIZE_BITS; |
BLOCK_SIZE | 101 | fs/minix/file.c | blocks += read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 153 | fs/minix/file.c | if (left < BLOCK_SIZE - offset) |
BLOCK_SIZE | 156 | fs/minix/file.c | chars = BLOCK_SIZE - offset; |
BLOCK_SIZE | 213 | fs/minix/file.c | bh = minix_getblk(inode,pos/BLOCK_SIZE,1); |
BLOCK_SIZE | 219 | fs/minix/file.c | c = BLOCK_SIZE - (pos % BLOCK_SIZE); |
BLOCK_SIZE | 222 | fs/minix/file.c | if (c != BLOCK_SIZE && !bh->b_uptodate) { |
BLOCK_SIZE | 232 | fs/minix/file.c | p = (pos % BLOCK_SIZE) + bh->b_data; |
BLOCK_SIZE | 24 | fs/minix/fsync.c | #define blocksize BLOCK_SIZE |
BLOCK_SIZE | 125 | fs/minix/inode.c | if (!(bh = bread(dev,1,BLOCK_SIZE))) { |
BLOCK_SIZE | 165 | fs/minix/inode.c | if ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
BLOCK_SIZE | 170 | fs/minix/inode.c | if ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
BLOCK_SIZE | 262 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
BLOCK_SIZE | 268 | fs/minix/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9); |
BLOCK_SIZE | 271 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511); |
BLOCK_SIZE | 284 | fs/minix/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 295 | fs/minix/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 328 | fs/minix/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 345 | fs/minix/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 414 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) { |
BLOCK_SIZE | 462 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) { |
BLOCK_SIZE | 88 | fs/minix/namei.c | while (block*BLOCK_SIZE+offset < dir->i_size) { |
BLOCK_SIZE | 402 | fs/minix/namei.c | while (block*BLOCK_SIZE+offset < inode->i_size) { |
BLOCK_SIZE | 39 | fs/minix/truncate.c | bh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE); |
BLOCK_SIZE | 69 | fs/minix/truncate.c | ind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 88 | fs/minix/truncate.c | bh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE); |
BLOCK_SIZE | 130 | fs/minix/truncate.c | dind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 163 | fs/msdos/inode.c | bh = bread(s->s_dev, 0, BLOCK_SIZE); |
BLOCK_SIZE | 335 | fs/msdos/inode.c | BLOCK_SIZE))) { |
BLOCK_SIZE | 398 | fs/msdos/inode.c | BLOCK_SIZE))) { |
BLOCK_SIZE | 173 | fs/msdos/misc.c | BLOCK_SIZE))) |
BLOCK_SIZE | 176 | fs/msdos/misc.c | memset(bh->b_data,0,BLOCK_SIZE); |
BLOCK_SIZE | 66 | fs/stat.c | #define I_B (BLOCK_SIZE / sizeof(unsigned short)) |
BLOCK_SIZE | 69 | fs/stat.c | blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE; |
BLOCK_SIZE | 80 | fs/stat.c | tmp.st_blocks = (BLOCK_SIZE / 512) * blocks; |
BLOCK_SIZE | 81 | fs/stat.c | tmp.st_blksize = BLOCK_SIZE; |
BLOCK_SIZE | 69 | fs/sysv/balloc.c | bh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 71 | fs/sysv/balloc.c | bh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 109 | fs/sysv/balloc.c | bh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 111 | fs/sysv/balloc.c | bh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 127 | fs/sysv/balloc.c | bh = get_hash_table(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 216 | fs/sysv/balloc.c | bh = bread(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 218 | fs/sysv/balloc.c | bh = getblk(sb->s_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 283 | fs/sysv/file.c | if (c != BLOCK_SIZE && !bh->b_uptodate) { |
BLOCK_SIZE | 41 | fs/sysv/fsync.c | bh = get_hash_table(inode->i_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 160 | fs/sysv/inode.c | sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 198 | fs/sysv/inode.c | sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 236 | fs/sysv/inode.c | sbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 282 | fs/sysv/inode.c | sb->s_blocksize = BLOCK_SIZE; /* anything else not supported by the block device drivers */ |
BLOCK_SIZE | 286 | fs/sysv/inode.c | if ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 291 | fs/sysv/inode.c | if ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 307 | fs/sysv/inode.c | if ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 387 | fs/sysv/inode.c | #define IND_PER_BLOCK (BLOCK_SIZE / sizeof(sysv_zone_t)) |
BLOCK_SIZE | 428 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 436 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 440 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 448 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 452 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 456 | fs/sysv/inode.c | bh = bread(inode->i_dev,i,BLOCK_SIZE); |
BLOCK_SIZE | 484 | fs/sysv/inode.c | result = getblk(inode->i_dev, (tmp >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 497 | fs/sysv/inode.c | result = getblk(inode->i_dev, (tmp >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 535 | fs/sysv/inode.c | result = getblk(bh->b_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 553 | fs/sysv/inode.c | result = getblk(bh->b_dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE); |
BLOCK_SIZE | 266 | fs/sysv/truncate.c | for (i = ((unsigned long) inode->i_size + BLOCK_SIZE-1) / BLOCK_SIZE; i < 10; i++) { |
BLOCK_SIZE | 271 | fs/sysv/truncate.c | bh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE); |
BLOCK_SIZE | 272 | fs/sysv/truncate.c | if (i*BLOCK_SIZE < inode->i_size) { |
BLOCK_SIZE | 289 | fs/sysv/truncate.c | #define IND_PER_BLOCK (BLOCK_SIZE / sizeof(sysv_zone_t)) |
BLOCK_SIZE | 308 | fs/sysv/truncate.c | indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE); |
BLOCK_SIZE | 322 | fs/sysv/truncate.c | i = (inode->i_size - offset + BLOCK_SIZE-1) / BLOCK_SIZE; |
BLOCK_SIZE | 330 | fs/sysv/truncate.c | bh = get_hash_table(inode->i_dev,block+sb->sv_block_base,BLOCK_SIZE); |
BLOCK_SIZE | 331 | fs/sysv/truncate.c | if (i*BLOCK_SIZE + offset < inode->i_size) { |
BLOCK_SIZE | 376 | fs/sysv/truncate.c | indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE); |
BLOCK_SIZE | 389 | fs/sysv/truncate.c | i = (inode->i_size - offset + IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*BLOCK_SIZE); |
BLOCK_SIZE | 430 | fs/sysv/truncate.c | indbh = bread(inode->i_dev,indblock+sb->sv_block_base,BLOCK_SIZE); |
BLOCK_SIZE | 443 | fs/sysv/truncate.c | i = (inode->i_size - offset + IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE-1) / (IND_PER_BLOCK*IND_PER_BLOCK*BLOCK_SIZE); |
BLOCK_SIZE | 471 | fs/sysv/truncate.c | | trunc_indirect(inode,10*BLOCK_SIZE,&inode->u.sysv_i.i_data[10],0,&inode->i_dirt) |
BLOCK_SIZE | 472 | fs/sysv/truncate.c | | trunc_dindirect(inode,(10+IND_PER_BLOCK)*BLOCK_SIZE,&inode->u.sysv_i.i_data[11],0,&inode->i_dirt) |
BLOCK_SIZE | 473 | fs/sysv/truncate.c | | trunc_tindirect(inode,(10+IND_PER_BLOCK+IND_PER_BLOCK*IND_PER_BLOCK)*BLOCK_SIZE,&inode->u.sysv_i.i_data[12],0,&inode->i_dirt); |
BLOCK_SIZE | 69 | fs/xiafs/inode.c | set_blocksize(dev, BLOCK_SIZE); |
BLOCK_SIZE | 71 | fs/xiafs/inode.c | if (!(bh = bread(dev, 0, BLOCK_SIZE))) { |
BLOCK_SIZE | 90 | fs/xiafs/inode.c | if (s->s_blocksize != BLOCK_SIZE && |
BLOCK_SIZE | 97 | fs/xiafs/inode.c | sp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ; |
BLOCK_SIZE | 611 | fs/xiafs/namei.c | for (i = 0; i < BLOCK_SIZE-1 && (c=*symname++); i++) |
BLOCK_SIZE | 57 | fs/xiafs/symlink.c | if (buflen > BLOCK_SIZE) |
BLOCK_SIZE | 58 | fs/xiafs/symlink.c | buflen = BLOCK_SIZE; |
BLOCK_SIZE | 12 | fs/xiafs/xiafs_mac.h | #define XIAFS_ZSIZE(sp) (BLOCK_SIZE << XIAFS_ZSHIFT(sp)) |
BLOCK_SIZE | 14 | fs/xiafs/xiafs_mac.h | #define XIAFS_ADDRS_PER_Z(sp) (BLOCK_SIZE >> (2 - XIAFS_ZSHIFT(sp))) |
BLOCK_SIZE | 16 | fs/xiafs/xiafs_mac.h | #define XIAFS_BITS_PER_Z(sp) (BLOCK_SIZE << (3 + XIAFS_ZSHIFT(sp))) |
BLOCK_SIZE | 13 | include/linux/ext_fs.h | #define EXT_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct ext_inode))) |
BLOCK_SIZE | 28 | include/linux/minix_fs.h | #define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode))) |
BLOCK_SIZE | 356 | include/linux/sysv_fs.h | if (!(bh = bread (dev, (block >> sb->sv_block_size_ratio_bits) + sb->sv_block_base, BLOCK_SIZE))) |
BLOCK_SIZE | 19 | include/linux/xia_fs.h | #define _XIAFS_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof(struct xiafs_inode))) |