tag | line | file | source code |
BLOCK_SIZE | 539 | drivers/block/ide.c | *bs++ = BLOCK_SIZE; |
BLOCK_SIZE | 493 | drivers/block/ll_rw_blk.c | correct_size = BLOCK_SIZE; |
BLOCK_SIZE | 129 | drivers/block/ramdisk.c | bh = breada(ROOT_DEV,block+1,BLOCK_SIZE, 0, PAGE_SIZE); |
BLOCK_SIZE | 175 | drivers/block/ramdisk.c | bh = breada(ROOT_DEV, block, BLOCK_SIZE, 0, PAGE_SIZE); |
BLOCK_SIZE | 177 | drivers/block/ramdisk.c | bh = bread(ROOT_DEV, block, BLOCK_SIZE); |
BLOCK_SIZE | 183 | drivers/block/ramdisk.c | (void) memcpy(cp, bh->b_data, BLOCK_SIZE); |
BLOCK_SIZE | 186 | drivers/block/ramdisk.c | cp += BLOCK_SIZE; |
BLOCK_SIZE | 43 | fs/block_dev.c | blocksize = BLOCK_SIZE; |
BLOCK_SIZE | 180 | fs/block_dev.c | blocksize = BLOCK_SIZE; |
BLOCK_SIZE | 485 | fs/buffer.c | if (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) { |
BLOCK_SIZE | 1746 | fs/buffer.c | int isize = BUFSIZE_INDEX(BLOCK_SIZE); |
BLOCK_SIZE | 1770 | fs/buffer.c | grow_buffers(GFP_KERNEL, BLOCK_SIZE); |
BLOCK_SIZE | 835 | fs/exec.c | if (N_MAGIC(ex) == ZMAGIC && fd_offset != BLOCK_SIZE) { |
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 | if(blocks < read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9)) |
BLOCK_SIZE | 108 | fs/ext/file.c | blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 160 | fs/ext/file.c | if (left < BLOCK_SIZE - offset) |
BLOCK_SIZE | 163 | fs/ext/file.c | chars = BLOCK_SIZE - offset; |
BLOCK_SIZE | 222 | fs/ext/file.c | bh = ext_getblk(inode,pos/BLOCK_SIZE,1); |
BLOCK_SIZE | 228 | fs/ext/file.c | c = BLOCK_SIZE - (pos % BLOCK_SIZE); |
BLOCK_SIZE | 231 | fs/ext/file.c | if (c != BLOCK_SIZE && !buffer_uptodate(bh)) { |
BLOCK_SIZE | 241 | fs/ext/file.c | p = (pos % BLOCK_SIZE) + bh->b_data; |
BLOCK_SIZE | 129 | fs/ext/freelists.c | memset(bh->b_data, 0, BLOCK_SIZE); |
BLOCK_SIZE | 27 | fs/ext/fsync.c | #define blocksize BLOCK_SIZE |
BLOCK_SIZE | 70 | fs/ext/inode.c | set_blocksize(dev, BLOCK_SIZE); |
BLOCK_SIZE | 71 | fs/ext/inode.c | if (!(bh = bread(dev, 1, BLOCK_SIZE))) { |
BLOCK_SIZE | 105 | fs/ext/inode.c | s->u.ext_sb.s_firstfreeblocknumber, BLOCK_SIZE))) { |
BLOCK_SIZE | 116 | fs/ext/inode.c | if (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) { |
BLOCK_SIZE | 143 | fs/ext/inode.c | if (!(bh = bread(sb->s_dev, 1, BLOCK_SIZE))) { |
BLOCK_SIZE | 204 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
BLOCK_SIZE | 211 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>8); |
BLOCK_SIZE | 214 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
BLOCK_SIZE | 220 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>16); |
BLOCK_SIZE | 223 | fs/ext/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),(block>>8) & 255); |
BLOCK_SIZE | 226 | fs/ext/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 255); |
BLOCK_SIZE | 239 | fs/ext/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 250 | fs/ext/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 283 | fs/ext/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 300 | fs/ext/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 366 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
BLOCK_SIZE | 404 | fs/ext/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) |
BLOCK_SIZE | 107 | fs/ext/namei.c | if ((char *)de >= BLOCK_SIZE+bh->b_data) { |
BLOCK_SIZE | 119 | fs/ext/namei.c | (((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) { |
BLOCK_SIZE | 125 | fs/ext/namei.c | de = (struct ext_dir_entry *) (bh->b_data+BLOCK_SIZE); |
BLOCK_SIZE | 126 | fs/ext/namei.c | offset = ((offset / BLOCK_SIZE) + 1) * BLOCK_SIZE; |
BLOCK_SIZE | 135 | fs/ext/namei.c | ((char *)de) + de->rec_len < BLOCK_SIZE+bh->b_data) |
BLOCK_SIZE | 217 | fs/ext/namei.c | if ((char *)de >= BLOCK_SIZE+bh->b_data && offset < dir->i_size) { |
BLOCK_SIZE | 230 | fs/ext/namei.c | if (offset % BLOCK_SIZE == 0 || |
BLOCK_SIZE | 231 | fs/ext/namei.c | (BLOCK_SIZE - (offset % BLOCK_SIZE)) < rec_len) { |
BLOCK_SIZE | 232 | fs/ext/namei.c | if ((offset % BLOCK_SIZE) != 0) { |
BLOCK_SIZE | 237 | fs/ext/namei.c | de->rec_len = BLOCK_SIZE |
BLOCK_SIZE | 238 | fs/ext/namei.c | - (offset & (BLOCK_SIZE - 1)); |
BLOCK_SIZE | 269 | fs/ext/namei.c | (((char *) de) + de->rec_len-1 >= BLOCK_SIZE+bh->b_data)) { |
BLOCK_SIZE | 493 | fs/ext/namei.c | if ((void *) de >= (void *) (bh->b_data+BLOCK_SIZE)) { |
BLOCK_SIZE | 497 | 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 | 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 | 403 | fs/ext2/super.c | if (sb->s_blocksize != BLOCK_SIZE && |
BLOCK_SIZE | 410 | fs/ext2/super.c | logic_sb_block = (sb_block*BLOCK_SIZE) / sb->s_blocksize; |
BLOCK_SIZE | 411 | fs/ext2/super.c | offset = (sb_block*BLOCK_SIZE) % sb->s_blocksize; |
BLOCK_SIZE | 152 | fs/isofs/file.c | ra_blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 167 | fs/isofs/file.c | max_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE; |
BLOCK_SIZE | 28 | fs/minix/bitmap.c | if (numbits >= (8*BLOCK_SIZE)) { |
BLOCK_SIZE | 29 | fs/minix/bitmap.c | end = BLOCK_SIZE; |
BLOCK_SIZE | 30 | fs/minix/bitmap.c | numbits -= 8*BLOCK_SIZE; |
BLOCK_SIZE | 60 | fs/minix/bitmap.c | bh = get_hash_table(sb->s_dev,block,BLOCK_SIZE); |
BLOCK_SIZE | 105 | fs/minix/bitmap.c | if (!(bh = getblk(sb->s_dev,j,BLOCK_SIZE))) { |
BLOCK_SIZE | 109 | fs/minix/bitmap.c | memset(bh->b_data, 0, 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 | if(blocks < read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9)) |
BLOCK_SIZE | 102 | fs/minix/file.c | blocks = read_ahead[MAJOR(inode->i_dev)] / (BLOCK_SIZE >> 9); |
BLOCK_SIZE | 154 | fs/minix/file.c | if (left < BLOCK_SIZE - offset) |
BLOCK_SIZE | 157 | fs/minix/file.c | chars = BLOCK_SIZE - offset; |
BLOCK_SIZE | 210 | fs/minix/file.c | bh = minix_getblk(inode,pos/BLOCK_SIZE,1); |
BLOCK_SIZE | 216 | fs/minix/file.c | c = BLOCK_SIZE - (pos % BLOCK_SIZE); |
BLOCK_SIZE | 219 | fs/minix/file.c | if (c != BLOCK_SIZE && !buffer_uptodate(bh)) { |
BLOCK_SIZE | 229 | fs/minix/file.c | p = (pos % BLOCK_SIZE) + bh->b_data; |
BLOCK_SIZE | 23 | fs/minix/fsync.c | #define blocksize BLOCK_SIZE |
BLOCK_SIZE | 130 | fs/minix/inode.c | set_blocksize(dev, BLOCK_SIZE); |
BLOCK_SIZE | 131 | fs/minix/inode.c | if (!(bh = bread(dev,1,BLOCK_SIZE))) { |
BLOCK_SIZE | 174 | fs/minix/inode.c | if ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
BLOCK_SIZE | 179 | fs/minix/inode.c | if ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
BLOCK_SIZE | 270 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block); |
BLOCK_SIZE | 276 | fs/minix/inode.c | i = block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block>>9); |
BLOCK_SIZE | 279 | fs/minix/inode.c | return block_bmap(bread(inode->i_dev,i,BLOCK_SIZE),block & 511); |
BLOCK_SIZE | 292 | fs/minix/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 303 | fs/minix/inode.c | result = getblk(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 336 | fs/minix/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 353 | fs/minix/inode.c | result = getblk(bh->b_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 423 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) { |
BLOCK_SIZE | 472 | fs/minix/inode.c | if (!(bh=bread(inode->i_dev, block, BLOCK_SIZE))) { |
BLOCK_SIZE | 84 | fs/minix/namei.c | while (block*BLOCK_SIZE+offset < dir->i_size) { |
BLOCK_SIZE | 400 | 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 | 72 | fs/minix/truncate.c | ind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 91 | fs/minix/truncate.c | bh = get_hash_table(inode->i_dev,tmp,BLOCK_SIZE); |
BLOCK_SIZE | 133 | fs/minix/truncate.c | dind_bh = bread(inode->i_dev, tmp, BLOCK_SIZE); |
BLOCK_SIZE | 55 | fs/msdos/inode.c | set_blocksize (sb->s_dev,BLOCK_SIZE); |
BLOCK_SIZE | 74 | fs/stat.c | #define I_B (BLOCK_SIZE / sizeof(unsigned short)) |
BLOCK_SIZE | 77 | fs/stat.c | blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE; |
BLOCK_SIZE | 88 | fs/stat.c | tmp.st_blocks = (BLOCK_SIZE / 512) * blocks; |
BLOCK_SIZE | 89 | fs/stat.c | tmp.st_blksize = BLOCK_SIZE; |
BLOCK_SIZE | 139 | fs/sysv/inode.c | if (sb->sv_block_size == BLOCK_SIZE) |
BLOCK_SIZE | 145 | fs/sysv/inode.c | sbd2 = (struct xenix_super_block *) (bh2->b_data - BLOCK_SIZE/2); |
BLOCK_SIZE | 180 | fs/sysv/inode.c | sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 197 | fs/sysv/inode.c | if (sb->sv_block_size == BLOCK_SIZE) |
BLOCK_SIZE | 198 | fs/sysv/inode.c | sbd = (struct sysv4_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 238 | fs/sysv/inode.c | sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 255 | fs/sysv/inode.c | if (sb->sv_block_size == BLOCK_SIZE) |
BLOCK_SIZE | 256 | fs/sysv/inode.c | sbd = (struct sysv2_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 296 | fs/sysv/inode.c | sbd = (struct coh_super_block *) (bh->b_data + BLOCK_SIZE/2); |
BLOCK_SIZE | 357 | fs/sysv/inode.c | set_blocksize(dev,BLOCK_SIZE); |
BLOCK_SIZE | 360 | fs/sysv/inode.c | if ((bh = bread(dev, 1, BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 365 | fs/sysv/inode.c | if ((bh = bread(dev, 0, BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 381 | fs/sysv/inode.c | if ((bh = bread(dev, offsets[i], BLOCK_SIZE)) != NULL) { |
BLOCK_SIZE | 404 | fs/sysv/inode.c | if (sb->sv_block_size == BLOCK_SIZE) { |
BLOCK_SIZE | 466 | fs/sysv/inode.c | set_blocksize(sb->s_dev,BLOCK_SIZE); |
BLOCK_SIZE | 528 | fs/sysv/inode.c | if (sb->s_blocksize != BLOCK_SIZE) |
BLOCK_SIZE | 529 | fs/sysv/inode.c | set_blocksize(sb->s_dev,BLOCK_SIZE); |
BLOCK_SIZE | 74 | fs/xiafs/inode.c | set_blocksize(dev, BLOCK_SIZE); |
BLOCK_SIZE | 76 | fs/xiafs/inode.c | if (!(bh = bread(dev, 0, BLOCK_SIZE))) { |
BLOCK_SIZE | 97 | fs/xiafs/inode.c | if (s->s_blocksize != BLOCK_SIZE && |
BLOCK_SIZE | 107 | fs/xiafs/inode.c | sp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ; |
BLOCK_SIZE | 614 | 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 | 30 | include/linux/blk.h | #define SECTOR_MASK ((BLOCK_SIZE >> 9) - 1) |
BLOCK_SIZE | 35 | include/linux/blk.h | ((BLOCK_SIZE >> 9) - 1)) |
BLOCK_SIZE | 358 | include/linux/blk.h | req->sector += (BLOCK_SIZE / 512); |
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 | 19 | include/linux/xia_fs.h | #define _XIAFS_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof(struct xiafs_inode))) |