bit 231 arch/x86/kernel/amd_iommu_init.c ctrl |= (1 << bit);
bit 240 arch/x86/kernel/amd_iommu_init.c ctrl &= ~(1 << bit);
bit 468 arch/x86/kernel/amd_iommu_init.c int i = (bit >> 5) & 0x07;
bit 469 arch/x86/kernel/amd_iommu_init.c int _bit = bit & 0x1f;
bit 15 arch/x86/kernel/cpu/addon_cpuid_features.c u8 bit;
bit 48 arch/x86/kernel/cpu/addon_cpuid_features.c if (regs[cb->reg] & (1 << cb->bit))
bit 843 arch/x86/kernel/cpu/common.c int bit;
bit 844 arch/x86/kernel/cpu/common.c if (get_option(&arg, &bit) && bit < NCAPINTS*32)
bit 845 arch/x86/kernel/cpu/common.c setup_clear_cpu_cap(bit);
bit 225 arch/x86/kernel/tlb_uv.c int bit;
bit 266 arch/x86/kernel/tlb_uv.c for_each_cpu_mask(bit, *cpumaskp) {
bit 267 arch/x86/kernel/tlb_uv.c blade = uv_cpu_to_blade_id(bit);
bit 270 arch/x86/kernel/tlb_uv.c cpu_clear(bit, *cpumaskp);
bit 303 arch/x86/kernel/tlb_uv.c int bit;
bit 318 arch/x86/kernel/tlb_uv.c for_each_cpu_mask(bit, *cpumaskp) {
bit 319 arch/x86/kernel/tlb_uv.c blade = uv_cpu_to_blade_id(bit);
bit 786 arch/x86/kernel/vm86_32.c int bit;
bit 793 arch/x86/kernel/vm86_32.c bit = irqbits & (1 << irqnumber);
bit 794 arch/x86/kernel/vm86_32.c irqbits &= ~bit;
bit 795 arch/x86/kernel/vm86_32.c if (bit) {
bit 1109 arch/x86/kvm/x86.c const u32 kvm_supported_word0_x86_features = bit(X86_FEATURE_FPU) |
bit 1110 arch/x86/kvm/x86.c bit(X86_FEATURE_VME) | bit(X86_FEATURE_DE) |
bit 1111 arch/x86/kvm/x86.c bit(X86_FEATURE_PSE) | bit(X86_FEATURE_TSC) |
bit 1112 arch/x86/kvm/x86.c bit(X86_FEATURE_MSR) | bit(X86_FEATURE_PAE) |
bit 1113 arch/x86/kvm/x86.c bit(X86_FEATURE_CX8) | bit(X86_FEATURE_APIC) |
bit 1114 arch/x86/kvm/x86.c bit(X86_FEATURE_SEP) | bit(X86_FEATURE_PGE) |
bit 1115 arch/x86/kvm/x86.c bit(X86_FEATURE_CMOV) | bit(X86_FEATURE_PSE36) |
bit 1116 arch/x86/kvm/x86.c bit(X86_FEATURE_CLFLSH) | bit(X86_FEATURE_MMX) |
bit 1117 arch/x86/kvm/x86.c bit(X86_FEATURE_FXSR) | bit(X86_FEATURE_XMM) |
bit 1118 arch/x86/kvm/x86.c bit(X86_FEATURE_XMM2) | bit(X86_FEATURE_SELFSNOOP);
bit 1119 arch/x86/kvm/x86.c const u32 kvm_supported_word1_x86_features = bit(X86_FEATURE_FPU) |
bit 1120 arch/x86/kvm/x86.c bit(X86_FEATURE_VME) | bit(X86_FEATURE_DE) |
bit 1121 arch/x86/kvm/x86.c bit(X86_FEATURE_PSE) | bit(X86_FEATURE_TSC) |
bit 1122 arch/x86/kvm/x86.c bit(X86_FEATURE_MSR) | bit(X86_FEATURE_PAE) |
bit 1123 arch/x86/kvm/x86.c bit(X86_FEATURE_CX8) | bit(X86_FEATURE_APIC) |
bit 1124 arch/x86/kvm/x86.c bit(X86_FEATURE_PGE) |
bit 1125 arch/x86/kvm/x86.c bit(X86_FEATURE_CMOV) | bit(X86_FEATURE_PSE36) |
bit 1126 arch/x86/kvm/x86.c bit(X86_FEATURE_MMX) | bit(X86_FEATURE_FXSR) |
bit 1127 arch/x86/kvm/x86.c bit(X86_FEATURE_SYSCALL) |
bit 1128 arch/x86/kvm/x86.c (bit(X86_FEATURE_NX) && is_efer_nx()) |
bit 1130 arch/x86/kvm/x86.c bit(X86_FEATURE_LM) |
bit 1132 arch/x86/kvm/x86.c bit(X86_FEATURE_MMXEXT) |
bit 1133 arch/x86/kvm/x86.c bit(X86_FEATURE_3DNOWEXT) |
bit 1134 arch/x86/kvm/x86.c bit(X86_FEATURE_3DNOW);
bit 1136 arch/x86/kvm/x86.c bit(X86_FEATURE_XMM3) | bit(X86_FEATURE_CX16);
bit 1138 arch/x86/kvm/x86.c bit(X86_FEATURE_LAHF_LM) | bit(X86_FEATURE_CMP_LEGACY);
bit 766 arch/x86/mm/fault.c unsigned long bit = (address - 0xA0000) >> PAGE_SHIFT;
bit 767 arch/x86/mm/fault.c if (bit < 32)
bit 768 arch/x86/mm/fault.c tsk->thread.screen_bitmap |= 1 << bit;
bit 41 arch/x86/mm/srat_32.c #define BMAP_SET(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] |= 1 << NODE_ARRAY_OFFSET(bit))
bit 42 arch/x86/mm/srat_32.c #define BMAP_TEST(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] & (1 << NODE_ARRAY_OFFSET(bit)))
bit 163 block/blk-core.c int bit;
bit 180 block/blk-core.c for (bit = 0; bit < BLK_MAX_CDB; bit++)
bit 181 block/blk-core.c printk("%02x ", rq->cmd[bit]);
bit 48 crypto/lrw.c __set_bit(bit ^ 0x78, b);
bit 66 fs/affs/bitmap.c u32 blk, bmap, bit, mask, tmp;
bit 76 fs/affs/bitmap.c bit = blk % sbi->s_bmap_bits;
bit 91 fs/affs/bitmap.c mask = 1 << (bit & 31);
bit 92 fs/affs/bitmap.c data = (__be32 *)bh->b_data + bit / 32 + 1;
bit 145 fs/affs/bitmap.c u32 blk, bmap, bit, mask, mask2, tmp;
bit 205 fs/affs/bitmap.c bit = blk % sbi->s_bmap_bits;
bit 206 fs/affs/bitmap.c data = (__be32 *)bh->b_data + bit / 32 + 1;
bit 208 fs/affs/bitmap.c mask = ~0UL << (bit & 31);
bit 229 fs/affs/bitmap.c bit = ffs(tmp & mask) - 1;
bit 230 fs/affs/bitmap.c blk += bit + sbi->s_reserved;
bit 231 fs/affs/bitmap.c mask2 = mask = 1 << (bit & 31);
bit 492 fs/ext2/balloc.c unsigned long bit;
bit 516 fs/ext2/balloc.c bit = (block - le32_to_cpu(es->s_first_data_block)) %
bit 522 fs/ext2/balloc.c if (bit + count > EXT2_BLOCKS_PER_GROUP(sb)) {
bit 523 fs/ext2/balloc.c overflow = bit + count - EXT2_BLOCKS_PER_GROUP(sb);
bit 550 fs/ext2/balloc.c bit + i, bitmap_bh->b_data)) {
bit 111 fs/ext2/ialloc.c unsigned long bit;
bit 141 fs/ext2/ialloc.c bit = (ino - 1) % EXT2_INODES_PER_GROUP(sb);
bit 149 fs/ext2/ialloc.c bit, (void *) bitmap_bh->b_data))
bit 483 fs/ext3/balloc.c ext3_grpblk_t bit;
bit 510 fs/ext3/balloc.c bit = (block - le32_to_cpu(es->s_first_data_block)) %
bit 516 fs/ext3/balloc.c if (bit + count > EXT3_BLOCKS_PER_GROUP(sb)) {
bit 517 fs/ext3/balloc.c overflow = bit + count - EXT3_BLOCKS_PER_GROUP(sb);
bit 609 fs/ext3/balloc.c ext3_set_bit_atomic(sb_bgl_lock(sbi, block_group), bit + i,
bit 619 fs/ext3/balloc.c bit + i, bitmap_bh->b_data)) {
bit 97 fs/ext3/ialloc.c unsigned long bit;
bit 143 fs/ext3/ialloc.c bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
bit 155 fs/ext3/ialloc.c bit, bitmap_bh->b_data))
bit 640 fs/ext3/ialloc.c int bit;
bit 653 fs/ext3/ialloc.c bit = (ino - 1) % EXT3_INODES_PER_GROUP(sb);
bit 665 fs/ext3/ialloc.c if (!ext3_test_bit(bit, bitmap_bh->b_data))
bit 692 fs/ext3/ialloc.c bit, (unsigned long long)bitmap_bh->b_blocknr,
bit 693 fs/ext3/ialloc.c ext3_test_bit(bit, bitmap_bh->b_data));
bit 202 fs/ext3/resize.c ext3_grpblk_t bit;
bit 229 fs/ext3/resize.c for (i = 0, bit = 1, block = start + 1;
bit 230 fs/ext3/resize.c i < gdblocks; i++, block++, bit++) {
bit 233 fs/ext3/resize.c ext3_debug("update backup group %#04lx (+%d)\n", block, bit);
bit 253 fs/ext3/resize.c ext3_set_bit(bit, bh->b_data);
bit 258 fs/ext3/resize.c for (i = 0, bit = gdblocks + 1, block = start + bit;
bit 259 fs/ext3/resize.c i < reserved_gdb; i++, block++, bit++) {
bit 262 fs/ext3/resize.c ext3_debug("clear reserved block %#04lx (+%d)\n", block, bit);
bit 273 fs/ext3/resize.c ext3_set_bit(bit, bh->b_data);
bit 284 fs/ext3/resize.c for (i = 0, block = input->inode_table, bit = block - start;
bit 285 fs/ext3/resize.c i < sbi->s_itb_per_group; i++, bit++, block++) {
bit 288 fs/ext3/resize.c ext3_debug("clear inode block %#04lx (+%d)\n", block, bit);
bit 300 fs/ext3/resize.c ext3_set_bit(bit, bh->b_data);
bit 92 fs/ext4/balloc.c int bit, bit_max;
bit 147 fs/ext4/balloc.c for (bit = 0; bit < bit_max; bit++)
bit 148 fs/ext4/balloc.c ext4_set_bit(bit, bh->b_data);
bit 374 fs/ext4/balloc.c ext4_grpblk_t bit;
bit 399 fs/ext4/balloc.c ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
bit 404 fs/ext4/balloc.c if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
bit 405 fs/ext4/balloc.c overflow = bit + count - EXT4_BLOCKS_PER_GROUP(sb);
bit 496 fs/ext4/balloc.c ext4_set_bit_atomic(sb_bgl_lock(sbi, block_group), bit + i,
bit 506 fs/ext4/balloc.c bit + i, bitmap_bh->b_data)) {
bit 167 fs/ext4/ialloc.c unsigned long bit;
bit 215 fs/ext4/ialloc.c bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
bit 227 fs/ext4/ialloc.c bit, bitmap_bh->b_data))
bit 892 fs/ext4/ialloc.c int bit;
bit 905 fs/ext4/ialloc.c bit = (ino - 1) % EXT4_INODES_PER_GROUP(sb);
bit 917 fs/ext4/ialloc.c if (!ext4_test_bit(bit, bitmap_bh->b_data))
bit 944 fs/ext4/ialloc.c bit, (unsigned long long)bitmap_bh->b_blocknr,
bit 945 fs/ext4/ialloc.c ext4_test_bit(bit, bitmap_bh->b_data));
bit 337 fs/ext4/mballoc.c *bit += ((unsigned long) addr & 7UL) << 3;
bit 340 fs/ext4/mballoc.c *bit += ((unsigned long) addr & 3UL) << 3;
bit 354 fs/ext4/mballoc.c addr = mb_correct_addr_and_bit(&bit, addr);
bit 355 fs/ext4/mballoc.c return ext4_test_bit(bit, addr);
bit 360 fs/ext4/mballoc.c addr = mb_correct_addr_and_bit(&bit, addr);
bit 361 fs/ext4/mballoc.c ext4_set_bit(bit, addr);
bit 366 fs/ext4/mballoc.c addr = mb_correct_addr_and_bit(&bit, addr);
bit 367 fs/ext4/mballoc.c ext4_set_bit_atomic(lock, bit, addr);
bit 372 fs/ext4/mballoc.c addr = mb_correct_addr_and_bit(&bit, addr);
bit 373 fs/ext4/mballoc.c ext4_clear_bit(bit, addr);
bit 378 fs/ext4/mballoc.c addr = mb_correct_addr_and_bit(&bit, addr);
bit 379 fs/ext4/mballoc.c ext4_clear_bit_atomic(lock, bit, addr);
bit 3582 fs/ext4/mballoc.c ext4_grpblk_t bit;
bit 3588 fs/ext4/mballoc.c ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
bit 3590 fs/ext4/mballoc.c end = bit + pa->pa_len;
bit 3598 fs/ext4/mballoc.c while (bit < end) {
bit 3599 fs/ext4/mballoc.c bit = mb_find_next_zero_bit(bitmap_bh->b_data, end, bit);
bit 3600 fs/ext4/mballoc.c if (bit >= end)
bit 3602 fs/ext4/mballoc.c next = mb_find_next_bit(bitmap_bh->b_data, end, bit);
bit 3603 fs/ext4/mballoc.c start = group * EXT4_BLOCKS_PER_GROUP(sb) + bit +
bit 3606 fs/ext4/mballoc.c (unsigned) start, (unsigned) next - bit,
bit 3608 fs/ext4/mballoc.c free += next - bit;
bit 3612 fs/ext4/mballoc.c ac->ac_b_ex.fe_start = bit;
bit 3613 fs/ext4/mballoc.c ac->ac_b_ex.fe_len = next - bit;
bit 3618 fs/ext4/mballoc.c mb_free_blocks(pa->pa_inode, e4b, bit, next - bit);
bit 3619 fs/ext4/mballoc.c bit = next + 1;
bit 3645 fs/ext4/mballoc.c ext4_grpblk_t bit;
bit 3651 fs/ext4/mballoc.c ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
bit 3653 fs/ext4/mballoc.c mb_free_blocks(pa->pa_inode, e4b, bit, pa->pa_len);
bit 3660 fs/ext4/mballoc.c ac->ac_b_ex.fe_start = bit;
bit 4493 fs/ext4/mballoc.c ext4_grpblk_t bit;
bit 4527 fs/ext4/mballoc.c ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
bit 4533 fs/ext4/mballoc.c if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
bit 4534 fs/ext4/mballoc.c overflow = bit + count - EXT4_BLOCKS_PER_GROUP(sb);
bit 4585 fs/ext4/mballoc.c BUG_ON(!mb_test_bit(bit + i, bitmap_bh->b_data));
bit 4589 fs/ext4/mballoc.c bit, count);
bit 4597 fs/ext4/mballoc.c ac->ac_b_ex.fe_start = bit;
bit 4605 fs/ext4/mballoc.c ext4_mb_free_metadata(handle, &e4b, block_group, bit, count);
bit 4608 fs/ext4/mballoc.c mb_free_blocks(inode, &e4b, bit, count);
bit 186 fs/ext4/resize.c ext4_grpblk_t bit;
bit 213 fs/ext4/resize.c for (i = 0, bit = 1, block = start + 1;
bit 214 fs/ext4/resize.c i < gdblocks; i++, block++, bit++) {
bit 217 fs/ext4/resize.c ext4_debug("update backup group %#04llx (+%d)\n", block, bit);
bit 236 fs/ext4/resize.c ext4_set_bit(bit, bh->b_data);
bit 241 fs/ext4/resize.c for (i = 0, bit = gdblocks + 1, block = start + bit;
bit 242 fs/ext4/resize.c i < reserved_gdb; i++, block++, bit++) {
bit 245 fs/ext4/resize.c ext4_debug("clear reserved block %#04llx (+%d)\n", block, bit);
bit 255 fs/ext4/resize.c ext4_set_bit(bit, bh->b_data);
bit 266 fs/ext4/resize.c for (i = 0, block = input->inode_table, bit = block - start;
bit 267 fs/ext4/resize.c i < sbi->s_itb_per_group; i++, bit++, block++) {
bit 270 fs/ext4/resize.c ext4_debug("clear inode block %#04llx (+%d)\n", block, bit);
bit 281 fs/ext4/resize.c ext4_set_bit(bit, bh->b_data);
bit 825 fs/gfs2/glock.c int bit = delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE;
bit 827 fs/gfs2/glock.c set_bit(bit, &gl->gl_flags);
bit 85 fs/gfs2/rgrp.c const unsigned int bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
bit 92 fs/gfs2/rgrp.c cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
bit 98 fs/gfs2/rgrp.c *byte1 ^= (cur_state ^ new_state) << bit;
bit 102 fs/gfs2/rgrp.c cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
bit 103 fs/gfs2/rgrp.c *byte2 ^= (cur_state ^ new_state) << bit;
bit 121 fs/gfs2/rgrp.c unsigned int bit;
bit 124 fs/gfs2/rgrp.c bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
bit 129 fs/gfs2/rgrp.c cur_state = (*byte >> bit) & GFS2_BIT_MASK;
bit 153 fs/gfs2/rgrp.c int bit, startbit;
bit 165 fs/gfs2/rgrp.c startbit = bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
bit 172 fs/gfs2/rgrp.c if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) {
bit 175 fs/gfs2/rgrp.c ((bit - startbit) >> 1));
bit 177 fs/gfs2/rgrp.c bit += GFS2_BIT_SIZE;
bit 178 fs/gfs2/rgrp.c if (bit >= GFS2_NBBY * GFS2_BIT_SIZE) {
bit 179 fs/gfs2/rgrp.c bit = 0;
bit 250 fs/gfs2/util.c unsigned int c, o, b = bit;
bit 60 fs/jffs2/compr_rubin.c if (bit) {
bit 78 fs/jffs2/compr_rubin.c int bit;
bit 80 fs/jffs2/compr_rubin.c bit = (pp->buf[pp->ofs >> 3] >> (7-(pp->ofs & 7))) & 1;
bit 83 fs/jffs2/compr_rubin.c return bit;
bit 58 fs/minix/bitmap.c unsigned long bit, zone;
bit 65 fs/minix/bitmap.c bit = zone & ((1<<k) - 1);
bit 73 fs/minix/bitmap.c if (!minix_test_and_clear_bit(bit, bh->b_data))
bit 197 fs/minix/bitmap.c unsigned long ino, bit;
bit 204 fs/minix/bitmap.c bit = ino & ((1<<k) - 1);
bit 215 fs/minix/bitmap.c if (!minix_test_and_clear_bit(bit, bh->b_data))
bit 216 fs/minix/bitmap.c printk("minix_free_inode: bit %lu already cleared\n", bit);
bit 56 fs/ntfs/bitmap.c u8 bit;
bit 88 fs/ntfs/bitmap.c bit = start_bit & 7;
bit 91 fs/ntfs/bitmap.c if (bit) {
bit 93 fs/ntfs/bitmap.c while ((bit & 7) && cnt) {
bit 96 fs/ntfs/bitmap.c *byte |= 1 << bit++;
bit 98 fs/ntfs/bitmap.c *byte &= ~(1 << bit++);
bit 149 fs/ntfs/bitmap.c bit = cnt;
bit 151 fs/ntfs/bitmap.c while (bit--) {
bit 153 fs/ntfs/bitmap.c *byte |= 1 << bit;
bit 155 fs/ntfs/bitmap.c *byte &= ~(1 << bit);
bit 99 fs/ntfs/bitmap.h return ntfs_bitmap_set_run(vi, bit, 1);
bit 113 fs/ntfs/bitmap.h return ntfs_bitmap_clear_run(vi, bit, 1);
bit 161 fs/ntfs/lcnalloc.c u8 pass, done_zones, search_zone, need_writeback = 0, bit;
bit 321 fs/ntfs/lcnalloc.c bit = 1 << (lcn & 7);
bit 322 fs/ntfs/lcnalloc.c ntfs_debug("bit 0x%x.", bit);
bit 324 fs/ntfs/lcnalloc.c if (*byte & bit) {
bit 358 fs/ntfs/lcnalloc.c *byte |= bit;
bit 1134 fs/ntfs/mft.c s64 pass_end, ll, data_pos, pass_start, ofs, bit;
bit 1200 fs/ntfs/mft.c bit = data_pos & 7;
bit 1204 fs/ntfs/mft.c (long long)data_pos, (long long)bit);
bit 1205 fs/ntfs/mft.c for (; bit < size && data_pos + bit < pass_end;
bit 1206 fs/ntfs/mft.c bit &= ~7ull, bit += 8) {
bit 1207 fs/ntfs/mft.c byte = buf + (bit >> 3);
bit 1211 fs/ntfs/mft.c if (b < 8 && b >= (bit & 7)) {
bit 1212 fs/ntfs/mft.c ll = data_pos + (bit & ~7ull) + b;
bit 1230 fs/ntfs/mft.c (long long)data_pos, (long long)bit);
bit 2246 fs/ntfs/mft.c s64 ll, bit, old_data_initialized, old_data_size;
bit 2279 fs/ntfs/mft.c bit = ntfs_mft_bitmap_find_and_alloc_free_rec_nolock(vol, base_ni);
bit 2280 fs/ntfs/mft.c if (bit >= 0) {
bit 2282 fs/ntfs/mft.c (long long)bit);
bit 2285 fs/ntfs/mft.c if (bit != -ENOSPC) {
bit 2287 fs/ntfs/mft.c return ERR_PTR(bit);
bit 2304 fs/ntfs/mft.c bit = ll;
bit 2305 fs/ntfs/mft.c if (bit < 24)
bit 2306 fs/ntfs/mft.c bit = 24;
bit 2307 fs/ntfs/mft.c if (unlikely(bit >= (1ll << 32)))
bit 2310 fs/ntfs/mft.c (long long)bit);
bit 2318 fs/ntfs/mft.c bit = old_data_initialized << 3;
bit 2319 fs/ntfs/mft.c if (unlikely(bit >= (1ll << 32)))
bit 2368 fs/ntfs/mft.c ntfs_debug("Found free record (#3), bit 0x%llx.", (long long)bit);
bit 2372 fs/ntfs/mft.c err = ntfs_bitmap_set_bit(vol->mftbmp_ino, bit);
bit 2378 fs/ntfs/mft.c ntfs_debug("Set bit 0x%llx in mft bitmap.", (long long)bit);
bit 2388 fs/ntfs/mft.c ll = (bit + 1) << vol->mft_record_size_bits;
bit 2518 fs/ntfs/mft.c index = bit << vol->mft_record_size_bits >> PAGE_CACHE_SHIFT;
bit 2519 fs/ntfs/mft.c ofs = (bit << vol->mft_record_size_bits) & ~PAGE_CACHE_MASK;
bit 2524 fs/ntfs/mft.c "mft record 0x%llx.", (long long)bit);
bit 2541 fs/ntfs/mft.c (long long)bit);
bit 2558 fs/ntfs/mft.c err = ntfs_mft_record_layout(vol, bit, m);
bit 2561 fs/ntfs/mft.c "record 0x%llx.", (long long)bit);
bit 2591 fs/ntfs/mft.c m = map_extent_mft_record(base_ni, bit, &ni);
bit 2594 fs/ntfs/mft.c "mft record 0x%llx.", (long long)bit);
bit 2639 fs/ntfs/mft.c vi->i_ino = bit;
bit 2727 fs/ntfs/mft.c vol->mft_data_pos = bit + 1;
bit 2734 fs/ntfs/mft.c base_ni ? "extent " : "", (long long)bit);
bit 2746 fs/ntfs/mft.c if (ntfs_bitmap_clear_bit(vol->mftbmp_ino, bit)) {
bit 5975 fs/ocfs2/alloc.c type, slot, bit, (unsigned long long)blkno);
bit 5978 fs/ocfs2/alloc.c item->free_bit = bit;
bit 860 fs/ocfs2/dlm/dlmcommon.h __dlm_lockres_set_refmap_bit(bit,res,__FILE__,__LINE__)
bit 862 fs/ocfs2/dlm/dlmcommon.h __dlm_lockres_clear_refmap_bit(bit,res,__FILE__,__LINE__)
bit 871 fs/ocfs2/dlm/dlmcommon.h set_bit(bit, res->refmap);
bit 881 fs/ocfs2/dlm/dlmcommon.h clear_bit(bit, res->refmap);
bit 1100 fs/ocfs2/dlm/dlmcommon.h int bit;
bit 1101 fs/ocfs2/dlm/dlmcommon.h bit = find_next_bit(iter->node_map, O2NM_MAX_NODES, iter->curnode+1);
bit 1102 fs/ocfs2/dlm/dlmcommon.h if (bit >= O2NM_MAX_NODES) {
bit 1106 fs/ocfs2/dlm/dlmcommon.h iter->curnode = bit;
bit 1107 fs/ocfs2/dlm/dlmcommon.h return bit;
bit 59 fs/ocfs2/dlm/dlmdebug.c int bit;
bit 63 fs/ocfs2/dlm/dlmdebug.c bit = 0;
bit 65 fs/ocfs2/dlm/dlmdebug.c bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
bit 66 fs/ocfs2/dlm/dlmdebug.c if (bit >= O2NM_MAX_NODES)
bit 68 fs/ocfs2/dlm/dlmdebug.c printk("%u ", bit);
bit 69 fs/ocfs2/dlm/dlmdebug.c bit++;
bit 821 fs/ocfs2/dlm/dlmdomain.c int bit = query->node_idx;
bit 835 fs/ocfs2/dlm/dlmdomain.c "is ongoing.\n", bit);
bit 837 fs/ocfs2/dlm/dlmdomain.c } else if (test_bit(bit, dlm->recovery_map)) {
bit 839 fs/ocfs2/dlm/dlmdomain.c "still needs recovery.\n", bit);
bit 841 fs/ocfs2/dlm/dlmdomain.c } else if (test_bit(bit, dlm->domain_map)) {
bit 844 fs/ocfs2/dlm/dlmdomain.c bit);
bit 853 fs/ocfs2/dlm/dlmdomain.c if (dlm_query_join_proto_check("DLM", bit,
bit 857 fs/ocfs2/dlm/dlmdomain.c } else if (dlm_query_join_proto_check("fs", bit,
bit 710 fs/ocfs2/dlm/dlmmaster.c int bit, wait_on_recovery = 0;
bit 835 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0);
bit 836 fs/ocfs2/dlm/dlmmaster.c if (bit < O2NM_MAX_NODES) {
bit 839 fs/ocfs2/dlm/dlmmaster.c dlm->name, namelen, (char *)lockid, bit);
bit 889 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(dlm->recovery_map, O2NM_MAX_NODES, 0);
bit 890 fs/ocfs2/dlm/dlmmaster.c if (bit < O2NM_MAX_NODES) {
bit 893 fs/ocfs2/dlm/dlmmaster.c dlm->name, namelen, (char *)lockid, bit);
bit 900 fs/ocfs2/dlm/dlmmaster.c dlm_wait_for_node_recovery(dlm, bit, 10000);
bit 983 fs/ocfs2/dlm/dlmmaster.c int ret, bit;
bit 1058 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0);
bit 1059 fs/ocfs2/dlm/dlmmaster.c if (dlm->node_num <= bit) {
bit 1166 fs/ocfs2/dlm/dlmmaster.c int bit;
bit 1171 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(iter->diff_bm, O2NM_MAX_NODES,
bit 1173 fs/ocfs2/dlm/dlmmaster.c if (bit >= O2NM_MAX_NODES) {
bit 1179 fs/ocfs2/dlm/dlmmaster.c if (test_bit(bit, iter->orig_bm))
bit 1184 fs/ocfs2/dlm/dlmmaster.c iter->curnode = bit;
bit 1185 fs/ocfs2/dlm/dlmmaster.c return bit;
bit 1779 fs/ocfs2/dlm/dlmmaster.c int bit = find_next_bit (mle->maybe_map, O2NM_MAX_NODES, 0);
bit 1780 fs/ocfs2/dlm/dlmmaster.c if (bit >= O2NM_MAX_NODES) {
bit 1786 fs/ocfs2/dlm/dlmmaster.c } else if (bit != assert->node_idx) {
bit 1789 fs/ocfs2/dlm/dlmmaster.c "back off\n", assert->node_idx, bit);
bit 1797 fs/ocfs2/dlm/dlmmaster.c "have begun after %u won.\n", bit,
bit 1798 fs/ocfs2/dlm/dlmmaster.c assert->node_idx, namelen, name, bit,
bit 2064 fs/ocfs2/dlm/dlmmaster.c int bit;
bit 2084 fs/ocfs2/dlm/dlmmaster.c bit = dlm->node_num;
bit 2086 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(nodemap, O2NM_MAX_NODES,
bit 2087 fs/ocfs2/dlm/dlmmaster.c bit+1);
bit 2088 fs/ocfs2/dlm/dlmmaster.c if (bit >= O2NM_MAX_NODES)
bit 2090 fs/ocfs2/dlm/dlmmaster.c clear_bit(bit, nodemap);
bit 2851 fs/ocfs2/dlm/dlmmaster.c int i, bit;
bit 2878 fs/ocfs2/dlm/dlmmaster.c bit = 0;
bit 2880 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(res->refmap, O2NM_MAX_NODES, bit);
bit 2881 fs/ocfs2/dlm/dlmmaster.c if (bit >= O2NM_MAX_NODES)
bit 2885 fs/ocfs2/dlm/dlmmaster.c if (bit != dlm->node_num) {
bit 2888 fs/ocfs2/dlm/dlmmaster.c res->lockname.len, res->lockname.name, bit);
bit 2889 fs/ocfs2/dlm/dlmmaster.c dlm_lockres_clear_refmap_bit(bit, res);
bit 2891 fs/ocfs2/dlm/dlmmaster.c bit++;
bit 3186 fs/ocfs2/dlm/dlmmaster.c int bit;
bit 3189 fs/ocfs2/dlm/dlmmaster.c bit = find_next_bit(mle->maybe_map, O2NM_MAX_NODES, 0);
bit 3190 fs/ocfs2/dlm/dlmmaster.c if (bit != dead_node) {
bit 465 fs/ocfs2/dlm/dlmrecovery.c int bit;
bit 467 fs/ocfs2/dlm/dlmrecovery.c bit = find_next_bit (dlm->recovery_map, O2NM_MAX_NODES+1, 0);
bit 468 fs/ocfs2/dlm/dlmrecovery.c if (bit >= O2NM_MAX_NODES || bit < 0)
bit 471 fs/ocfs2/dlm/dlmrecovery.c dlm_set_reco_dead_node(dlm, bit);
bit 101 fs/ocfs2/dlm/dlmthread.c int bit = find_next_bit(res->refmap, O2NM_MAX_NODES, 0);
bit 102 fs/ocfs2/dlm/dlmthread.c if (bit >= O2NM_MAX_NODES) {
bit 88 fs/ocfs2/heartbeat.c set_bit(bit, map->map);
bit 95 fs/ocfs2/heartbeat.c if (bit==-1)
bit 97 fs/ocfs2/heartbeat.c BUG_ON(bit >= map->num_nodes);
bit 99 fs/ocfs2/heartbeat.c __ocfs2_node_map_set_bit(map, bit);
bit 106 fs/ocfs2/heartbeat.c clear_bit(bit, map->map);
bit 113 fs/ocfs2/heartbeat.c if (bit==-1)
bit 115 fs/ocfs2/heartbeat.c BUG_ON(bit >= map->num_nodes);
bit 117 fs/ocfs2/heartbeat.c __ocfs2_node_map_clear_bit(map, bit);
bit 126 fs/ocfs2/heartbeat.c if (bit >= map->num_nodes) {
bit 127 fs/ocfs2/heartbeat.c mlog(ML_ERROR, "bit=%d map->num_nodes=%d\n", bit, map->num_nodes);
bit 131 fs/ocfs2/heartbeat.c ret = test_bit(bit, map->map);
bit 1849 fs/ocfs2/suballoc.c u16 bit = le16_to_cpu(di->i_suballoc_bit);
bit 1850 fs/ocfs2/suballoc.c u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
bit 1853 fs/ocfs2/suballoc.c inode_alloc_bh, bit, bg_blkno, 1);
bit 130 fs/ocfs2/suballoc.h u64 group = block - (u64) bit;
bit 1509 fs/ocfs2/xattr.c u16 bit;
bit 1532 fs/ocfs2/xattr.c bit = le16_to_cpu(xb->xb_suballoc_bit);
bit 1533 fs/ocfs2/xattr.c bg_blkno = ocfs2_which_suballoc_group(blk, bit);
bit 1559 fs/ocfs2/xattr.c bit, bg_blkno, 1);
bit 32 fs/omfs/bitmap.c x = find_next_bit(*addr, nbits, bit);
bit 33 fs/omfs/bitmap.c count += x - bit;
bit 38 fs/omfs/bitmap.c bit = 0;
bit 60 fs/omfs/bitmap.c for (i = 0; i < count; i++, bit++) {
bit 61 fs/omfs/bitmap.c if (bit >= nbits) {
bit 62 fs/omfs/bitmap.c bit = 0;
bit 73 fs/omfs/bitmap.c set_bit(bit, sbi->s_imap[map]);
bit 74 fs/omfs/bitmap.c set_bit(bit, (unsigned long *)bh->b_data);
bit 76 fs/omfs/bitmap.c clear_bit(bit, sbi->s_imap[map]);
bit 77 fs/omfs/bitmap.c clear_bit(bit, (unsigned long *)bh->b_data);
bit 95 fs/omfs/bitmap.c unsigned int map, bit;
bit 100 fs/omfs/bitmap.c bit = do_div(tmp, bits_per_entry);
bit 104 fs/omfs/bitmap.c if (map >= sbi->s_imap_size || test_and_set_bit(bit, sbi->s_imap[map]))
bit 112 fs/omfs/bitmap.c set_bit(bit, (unsigned long *)bh->b_data);
bit 138 fs/omfs/bitmap.c int i, run, bit;
bit 142 fs/omfs/bitmap.c bit = 0;
bit 143 fs/omfs/bitmap.c while (bit < bits_per_entry) {
bit 144 fs/omfs/bitmap.c bit = find_next_zero_bit(sbi->s_imap[i], bits_per_entry,
bit 145 fs/omfs/bitmap.c bit);
bit 147 fs/omfs/bitmap.c if (bit == bits_per_entry)
bit 151 fs/omfs/bitmap.c sbi->s_imap_size-i, bit, max_request);
bit 155 fs/omfs/bitmap.c bit += run;
bit 162 fs/omfs/bitmap.c *return_block = i * bits_per_entry + bit;
bit 164 fs/omfs/bitmap.c ret = set_run(sb, i, bits_per_entry, bit, run, 1);
bit 179 fs/omfs/bitmap.c unsigned int map, bit;
bit 183 fs/omfs/bitmap.c bit = do_div(tmp, bits_per_entry);
bit 190 fs/omfs/bitmap.c ret = set_run(sb, map, bits_per_entry, bit, count, 0);
bit 214 fs/select.c unsigned long in, out, ex, all_bits, bit = 1, mask, j;
bit 226 fs/select.c for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
bit 230 fs/select.c if (!(bit & all_bits))
bit 239 fs/select.c if ((mask & POLLIN_SET) && (in & bit)) {
bit 240 fs/select.c res_in |= bit;
bit 243 fs/select.c if ((mask & POLLOUT_SET) && (out & bit)) {
bit 244 fs/select.c res_out |= bit;
bit 247 fs/select.c if ((mask & POLLEX_SET) && (ex & bit)) {
bit 248 fs/select.c res_ex |= bit;
bit 1126 fs/ubifs/journal.c int err, dlen, len, lnum, offs, bit, sz, sync = IS_SYNC(inode);
bit 1216 fs/ubifs/journal.c bit = new_size & (UBIFS_BLOCK_SIZE - 1);
bit 1217 fs/ubifs/journal.c blk = (new_size >> UBIFS_BLOCK_SHIFT) + (bit ? 1 : 0);
bit 1220 fs/ubifs/journal.c bit = old_size & (UBIFS_BLOCK_SIZE - 1);
bit 1221 fs/ubifs/journal.c blk = (old_size >> UBIFS_BLOCK_SHIFT) - (bit ? 0: 1);
bit 166 fs/udf/balloc.c unsigned long bit;
bit 188 fs/udf/balloc.c bit = block % (sb->s_blocksize << 3);
bit 193 fs/udf/balloc.c if (bit + count > (sb->s_blocksize << 3)) {
bit 194 fs/udf/balloc.c overflow = bit + count - (sb->s_blocksize << 3);
bit 203 fs/udf/balloc.c if (udf_set_bit(bit + i, bh->b_data)) {
bit 204 fs/udf/balloc.c udf_debug("bit %ld already set\n", bit + i);
bit 206 fs/udf/balloc.c ((char *)bh->b_data)[(bit + i) >> 3]);
bit 235 fs/udf/balloc.c int bit, block, block_group, group_start;
bit 259 fs/udf/balloc.c bit = block % (sb->s_blocksize << 3);
bit 261 fs/udf/balloc.c while (bit < (sb->s_blocksize << 3) && block_count > 0) {
bit 262 fs/udf/balloc.c if (!udf_test_bit(bit, bh->b_data))
bit 266 fs/udf/balloc.c else if (!udf_clear_bit(bit, bh->b_data)) {
bit 267 fs/udf/balloc.c udf_debug("bit already cleared for block %d\n", bit);
bit 273 fs/udf/balloc.c bit++;
bit 293 fs/udf/balloc.c int newbit, bit = 0, block, block_group, group_start;
bit 319 fs/udf/balloc.c bit = block % (sb->s_blocksize << 3);
bit 320 fs/udf/balloc.c if (udf_test_bit(bit, bh->b_data))
bit 323 fs/udf/balloc.c end_goal = (bit + 63) & ~63;
bit 324 fs/udf/balloc.c bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
bit 325 fs/udf/balloc.c if (bit < end_goal)
bit 328 fs/udf/balloc.c ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
bit 329 fs/udf/balloc.c sb->s_blocksize - ((bit + 7) >> 3));
bit 332 fs/udf/balloc.c bit = newbit;
bit 337 fs/udf/balloc.c sb->s_blocksize << 3, bit);
bit 339 fs/udf/balloc.c bit = newbit;
bit 358 fs/udf/balloc.c bit = (ptr - ((char *)bh->b_data)) << 3;
bit 362 fs/udf/balloc.c bit = udf_find_next_one_bit((char *)bh->b_data,
bit 365 fs/udf/balloc.c if (bit < sb->s_blocksize << 3)
bit 373 fs/udf/balloc.c if (bit < sb->s_blocksize << 3)
bit 376 fs/udf/balloc.c bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
bit 378 fs/udf/balloc.c if (bit >= sb->s_blocksize << 3) {
bit 385 fs/udf/balloc.c while (i < 7 && bit > (group_start << 3) &&
bit 386 fs/udf/balloc.c udf_test_bit(bit - 1, bh->b_data)) {
bit 388 fs/udf/balloc.c --bit;
bit 402 fs/udf/balloc.c newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
bit 405 fs/udf/balloc.c if (!udf_clear_bit(bit, bh->b_data)) {
bit 406 fs/udf/balloc.c udf_debug("bit already cleared for block %d\n", bit);
bit 45 fs/ufs/balloc.c unsigned cgno, bit, end_bit, bbase, blkmap, i;
bit 61 fs/ufs/balloc.c bit = ufs_dtogd(uspi, fragment);
bit 76 fs/ufs/balloc.c end_bit = bit + count;
bit 77 fs/ufs/balloc.c bbase = ufs_blknum (bit);
bit 80 fs/ufs/balloc.c for (i = bit; i < end_bit; i++) {
bit 147 fs/ufs/balloc.c unsigned overflow, cgno, bit, end_bit, i;
bit 169 fs/ufs/balloc.c bit = ufs_dtogd(uspi, fragment);
bit 174 fs/ufs/balloc.c end_bit = bit + count;
bit 176 fs/ufs/balloc.c overflow = bit + count - uspi->s_fpg;
bit 190 fs/ufs/balloc.c for (i = bit; i < end_bit; i += uspi->s_fpb) {
bit 65 fs/ufs/ialloc.c unsigned ino, cg, bit;
bit 84 fs/ufs/ialloc.c bit = ufs_inotocgoff (ino);
bit 103 fs/ufs/ialloc.c if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))
bit 106 fs/ufs/ialloc.c ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit);
bit 192 fs/ufs/ialloc.c unsigned cg, bit, i, j, start;
bit 261 fs/ufs/ialloc.c bit = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, uspi->s_ipg, start);
bit 262 fs/ufs/ialloc.c if (!(bit < uspi->s_ipg)) {
bit 263 fs/ufs/ialloc.c bit = ubh_find_first_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, start);
bit 264 fs/ufs/ialloc.c if (!(bit < start)) {
bit 271 fs/ufs/ialloc.c UFSD("start = %u, bit = %u, ipg = %u\n", start, bit, uspi->s_ipg);
bit 272 fs/ufs/ialloc.c if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))
bit 273 fs/ufs/ialloc.c ubh_setbit (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit);
bit 283 fs/ufs/ialloc.c if (bit + uspi->s_inopb > initediblk &&
bit 305 fs/ufs/ialloc.c inode->i_ino = cg * uspi->s_ipg + bit;
bit 354 fs/ufs/util.h ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
bit 387 fs/ufs/util.h (*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) |= (1 << ((bit) & 7)))
bit 390 fs/ufs/util.h (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) &= ~(1 << ((bit) & 7)))
bit 393 fs/ufs/util.h (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) & (1 << ((bit) & 7)))
bit 395 fs/ufs/util.h #define ubh_isclr(ubh,begin,bit) (!ubh_isset(ubh,begin,bit))
bit 426 fs/ufs/util.h unsigned bit, i;
bit 432 fs/ufs/util.h bit = 1 << (size & 7);
bit 434 fs/ufs/util.h if ((map & bit) == 0)
bit 437 fs/ufs/util.h bit >>= 1;
bit 440 fs/ufs/util.h bit = 1 << 7;
bit 786 fs/xfs/xfs_buf_item.c uint bit;
bit 817 fs/xfs/xfs_buf_item.c bit = first_bit & (uint)(NBWORD - 1);
bit 827 fs/xfs/xfs_buf_item.c if (bit) {
bit 828 fs/xfs/xfs_buf_item.c end_bit = MIN(bit + bits_to_set, (uint)NBWORD);
bit 829 fs/xfs/xfs_buf_item.c mask = ((1 << (end_bit - bit)) - 1) << bit;
bit 832 fs/xfs/xfs_buf_item.c bits_set = end_bit - bit;
bit 1776 fs/xfs/xfs_log_recover.c int bit;
bit 1800 fs/xfs/xfs_log_recover.c bit = 0;
bit 1816 fs/xfs/xfs_log_recover.c bit += nbits;
bit 1817 fs/xfs/xfs_log_recover.c bit = xfs_next_bit(data_map, map_size, bit);
bit 1823 fs/xfs/xfs_log_recover.c if (bit == -1) {
bit 1828 fs/xfs/xfs_log_recover.c bit);
bit 1830 fs/xfs/xfs_log_recover.c reg_buf_offset = bit << XFS_BLI_SHIFT;
bit 1887 fs/xfs/xfs_log_recover.c int bit;
bit 1899 fs/xfs/xfs_log_recover.c bit = 0;
bit 1902 fs/xfs/xfs_log_recover.c bit = xfs_next_bit(data_map, map_size, bit);
bit 1903 fs/xfs/xfs_log_recover.c if (bit == -1)
bit 1905 fs/xfs/xfs_log_recover.c nbits = xfs_contig_bits(data_map, map_size, bit);
bit 1910 fs/xfs/xfs_log_recover.c ((uint)bit << XFS_BLI_SHIFT)+(nbits<<XFS_BLI_SHIFT));
bit 1927 fs/xfs/xfs_log_recover.c (uint)bit << XFS_BLI_SHIFT), /* dest */
bit 1931 fs/xfs/xfs_log_recover.c bit += nbits;
bit 931 fs/xfs/xfs_rtalloc.c int bit; /* bit number in the word */
bit 959 fs/xfs/xfs_rtalloc.c bit = (int)(start & (XFS_NBWORD - 1));
bit 968 fs/xfs/xfs_rtalloc.c if (bit) {
bit 972 fs/xfs/xfs_rtalloc.c lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
bit 976 fs/xfs/xfs_rtalloc.c mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
bit 985 fs/xfs/xfs_rtalloc.c i = XFS_RTLOBIT(wdiff) - bit;
bit 990 fs/xfs/xfs_rtalloc.c i = lastbit - bit;
bit 1147 fs/xfs/xfs_rtalloc.c int bit; /* bit number in the word */
bit 1174 fs/xfs/xfs_rtalloc.c bit = (int)(start & (XFS_NBWORD - 1));
bit 1180 fs/xfs/xfs_rtalloc.c want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
bit 1185 fs/xfs/xfs_rtalloc.c if (bit < XFS_NBWORD - 1) {
bit 1190 fs/xfs/xfs_rtalloc.c firstbit = XFS_RTMAX((xfs_srtblock_t)(bit - len + 1), 0);
bit 1191 fs/xfs/xfs_rtalloc.c mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
bit 1202 fs/xfs/xfs_rtalloc.c i = bit - XFS_RTHIBIT(wdiff);
bit 1206 fs/xfs/xfs_rtalloc.c i = bit - firstbit + 1;
bit 1322 fs/xfs/xfs_rtalloc.c int bit; /* bit number in the word */
bit 1349 fs/xfs/xfs_rtalloc.c bit = (int)(start & (XFS_NBWORD - 1));
bit 1355 fs/xfs/xfs_rtalloc.c want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
bit 1360 fs/xfs/xfs_rtalloc.c if (bit) {
bit 1365 fs/xfs/xfs_rtalloc.c lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
bit 1366 fs/xfs/xfs_rtalloc.c mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
bit 1376 fs/xfs/xfs_rtalloc.c i = XFS_RTLOBIT(wdiff) - bit;
bit 1380 fs/xfs/xfs_rtalloc.c i = lastbit - bit;
bit 1635 fs/xfs/xfs_rtalloc.c int bit; /* bit number in the word */
bit 1663 fs/xfs/xfs_rtalloc.c bit = (int)(start & (XFS_NBWORD - 1));
bit 1672 fs/xfs/xfs_rtalloc.c if (bit) {
bit 1676 fs/xfs/xfs_rtalloc.c lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
bit 1677 fs/xfs/xfs_rtalloc.c mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
bit 1685 fs/xfs/xfs_rtalloc.c i = lastbit - bit;
bit 1759 fs/xfs/xfs_rtalloc.c bit = 0;
bit 55 include/acpi/acmacros.h #define ACPI_SET_BIT(target,bit) ((target) |= (bit))
bit 56 include/acpi/acmacros.h #define ACPI_CLEAR_BIT(target,bit) ((target) &= ~(bit))
bit 66 include/asm-arm/plat-s3c24xx/irq.h unsigned int bit = 1UL << (irqno - IRQ_S3CUART_RX0);
bit 70 include/asm-arm/plat-s3c24xx/irq.h __raw_writel(bit, S3C2410_SUBSRCPND);
bit 86 include/asm-arm/plat-s3c24xx/irq.h unsigned int bit = 1UL << (irqno - IRQ_S3CUART_RX0);
bit 88 include/asm-arm/plat-s3c24xx/irq.h __raw_writel(bit, S3C2410_SUBSRCPND);
bit 27 include/asm-cris/arch-v32/io.h int bit;
bit 50 include/asm-cris/arch-v32/io.h *iopin->port->data |= iopin->bit;
bit 52 include/asm-cris/arch-v32/io.h *iopin->port->data &= ~iopin->bit;
bit 64 include/asm-cris/arch-v32/io.h *iopin->port->oe &= ~iopin->bit;
bit 66 include/asm-cris/arch-v32/io.h *iopin->port->oe |= iopin->bit;
bit 73 include/asm-cris/arch-v32/io.h return ((*iopin->port->data_in & iopin->bit) ? 1 : 0);
bit 255 include/asm-frv/bitops.h int bit; \
bit 262 include/asm-frv/bitops.h : "=&r"(bit) \
bit 267 include/asm-frv/bitops.h bit; \
bit 285 include/asm-frv/bitops.h int bit, x, y;
bit 303 include/asm-frv/bitops.h : "=&r"(bit), "=r"(x), "=r"(y)
bit 307 include/asm-frv/bitops.h return bit;
bit 337 include/asm-frv/bitops.h int bit;
bit 338 include/asm-frv/bitops.h asm("scan %1,gr0,%0" : "=r"(bit) : "r"(x & -x));
bit 339 include/asm-frv/bitops.h return 31 - bit;
bit 350 include/asm-frv/bitops.h int bit;
bit 351 include/asm-frv/bitops.h asm("scan %1,gr0,%0" : "=r"(bit) : "r"(n));
bit 352 include/asm-frv/bitops.h return 31 - bit;
bit 367 include/asm-frv/bitops.h int bit, x, y;
bit 379 include/asm-frv/bitops.h : "=&r"(bit), "=r"(x), "=r"(y)
bit 383 include/asm-frv/bitops.h return bit;
bit 109 include/asm-frv/math-emu.h if (fp_debugprint & (1 << (bit))) \
bit 237 include/asm-frv/math-emu.h .macro printf bit=-1,string,nr=0,arg1,arg2,arg3,arg4,arg5
bit 264 include/asm-frv/math-emu.h .macro printx bit,fp
bit 206 include/asm-m68k/bitops.h int bit = offset & 31UL, res;
bit 211 include/asm-m68k/bitops.h if (bit) {
bit 212 include/asm-m68k/bitops.h unsigned long num = ~*p++ & (~0UL << bit);
bit 213 include/asm-m68k/bitops.h offset -= bit;
bit 253 include/asm-m68k/bitops.h int bit = offset & 31UL, res;
bit 258 include/asm-m68k/bitops.h if (bit) {
bit 259 include/asm-m68k/bitops.h unsigned long num = *p++ & (~0UL << bit);
bit 260 include/asm-m68k/bitops.h offset -= bit;
bit 397 include/asm-m68k/bitops.h int bit = offset & 31UL, res;
bit 402 include/asm-m68k/bitops.h if (bit) {
bit 404 include/asm-m68k/bitops.h for (res = bit; res < 32; res++)
bit 440 include/asm-m68k/bitops.h int bit = offset & 31UL, res;
bit 445 include/asm-m68k/bitops.h if (bit) {
bit 447 include/asm-m68k/bitops.h for (res = bit; res < 32; res++)
bit 109 include/asm-m68k/math-emu.h if (fp_debugprint & (1 << (bit))) \
bit 252 include/asm-m68k/math-emu.h .macro printf bit=-1,string,nr=0,arg1,arg2,arg3,arg4,arg5
bit 279 include/asm-m68k/math-emu.h .macro printx bit,fp
bit 167 include/asm-mn10300/bitops.h int bit;
bit 168 include/asm-mn10300/bitops.h asm("bsch %2,%0" : "=r"(bit) : "0"(0), "r"(x & -x));
bit 169 include/asm-mn10300/bitops.h return bit;
bit 179 include/asm-mn10300/bitops.h int bit;
bit 180 include/asm-mn10300/bitops.h asm("bsch %2,%0" : "=r"(bit) : "0"(0), "r"(n));
bit 181 include/asm-mn10300/bitops.h return bit;
bit 170 include/asm-x86/cpufeature.h test_bit(bit, (unsigned long *)((c)->x86_capability))
bit 173 include/asm-x86/cpufeature.h (__builtin_constant_p(bit) && \
bit 174 include/asm-x86/cpufeature.h ( (((bit)>>5)==0 && (1UL<<((bit)&31) & REQUIRED_MASK0)) || \
bit 175 include/asm-x86/cpufeature.h (((bit)>>5)==1 && (1UL<<((bit)&31) & REQUIRED_MASK1)) || \
bit 176 include/asm-x86/cpufeature.h (((bit)>>5)==2 && (1UL<<((bit)&31) & REQUIRED_MASK2)) || \
bit 177 include/asm-x86/cpufeature.h (((bit)>>5)==3 && (1UL<<((bit)&31) & REQUIRED_MASK3)) || \
bit 178 include/asm-x86/cpufeature.h (((bit)>>5)==4 && (1UL<<((bit)&31) & REQUIRED_MASK4)) || \
bit 179 include/asm-x86/cpufeature.h (((bit)>>5)==5 && (1UL<<((bit)&31) & REQUIRED_MASK5)) || \
bit 180 include/asm-x86/cpufeature.h (((bit)>>5)==6 && (1UL<<((bit)&31) & REQUIRED_MASK6)) || \
bit 181 include/asm-x86/cpufeature.h (((bit)>>5)==7 && (1UL<<((bit)&31) & REQUIRED_MASK7)) ) \
bit 183 include/asm-x86/cpufeature.h test_cpu_cap(c, bit))
bit 185 include/asm-x86/cpufeature.h #define boot_cpu_has(bit) cpu_has(&boot_cpu_data, bit)
bit 187 include/asm-x86/cpufeature.h #define set_cpu_cap(c, bit) set_bit(bit, (unsigned long *)((c)->x86_capability))
bit 188 include/asm-x86/cpufeature.h #define clear_cpu_cap(c, bit) clear_bit(bit, (unsigned long *)((c)->x86_capability))
bit 190 include/asm-x86/cpufeature.h clear_cpu_cap(&boot_cpu_data, bit); \
bit 191 include/asm-x86/cpufeature.h set_bit(bit, (unsigned long *)cleared_cpu_caps); \
bit 194 include/asm-x86/cpufeature.h set_cpu_cap(&boot_cpu_data, bit); \
bit 195 include/asm-x86/cpufeature.h clear_bit(bit, (unsigned long *)cleared_cpu_caps); \
bit 45 include/asm-x86/es7000/apic.h return physid_isset(bit, phys_cpu_present_map);
bit 97 include/asm-x86/mach-default/mach_apic.h return physid_isset(bit, phys_cpu_present_map);
bit 29 include/asm-x86/numaq/apic.h return physid_isset(bit, phys_cpu_present_map);
bit 129 include/asm-x86/pda.h : "dIr" (bit), "i" (pda_offset(field)) : "memory");\
bit 20 include/linux/bitops.h for ((bit) = find_first_bit((addr), (size)); \
bit 21 include/linux/bitops.h (bit) < (size); \
bit 22 include/linux/bitops.h (bit) = find_next_bit((addr), (size), (bit) + 1))
bit 85 include/linux/buffer_head.h set_bit(BH_##bit, &(bh)->b_state); \
bit 89 include/linux/buffer_head.h clear_bit(BH_##bit, &(bh)->b_state); \
bit 93 include/linux/buffer_head.h return test_bit(BH_##bit, &(bh)->b_state); \
bit 102 include/linux/buffer_head.h return test_and_set_bit(BH_##bit, &(bh)->b_state); \
bit 106 include/linux/buffer_head.h return test_and_clear_bit(BH_##bit, &(bh)->b_state); \
bit 99 include/linux/fs_enet_pd.h u8 bit;
bit 142 include/linux/hdlcdrv.h buf->shreg |= (!!bit) << 7;
bit 343 include/linux/hdlcdrv.h hdlcdrv_add_bitbuffer(&s->bitbuf_channel, bit);
bit 578 include/linux/hid.h struct hid_usage *usage, unsigned long **bit, int *max);
bit 581 include/linux/hid.h struct hid_usage *usage, unsigned long **bit, int *max);
bit 664 include/linux/hid.h *bit = input->absbit;
bit 668 include/linux/hid.h *bit = input->relbit;
bit 672 include/linux/hid.h *bit = input->keybit;
bit 676 include/linux/hid.h *bit = input->ledbit;
bit 692 include/linux/hid.h hid_map_usage(hidinput, usage, bit, max, type, c);
bit 693 include/linux/hid.h clear_bit(c, *bit);
bit 1648 include/linux/usb.h ((bit) << (ep)))
bit 78 include/linux/wait.h { .flags = word, .bit_nr = bit, }
bit 455 include/linux/wait.h .key = __WAIT_BIT_KEY_INITIALIZER(word, bit), \
bit 488 include/linux/wait.h if (!test_bit(bit, word))
bit 490 include/linux/wait.h return out_of_line_wait_on_bit(word, bit, action, mode);
bit 512 include/linux/wait.h if (!test_and_set_bit(bit, word))
bit 514 include/linux/wait.h return out_of_line_wait_on_bit_lock(word, bit, action, mode);
bit 66 include/sound/i2c.h struct snd_i2c_bit_ops *bit;
bit 289 include/sound/vx_core.h #define vx_check_isr(chip,mask,bit,time) snd_vx_check_reg_bit(chip, VX_ISR, mask, bit, time)
bit 290 include/sound/vx_core.h #define vx_wait_isr_bit(chip,bit) vx_check_isr(chip, bit, bit, 200)
bit 28 include/sound/wavefront.h of 22 bytes, corresponding to 16-bit alignment (as would have been
bit 394 kernel/auditfilter.c int bit = AUDIT_BITMASK_SIZE * 32 - i - 1;
bit 395 kernel/auditfilter.c __u32 *p = &entry->rule.mask[AUDIT_WORD(bit)];
bit 398 kernel/auditfilter.c if (!(*p & AUDIT_BIT(bit)))
bit 400 kernel/auditfilter.c *p &= ~AUDIT_BIT(bit);
bit 668 kernel/auditsc.c int bit = AUDIT_BIT(ctx->major);
bit 671 kernel/auditsc.c if ((e->rule.mask[word] & bit) == bit &&
bit 701 kernel/auditsc.c int bit = AUDIT_BIT(ctx->major);
bit 710 kernel/auditsc.c if ((e->rule.mask[word] & bit) == bit &&
bit 693 kernel/cgroup.c unsigned long bit = 1UL << i;
bit 695 kernel/cgroup.c if (!(bit & added_bits))
bit 713 kernel/cgroup.c unsigned long bit = 1UL << i;
bit 714 kernel/cgroup.c if (bit & added_bits) {
bit 726 kernel/cgroup.c } else if (bit & removed_bits) {
bit 736 kernel/cgroup.c } else if (bit & final_bits) {
bit 1179 kernel/cpuset.c set_bit(bit, &trialcs.flags);
bit 1181 kernel/cpuset.c clear_bit(bit, &trialcs.flags);
bit 554 kernel/lockdep.c int bit;
bit 561 kernel/lockdep.c for (bit = 0; bit < LOCK_USAGE_STATES; bit++) {
bit 562 kernel/lockdep.c if (class->usage_mask & (1 << bit)) {
bit 565 kernel/lockdep.c len += printk("%*s %s", depth, "", usage_str[bit]);
bit 567 kernel/lockdep.c print_stack_trace(class->usage_traces + bit, len);
bit 1891 kernel/lockdep.c find_usage_bit = bit;
bit 1910 kernel/lockdep.c find_usage_bit = bit;
bit 260 kernel/power/snapshot.c int bit;
bit 281 kernel/power/snapshot.c bm->cur.bit = 0;
bit 480 kernel/power/snapshot.c unsigned int bit;
bit 483 kernel/power/snapshot.c error = memory_bm_find_bit(bm, pfn, &addr, &bit);
bit 485 kernel/power/snapshot.c set_bit(bit, addr);
bit 491 kernel/power/snapshot.c unsigned int bit;
bit 494 kernel/power/snapshot.c error = memory_bm_find_bit(bm, pfn, &addr, &bit);
bit 496 kernel/power/snapshot.c set_bit(bit, addr);
bit 503 kernel/power/snapshot.c unsigned int bit;
bit 506 kernel/power/snapshot.c error = memory_bm_find_bit(bm, pfn, &addr, &bit);
bit 508 kernel/power/snapshot.c clear_bit(bit, addr);
bit 514 kernel/power/snapshot.c unsigned int bit;
bit 517 kernel/power/snapshot.c error = memory_bm_find_bit(bm, pfn, &addr, &bit);
bit 519 kernel/power/snapshot.c return test_bit(bit, addr);
bit 535 kernel/power/snapshot.c int bit;
bit 540 kernel/power/snapshot.c bit = bm->cur.bit;
bit 541 kernel/power/snapshot.c bit = find_next_bit(bb->data, bm_block_bits(bb), bit);
bit 542 kernel/power/snapshot.c if (bit < bm_block_bits(bb))
bit 547 kernel/power/snapshot.c bm->cur.bit = 0;
bit 553 kernel/power/snapshot.c bm->cur.bit = 0;
bit 560 kernel/power/snapshot.c bm->cur.bit = bit + 1;
bit 561 kernel/power/snapshot.c return bb->start_pfn + bit;
bit 179 kernel/wait.c wait_queue_head_t *wq = bit_waitqueue(word, bit);
bit 180 kernel/wait.c DEFINE_WAIT_BIT(wait, word, bit);
bit 207 kernel/wait.c wait_queue_head_t *wq = bit_waitqueue(word, bit);
bit 208 kernel/wait.c DEFINE_WAIT_BIT(wait, word, bit);
bit 216 kernel/wait.c struct wait_bit_key key = __WAIT_BIT_KEY_INITIALIZER(word, bit);
bit 241 kernel/wait.c __wake_up_bit(bit_waitqueue(word, bit), word, bit);
bit 249 kernel/wait.c unsigned long val = (unsigned long)word << shift | bit;
bit 293 lib/bitmap.c int i, word, bit, len = 0;
bit 307 lib/bitmap.c bit = i % BITS_PER_LONG;
bit 308 lib/bitmap.c val = (maskp[word] >> bit) & chunkmask;
bit 85 lib/genalloc.c int bit, end_bit;
bit 94 lib/genalloc.c bit = find_next_bit(chunk->bits, end_bit, 0);
bit 95 lib/genalloc.c BUG_ON(bit < end_bit);
bit 118 lib/genalloc.c int nbits, bit, start_bit, end_bit;
bit 133 lib/genalloc.c bit = -1;
bit 134 lib/genalloc.c while (bit + 1 < end_bit) {
bit 135 lib/genalloc.c bit = find_next_zero_bit(chunk->bits, end_bit, bit + 1);
bit 136 lib/genalloc.c if (bit >= end_bit)
bit 139 lib/genalloc.c start_bit = bit;
bit 141 lib/genalloc.c bit = find_next_bit(chunk->bits, bit + nbits,
bit 142 lib/genalloc.c bit + 1);
bit 143 lib/genalloc.c if (bit - start_bit < nbits)
bit 176 lib/genalloc.c int bit, nbits;
bit 187 lib/genalloc.c bit = (addr - chunk->start_addr) >> order;
bit 189 lib/genalloc.c __clear_bit(bit++, chunk->bits);
bit 262 mm/backing-dev.c enum bdi_state bit;
bit 265 mm/backing-dev.c bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested;
bit 266 mm/backing-dev.c clear_bit(bit, &bdi->state);
bit 275 mm/backing-dev.c enum bdi_state bit;
bit 277 mm/backing-dev.c bit = (rw == WRITE) ? BDI_write_congested : BDI_read_congested;
bit 278 mm/backing-dev.c set_bit(bit, &bdi->state);
bit 538 mm/filemap.c __wake_up_bit(page_waitqueue(page), &page->flags, bit);
bit 226 mm/vmalloc.c int bit = fls(size);
bit 228 mm/vmalloc.c if (bit > IOREMAP_MAX_ORDER)
bit 229 mm/vmalloc.c bit = IOREMAP_MAX_ORDER;
bit 230 mm/vmalloc.c else if (bit < PAGE_SHIFT)
bit 231 mm/vmalloc.c bit = PAGE_SHIFT;
bit 233 mm/vmalloc.c align = 1ul << bit;
bit 432 net/core/sock.c sock_set_flag(sk, bit);
bit 434 net/core/sock.c sock_reset_flag(sk, bit);
bit 191 net/ipv4/cipso_ipv4.c byte_spot = bit / 8;
bit 192 net/ipv4/cipso_ipv4.c bitmask = 0x80 >> (bit % 8);
bit 558 net/ipv4/netfilter/ipt_CLUSTERIP.c unsigned int bit; /* current bit */
bit 582 net/ipv4/netfilter/ipt_CLUSTERIP.c idx->bit = ffs(local_nodes);
bit 584 net/ipv4/netfilter/ipt_CLUSTERIP.c clear_bit(idx->bit - 1, &idx->val);
bit 598 net/ipv4/netfilter/ipt_CLUSTERIP.c idx->bit = ffs(idx->val);
bit 599 net/ipv4/netfilter/ipt_CLUSTERIP.c clear_bit(idx->bit - 1, &idx->val);
bit 615 net/ipv4/netfilter/ipt_CLUSTERIP.c seq_printf(s, "%u", idx->bit);
bit 422 net/ipv6/ip6_fib.c int bit;
bit 508 net/ipv6/ip6_fib.c bit = __ipv6_addr_diff(addr, &key->addr, addrlen);
bit 515 net/ipv6/ip6_fib.c if (plen > bit) {
bit 535 net/ipv6/ip6_fib.c in->fn_bit = bit;
bit 556 net/ipv6/ip6_fib.c if (addr_bit_set(addr, bit)) {
bit 99 net/netfilter/nf_conntrack_h323_asn1.c unsigned int bit;
bit 103 net/netfilter/nf_conntrack_h323_asn1.c #define INC_BIT(bs) if((++(bs)->bit)>7){(bs)->cur++;(bs)->bit=0;}
bit 104 net/netfilter/nf_conntrack_h323_asn1.c #define INC_BITS(bs,b) if(((bs)->bit+=(b))>7){(bs)->cur+=(bs)->bit>>3;(bs)->bit&=7;}
bit 105 net/netfilter/nf_conntrack_h323_asn1.c #define BYTE_ALIGN(bs) if((bs)->bit){(bs)->cur++;(bs)->bit=0;}
bit 171 net/netfilter/nf_conntrack_h323_asn1.c unsigned int b = (*bs->cur) & (0x80 >> bs->bit);
bit 184 net/netfilter/nf_conntrack_h323_asn1.c v = (*bs->cur) & (0xffU >> bs->bit);
bit 185 net/netfilter/nf_conntrack_h323_asn1.c l = b + bs->bit;
bit 189 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = l;
bit 192 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 198 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = l - 8;
bit 213 net/netfilter/nf_conntrack_h323_asn1.c l = bs->bit + b;
bit 216 net/netfilter/nf_conntrack_h323_asn1.c v = (unsigned int)(*bs->cur) << (bs->bit + 24);
bit 217 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = l;
bit 219 net/netfilter/nf_conntrack_h323_asn1.c v = (unsigned int)(*bs->cur++) << (bs->bit + 24);
bit 220 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 228 net/netfilter/nf_conntrack_h323_asn1.c v <<= bs->bit;
bit 230 net/netfilter/nf_conntrack_h323_asn1.c v <<= bs->bit;
bit 231 net/netfilter/nf_conntrack_h323_asn1.c v |= (*bs->cur) >> (8 - bs->bit);
bit 234 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = l & 0x7;
bit 392 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = len & 7;
bit 546 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 603 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 680 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 760 net/netfilter/nf_conntrack_h323_asn1.c bs->bit = 0;
bit 779 net/netfilter/nf_conntrack_h323_asn1.c bs.bit = 0;
bit 797 net/netfilter/nf_conntrack_h323_asn1.c bs.bit = 0;
bit 815 net/netfilter/nf_conntrack_h323_asn1.c bs.bit = 0;
bit 330 net/netlabel/netlabel_kapi.c bit >= (iter->startbit + NETLBL_CATMAP_SIZE))
bit 332 net/netlabel/netlabel_kapi.c if (bit >= (iter->startbit + NETLBL_CATMAP_SIZE)) {
bit 337 net/netlabel/netlabel_kapi.c iter->startbit = bit & ~(NETLBL_CATMAP_SIZE - 1);
bit 341 net/netlabel/netlabel_kapi.c node_idx = (bit - iter->startbit) / NETLBL_CATMAP_MAPSIZE;
bit 342 net/netlabel/netlabel_kapi.c node_bit = bit - iter->startbit - (NETLBL_CATMAP_MAPSIZE * node_idx);
bit 279 scripts/pnmtologo.c unsigned char val, bit;
bit 293 scripts/pnmtologo.c for (val = 0, bit = 0x80; bit && j < logo_width; j++, bit >>= 1)
bit 295 scripts/pnmtologo.c val |= bit;
bit 248 security/selinux/ss/ebitmap.c if (e->highbit < bit)
bit 252 security/selinux/ss/ebitmap.c while (n && (n->startbit <= bit)) {
bit 253 security/selinux/ss/ebitmap.c if ((n->startbit + EBITMAP_SIZE) > bit)
bit 254 security/selinux/ss/ebitmap.c return ebitmap_node_get_bit(n, bit);
bit 267 security/selinux/ss/ebitmap.c while (n && n->startbit <= bit) {
bit 268 security/selinux/ss/ebitmap.c if ((n->startbit + EBITMAP_SIZE) > bit) {
bit 270 security/selinux/ss/ebitmap.c ebitmap_node_set_bit(n, bit);
bit 274 security/selinux/ss/ebitmap.c ebitmap_node_clr_bit(n, bit);
bit 311 security/selinux/ss/ebitmap.c new->startbit = bit - (bit % EBITMAP_SIZE);
bit 312 security/selinux/ss/ebitmap.c ebitmap_node_set_bit(new, bit);
bit 65 security/selinux/ss/ebitmap.h ofs = find_next_bit((*n)->maps, EBITMAP_SIZE, bit - (*n)->startbit + 1);
bit 78 security/selinux/ss/ebitmap.h (((bit) - (node)->startbit) / EBITMAP_UNIT_SIZE)
bit 80 security/selinux/ss/ebitmap.h (((bit) - (node)->startbit) % EBITMAP_UNIT_SIZE)
bit 85 security/selinux/ss/ebitmap.h unsigned int index = EBITMAP_NODE_INDEX(n, bit);
bit 86 security/selinux/ss/ebitmap.h unsigned int ofs = EBITMAP_NODE_OFFSET(n, bit);
bit 97 security/selinux/ss/ebitmap.h unsigned int index = EBITMAP_NODE_INDEX(n, bit);
bit 98 security/selinux/ss/ebitmap.h unsigned int ofs = EBITMAP_NODE_OFFSET(n, bit);
bit 107 security/selinux/ss/ebitmap.h unsigned int index = EBITMAP_NODE_INDEX(n, bit);
bit 108 security/selinux/ss/ebitmap.h unsigned int ofs = EBITMAP_NODE_OFFSET(n, bit);
bit 115 security/selinux/ss/ebitmap.h for (bit = ebitmap_start_positive(e, &n); \
bit 116 security/selinux/ss/ebitmap.h bit < ebitmap_length(e); \
bit 117 security/selinux/ss/ebitmap.h bit = ebitmap_next_positive(e, &n, bit)) \
bit 1523 security/selinux/ss/policydb.c unsigned long bit;
bit 1533 security/selinux/ss/policydb.c ebitmap_for_each_positive_bit(&user->roles, node, bit) {
bit 1534 security/selinux/ss/policydb.c if (ebitmap_get_bit(&upper->roles, bit))
bit 1541 security/selinux/ss/policydb.c p->p_role_val_to_name[bit],
bit 1560 security/selinux/ss/policydb.c unsigned long bit;
bit 1570 security/selinux/ss/policydb.c ebitmap_for_each_positive_bit(&role->types, node, bit) {
bit 1571 security/selinux/ss/policydb.c if (ebitmap_get_bit(&upper->types, bit))
bit 1578 security/selinux/ss/policydb.c p->p_type_val_to_name[bit],
bit 147 sound/aoa/core/snd-aoa-gpio-feature.c rt->implementation_private &= ~(1<<bit); \
bit 148 sound/aoa/core/snd-aoa-gpio-feature.c rt->implementation_private |= (!!on << bit); \
bit 153 sound/aoa/core/snd-aoa-gpio-feature.c return (rt->implementation_private>>bit)&1; \
bit 24 sound/aoa/core/snd-aoa-gpio-pmf.c rt->implementation_private &= ~(1<<bit); \
bit 25 sound/aoa/core/snd-aoa-gpio-pmf.c rt->implementation_private |= (!!on << bit); \
bit 30 sound/aoa/core/snd-aoa-gpio-pmf.c return (rt->implementation_private>>bit)&1; \
bit 64 sound/drivers/vx/vx_core.c if ((snd_vx_inb(chip, reg) & mask) == bit)
bit 60 sound/i2c/cs8427.c int bit;
bit 62 sound/i2c/cs8427.c for (bit = 0; bit < 8; bit++) {
bit 171 sound/i2c/i2c.c if (bus->hw_ops.bit->start)
bit 172 sound/i2c/i2c.c bus->hw_ops.bit->start(bus);
bit 177 sound/i2c/i2c.c if (bus->hw_ops.bit->stop)
bit 178 sound/i2c/i2c.c bus->hw_ops.bit->stop(bus);
bit 183 sound/i2c/i2c.c if (bus->hw_ops.bit->direction)
bit 184 sound/i2c/i2c.c bus->hw_ops.bit->direction(bus, clock, data);
bit 189 sound/i2c/i2c.c bus->hw_ops.bit->setlines(bus, clock, data);
bit 195 sound/i2c/i2c.c if (bus->hw_ops.bit->getclock)
bit 196 sound/i2c/i2c.c return bus->hw_ops.bit->getclock(bus);
bit 203 sound/i2c/i2c.c return bus->hw_ops.bit->getdata(bus, ack);
bit 210 sound/i2c/other/ak4114.c unsigned char bit = (kcontrol->private_value >> 8) & 0xff;
bit 213 sound/i2c/other/ak4114.c ucontrol->value.integer.value[0] = ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv;
bit 190 sound/i2c/other/ak4117.c unsigned char bit = (kcontrol->private_value >> 8) & 0xff;
bit 193 sound/i2c/other/ak4117.c ucontrol->value.integer.value[0] = ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv;
bit 245 sound/isa/gus/interwave.c bus->hw_ops.bit = &snd_interwave_i2c_bit_ops;
bit 158 sound/mips/hal2.c hal2_write((hal2_read(®s->idr0) & 0xffff) | bit, ®s->idr0);
bit 172 sound/mips/hal2.c hal2_write((hal2_read(®s->idr0) & 0xffff) & ~bit, ®s->idr0);
bit 1117 sound/pci/ac97/ac97_codec.c mask = 1 << bit;
bit 2030 sound/pci/azt3328.c outb(val & ~(1 << bit), reg);
bit 2033 sound/pci/azt3328.c outb(val|(1 << bit), reg);
bit 2039 sound/pci/azt3328.c reg, bit, val, valoff, valon
bit 479 sound/pci/ca0106/ca0106_mixer.c unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
bit 481 sound/pci/ca0106/ca0106_mixer.c ucontrol->value.integer.value[0] = !(emu->spi_dac_reg[reg] & bit);
bit 490 sound/pci/ca0106/ca0106_mixer.c unsigned int bit = kcontrol->private_value & SPI_REG_MASK;
bit 493 sound/pci/ca0106/ca0106_mixer.c ret = emu->spi_dac_reg[reg] & bit;
bit 497 sound/pci/ca0106/ca0106_mixer.c emu->spi_dac_reg[reg] &= ~bit;
bit 501 sound/pci/ca0106/ca0106_mixer.c emu->spi_dac_reg[reg] |= bit;
bit 607 sound/pci/ca0106/ca0106_mixer.c .private_value = (reg<<SPI_REG_SHIFT) | (bit) \
bit 1764 sound/pci/echoaudio/echoaudio.c int detected, clocks, bit, src;
bit 1777 sound/pci/echoaudio/echoaudio.c for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
bit 1778 sound/pci/echoaudio/echoaudio.c if (detected & (1 << bit))
bit 1780 sound/pci/echoaudio/echoaudio.c if (bit == chip->clock_source_list[src]) {
bit 567 sound/pci/emu10k1/emu10k1_main.c unsigned int bit;
bit 575 sound/pci/emu10k1/emu10k1_main.c for (bit = (1 << 15); bit; bit >>= 1) {
bit 580 sound/pci/emu10k1/emu10k1_main.c if (gain & bit)
bit 78 sound/pci/ice1712/ews.c int bit;
bit 84 sound/pci/ice1712/ews.c bit = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_DATA ? 1 : 0;
bit 89 sound/pci/ice1712/ews.c return bit;
bit 464 sound/pci/ice1712/ews.c ice->i2c->hw_ops.bit = &snd_ice1712_ewx_cs8427_bit_ops;
bit 148 sound/pci/ice1712/ice1724.c if ((inb(ICEMT1724(ice, AC97_CMD)) & bit) == 0)
bit 224 sound/pci/ice1712/pontis.c int bit = kcontrol->private_value;
bit 227 sound/pci/ice1712/pontis.c ucontrol->value.integer.value[0] = (wm_get(ice, WM_ADC_MUX) & (1 << bit)) ? 1 : 0;
bit 235 sound/pci/ice1712/pontis.c int bit = kcontrol->private_value;
bit 242 sound/pci/ice1712/pontis.c nval |= (1 << bit);
bit 244 sound/pci/ice1712/pontis.c nval &= ~(1 << bit);
bit 332 sound/pci/ice1712/pontis.c tmp |= bit;
bit 334 sound/pci/ice1712/pontis.c tmp &= ~bit;
bit 161 sound/pci/ice1712/prodigy_hifi.c tmp |= bit;
bit 163 sound/pci/ice1712/prodigy_hifi.c tmp &= ~bit;
bit 670 sound/pci/ice1712/prodigy_hifi.c int bit = kcontrol->private_value;
bit 674 sound/pci/ice1712/prodigy_hifi.c (wm_get(ice, WM_ADC_MUX) & (1 << bit)) ? 1 : 0;
bit 683 sound/pci/ice1712/prodigy_hifi.c int bit = kcontrol->private_value;
bit 690 sound/pci/ice1712/prodigy_hifi.c nval |= (1 << bit);
bit 692 sound/pci/ice1712/prodigy_hifi.c nval &= ~(1 << bit);
bit 142 sound/pci/ice1712/revo.c int bit;
bit 146 sound/pci/ice1712/revo.c bit = snd_ice1712_gpio_read_bits(ice, VT1724_REVO_I2C_DATA) ? 1 : 0;
bit 147 sound/pci/ice1712/revo.c return bit;
bit 175 sound/pci/ice1712/revo.c ice->i2c->hw_ops.bit = &revo51_bit_ops;
bit 626 sound/pci/oxygen/oxygen_lib.c return bitmap[bit / 32] & (1 << (bit & 31));
bit 463 sound/pci/oxygen/oxygen_mixer.c u8 bit = ctl->private_value;
bit 467 sound/pci/oxygen/oxygen_mixer.c !!invert ^ !!(oxygen_read8(chip, OXYGEN_ADC_MONITOR) & bit);
bit 475 sound/pci/oxygen/oxygen_mixer.c u8 bit = ctl->private_value;
bit 483 sound/pci/oxygen/oxygen_mixer.c newreg = oldreg | bit;
bit 485 sound/pci/oxygen/oxygen_mixer.c newreg = oldreg & ~bit;
bit 690 sound/pci/oxygen/virtuoso.c u16 bit = ctl->private_value;
bit 693 sound/pci/oxygen/virtuoso.c !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit);
bit 701 sound/pci/oxygen/virtuoso.c u16 bit = ctl->private_value;
bit 708 sound/pci/oxygen/virtuoso.c new_bits = old_bits | bit;
bit 710 sound/pci/oxygen/virtuoso.c new_bits = old_bits & ~bit;
bit 133 sound/pci/pcxhr/pcxhr_core.c if ((*read & mask) == bit) {
bit 289 sound/pci/sis7019.c int bit;
bit 292 sound/pci/sis7019.c bit = __ffs(status);
bit 293 sound/pci/sis7019.c status >>= bit + 1;
bit 294 sound/pci/sis7019.c voice += bit;
bit 964 sound/soc/codecs/tlv320aic3x.c u8 bit = gpio ? 3: 0;
bit 965 sound/soc/codecs/tlv320aic3x.c u8 val = aic3x_read_reg_cache(codec, reg) & ~(1 << bit);
bit 966 sound/soc/codecs/tlv320aic3x.c aic3x_write(codec, reg, val | (!!state << bit));
bit 973 sound/soc/codecs/tlv320aic3x.c u8 val, bit = gpio ? 2: 1;
bit 976 sound/soc/codecs/tlv320aic3x.c return (val >> bit) & 1;
bit 796 sound/synth/emux/soundfont.c int s, low, bit;
bit 800 sound/synth/emux/soundfont.c for (bit = 0; ! (amount & 0x80000000L); bit++)
bit 808 sound/synth/emux/soundfont.c v += (24 - bit) * ratio;