Lines Matching +full:64 +full:- +full:byte
1 // SPDX-License-Identifier: GPL-2.0
17 unsigned word_bits = 64 - high_bit_offset; in bch2_bkey_packed_to_binary_text()
29 if (nr_key_bits < 64) { in bch2_bkey_packed_to_binary_text()
30 v >>= 64 - nr_key_bits; in bch2_bkey_packed_to_binary_text()
33 next_key_bits -= 64; in bch2_bkey_packed_to_binary_text()
45 word_bits = 64; in bch2_bkey_packed_to_binary_text()
61 BUG_ON(packed->u64s < bkeyp_key_u64s(format, packed)); in bch2_bkey_pack_verify()
69 format->key_u64s, in bch2_bkey_pack_verify()
70 format->bits_per_field[0], in bch2_bkey_pack_verify()
71 format->bits_per_field[1], in bch2_bkey_pack_verify()
72 format->bits_per_field[2], in bch2_bkey_pack_verify()
73 format->bits_per_field[3], in bch2_bkey_pack_verify()
74 format->bits_per_field[4]); in bch2_bkey_pack_verify()
119 .bits = 64 - high_bit_offset, in pack_state_init()
129 EBUG_ON(state->p < k->_data); in pack_state_finish()
130 EBUG_ON(state->p >= (u64 *) k->_data + state->format->key_u64s); in pack_state_finish()
132 *state->p = state->w; in pack_state_finish()
150 .bits = 64 - high_bit_offset, in unpack_state_init()
159 unsigned bits = state->format->bits_per_field[field]; in get_inc_field()
160 u64 v = 0, offset = le64_to_cpu(state->format->field_offset[field]); in get_inc_field()
162 if (bits >= state->bits) { in get_inc_field()
163 v = state->w >> (64 - bits); in get_inc_field()
164 bits -= state->bits; in get_inc_field()
166 state->p = next_word(state->p); in get_inc_field()
167 state->w = *state->p; in get_inc_field()
168 state->bits = 64; in get_inc_field()
171 /* avoid shift by 64 if bits is 0 - bits is never 64 here: */ in get_inc_field()
172 v |= (state->w >> 1) >> (63 - bits); in get_inc_field()
173 state->w <<= bits; in get_inc_field()
174 state->bits -= bits; in get_inc_field()
182 unsigned bits = state->format->bits_per_field[field]; in __set_inc_field()
185 if (bits > state->bits) { in __set_inc_field()
186 bits -= state->bits; in __set_inc_field()
187 /* avoid shift by 64 if bits is 64 - bits is never 0 here: */ in __set_inc_field()
188 state->w |= (v >> 1) >> (bits - 1); in __set_inc_field()
190 *state->p = state->w; in __set_inc_field()
191 state->p = next_word(state->p); in __set_inc_field()
192 state->w = 0; in __set_inc_field()
193 state->bits = 64; in __set_inc_field()
196 state->bits -= bits; in __set_inc_field()
197 state->w |= v << state->bits; in __set_inc_field()
204 unsigned bits = state->format->bits_per_field[field]; in set_inc_field()
205 u64 offset = le64_to_cpu(state->format->field_offset[field]); in set_inc_field()
210 v -= offset; in set_inc_field()
220 * Note: does NOT set out->format (we don't know what it should be here!)
222 * Also: doesn't work on extents - it doesn't preserve the invariant that
232 u64 *w = out->_data; in bch2_bkey_transform_key()
242 EBUG_ON(in->u64s - in_f->key_u64s + out_f->key_u64s > U8_MAX); in bch2_bkey_transform_key()
245 out->u64s = out_f->key_u64s + in->u64s - in_f->key_u64s; in bch2_bkey_transform_key()
246 out->needs_whiteout = in->needs_whiteout; in bch2_bkey_transform_key()
247 out->type = in->type; in bch2_bkey_transform_key()
260 memcpy_u64s((u64 *) out + out_f->key_u64s, in bch2_bkey_transform()
261 (u64 *) in + in_f->key_u64s, in bch2_bkey_transform()
262 (in->u64s - in_f->key_u64s)); in bch2_bkey_transform()
272 EBUG_ON(format->nr_fields != BKEY_NR_FIELDS); in __bch2_bkey_unpack_key()
273 EBUG_ON(in->u64s < format->key_u64s); in __bch2_bkey_unpack_key()
274 EBUG_ON(in->format != KEY_FORMAT_LOCAL_BTREE); in __bch2_bkey_unpack_key()
275 EBUG_ON(in->u64s - format->key_u64s + BKEY_U64s > U8_MAX); in __bch2_bkey_unpack_key()
277 out.u64s = BKEY_U64s + in->u64s - format->key_u64s; in __bch2_bkey_unpack_key()
279 out.needs_whiteout = in->needs_whiteout; in __bch2_bkey_unpack_key()
280 out.type = in->type; in __bch2_bkey_unpack_key()
297 EBUG_ON(format->nr_fields != BKEY_NR_FIELDS); in __bkey_unpack_pos()
298 EBUG_ON(in->u64s < format->key_u64s); in __bkey_unpack_pos()
299 EBUG_ON(in->format != KEY_FORMAT_LOCAL_BTREE); in __bkey_unpack_pos()
310 * bch2_bkey_pack_key -- pack just the key, not the value
321 u64 *w = out->_data; in bch2_bkey_pack_key()
324 EBUG_ON(format->nr_fields != BKEY_NR_FIELDS); in bch2_bkey_pack_key()
325 EBUG_ON(in->format != KEY_FORMAT_CURRENT); in bch2_bkey_pack_key()
329 #define x(id, field) if (!set_inc_field(&state, id, in->field)) return false; in bch2_bkey_pack_key()
333 out->u64s = format->key_u64s + in->u64s - BKEY_U64s; in bch2_bkey_pack_key()
334 out->format = KEY_FORMAT_LOCAL_BTREE; in bch2_bkey_pack_key()
335 out->needs_whiteout = in->needs_whiteout; in bch2_bkey_pack_key()
336 out->type = in->type; in bch2_bkey_pack_key()
343 * bch2_bkey_unpack -- unpack the key and the value
351 __bkey_unpack_key(b, &dst->k, src); in bch2_bkey_unpack()
353 memcpy_u64s(&dst->v, in bch2_bkey_unpack()
354 bkeyp_val(&b->format, src), in bch2_bkey_unpack()
355 bkeyp_val_u64s(&b->format, src)); in bch2_bkey_unpack()
359 * bch2_bkey_pack -- pack the key and the value
371 if (!bch2_bkey_pack_key(&tmp, &src->k, format)) in bch2_bkey_pack()
374 memmove_u64s((u64 *) dst + format->key_u64s, in bch2_bkey_pack()
375 &src->v, in bch2_bkey_pack()
376 bkey_val_u64s(&src->k)); in bch2_bkey_pack()
377 memcpy_u64s_small(dst, &tmp, format->key_u64s); in bch2_bkey_pack()
385 unsigned bits = state->format->bits_per_field[field]; in set_inc_field_lossy()
386 u64 offset = le64_to_cpu(state->format->field_offset[field]); in set_inc_field_lossy()
390 v -= offset; in set_inc_field_lossy()
406 const struct bkey_format *f = &b->format; in bkey_packed_successor()
407 unsigned nr_key_bits = b->nr_key_bits; in bkey_packed_successor()
411 EBUG_ON(b->nr_key_bits != bkey_format_key_bits(f)); in bkey_packed_successor()
418 first_bit = high_bit_offset + nr_key_bits - 1; in bkey_packed_successor()
420 offset = 63 - (first_bit & 63); in bkey_packed_successor()
423 unsigned bits = min(64 - offset, nr_key_bits); in bkey_packed_successor()
424 u64 mask = (~0ULL >> (64 - bits)) << offset; in bkey_packed_successor()
434 nr_key_bits -= bits; in bkey_packed_successor()
443 for (unsigned i = 0; i < f->nr_fields; i++) { in bkey_format_has_too_big_fields()
445 u64 unpacked_max = ~((~0ULL << 1) << (unpacked_bits - 1)); in bkey_format_has_too_big_fields()
446 u64 packed_max = f->bits_per_field[i] in bkey_format_has_too_big_fields()
447 ? ~((~0ULL << 1) << (f->bits_per_field[i] - 1)) in bkey_format_has_too_big_fields()
449 u64 field_offset = le64_to_cpu(f->field_offset[i]); in bkey_format_has_too_big_fields()
464 * able to compare against the keys in the auxiliary search tree - and it's
472 const struct bkey_format *f = &b->format; in bch2_bkey_pack_pos_lossy()
474 u64 *w = out->_data; in bch2_bkey_pack_pos_lossy()
482 * bch2_bkey_pack_key() will write to all of f->key_u64s, minus the 3 in bch2_bkey_pack_pos_lossy()
483 * byte header, but pack_pos() won't if the len/version fields are big in bch2_bkey_pack_pos_lossy()
484 * enough - we need to make sure to zero them out: in bch2_bkey_pack_pos_lossy()
486 for (i = 0; i < f->key_u64s; i++) in bch2_bkey_pack_pos_lossy()
490 le64_to_cpu(f->field_offset[BKEY_FIELD_SNAPSHOT]))) { in bch2_bkey_pack_pos_lossy()
491 if (!in.offset-- && in bch2_bkey_pack_pos_lossy()
492 !in.inode--) in bch2_bkey_pack_pos_lossy()
499 le64_to_cpu(f->field_offset[BKEY_FIELD_OFFSET]))) { in bch2_bkey_pack_pos_lossy()
500 if (!in.inode--) in bch2_bkey_pack_pos_lossy()
508 le64_to_cpu(f->field_offset[BKEY_FIELD_INODE]))) in bch2_bkey_pack_pos_lossy()
526 out->u64s = f->key_u64s; in bch2_bkey_pack_pos_lossy()
527 out->format = KEY_FORMAT_LOCAL_BTREE; in bch2_bkey_pack_pos_lossy()
528 out->type = KEY_TYPE_deleted; in bch2_bkey_pack_pos_lossy()
550 for (i = 0; i < ARRAY_SIZE(s->field_min); i++) in bch2_bkey_format_init()
551 s->field_min[i] = U64_MAX; in bch2_bkey_format_init()
553 for (i = 0; i < ARRAY_SIZE(s->field_max); i++) in bch2_bkey_format_init()
554 s->field_max[i] = 0; in bch2_bkey_format_init()
557 s->field_min[BKEY_FIELD_SIZE] = 0; in bch2_bkey_format_init()
578 u64 unpacked_max = ~((~0ULL << 1) << (unpacked_bits - 1)); in set_format_field()
582 offset = bits == unpacked_bits ? 0 : min(offset, unpacked_max - ((1ULL << bits) - 1)); in set_format_field()
584 f->bits_per_field[i] = bits; in set_format_field()
585 f->field_offset[i] = cpu_to_le64(offset); in set_format_field()
595 for (i = 0; i < ARRAY_SIZE(s->field_min); i++) { in bch2_bkey_format_done()
596 s->field_min[i] = min(s->field_min[i], s->field_max[i]); in bch2_bkey_format_done()
599 fls64(s->field_max[i] - s->field_min[i]), in bch2_bkey_format_done()
600 s->field_min[i]); in bch2_bkey_format_done()
607 unsigned b = min(4U, 32U - ret.bits_per_field[BKEY_FIELD_SIZE]); in bch2_bkey_format_done()
613 ret.key_u64s = DIV_ROUND_UP(bits, 64); in bch2_bkey_format_done()
615 /* if we have enough spare bits, round fields up to nearest byte */ in bch2_bkey_format_done()
616 bits = ret.key_u64s * 64 - bits; in bch2_bkey_format_done()
619 unsigned r = round_up(ret.bits_per_field[i], 8) - in bch2_bkey_format_done()
626 bits -= r; in bch2_bkey_format_done()
648 if (f->nr_fields != BKEY_NR_FIELDS) { in bch2_bkey_format_invalid()
650 f->nr_fields, BKEY_NR_FIELDS); in bch2_bkey_format_invalid()
651 return -BCH_ERR_invalid; in bch2_bkey_format_invalid()
658 for (unsigned i = 0; i < f->nr_fields; i++) { in bch2_bkey_format_invalid()
661 u64 unpacked_max = ~((~0ULL << 1) << (unpacked_bits - 1)); in bch2_bkey_format_invalid()
662 unsigned packed_bits = min(64, f->bits_per_field[i]); in bch2_bkey_format_invalid()
664 ? ~((~0ULL << 1) << (packed_bits - 1)) in bch2_bkey_format_invalid()
668 i, packed_max, le64_to_cpu(f->field_offset[i]), unpacked_max); in bch2_bkey_format_invalid()
669 return -BCH_ERR_invalid; in bch2_bkey_format_invalid()
672 bits += f->bits_per_field[i]; in bch2_bkey_format_invalid()
675 if (f->key_u64s != DIV_ROUND_UP(bits, 64)) { in bch2_bkey_format_invalid()
677 f->key_u64s, DIV_ROUND_UP(bits, 64)); in bch2_bkey_format_invalid()
678 return -BCH_ERR_invalid; in bch2_bkey_format_invalid()
686 prt_printf(out, "u64s %u fields ", f->key_u64s); in bch2_bkey_format_to_text()
688 for (unsigned i = 0; i < ARRAY_SIZE(f->bits_per_field); i++) { in bch2_bkey_format_to_text()
692 f->bits_per_field[i], in bch2_bkey_format_to_text()
693 le64_to_cpu(f->field_offset[i])); in bch2_bkey_format_to_text()
699 * Bits are indexed from 0 - return is [0, nr_key_bits)
706 const u64 *l = high_word(&b->format, l_k); in bch2_bkey_greatest_differing_bit()
707 const u64 *r = high_word(&b->format, r_k); in bch2_bkey_greatest_differing_bit()
708 unsigned nr_key_bits = b->nr_key_bits; in bch2_bkey_greatest_differing_bit()
709 unsigned word_bits = 64 - high_bit_offset; in bch2_bkey_greatest_differing_bit()
712 EBUG_ON(b->nr_key_bits != bkey_format_key_bits(&b->format)); in bch2_bkey_greatest_differing_bit()
720 l_v >>= word_bits - nr_key_bits; in bch2_bkey_greatest_differing_bit()
721 r_v >>= word_bits - nr_key_bits; in bch2_bkey_greatest_differing_bit()
724 nr_key_bits -= word_bits; in bch2_bkey_greatest_differing_bit()
728 return fls64(l_v ^ r_v) - 1 + nr_key_bits; in bch2_bkey_greatest_differing_bit()
735 word_bits = 64; in bch2_bkey_greatest_differing_bit()
743 * Bits are indexed from 0 - return is [0, nr_key_bits)
748 const u64 *p = high_word(&b->format, k); in bch2_bkey_ffs()
749 unsigned nr_key_bits = b->nr_key_bits; in bch2_bkey_ffs()
752 EBUG_ON(b->nr_key_bits != bkey_format_key_bits(&b->format)); in bch2_bkey_ffs()
755 while (offset > 64) { in bch2_bkey_ffs()
757 offset -= 64; in bch2_bkey_ffs()
760 offset = 64 - offset; in bch2_bkey_ffs()
763 unsigned bits = nr_key_bits + offset < 64 in bch2_bkey_ffs()
765 : 64 - offset; in bch2_bkey_ffs()
767 u64 mask = (~0ULL >> (64 - bits)) << offset; in bch2_bkey_ffs()
770 return ret + __ffs64(*p & mask) - offset; in bch2_bkey_ffs()
773 nr_key_bits -= bits; in bch2_bkey_ffs()
795 unsigned bits = format->bits_per_field[field]; in compile_bkey_field()
796 u64 offset = le64_to_cpu(format->field_offset[field]); in compile_bkey_field()
797 unsigned i, byte, bit_offset, align, shl, shr; in compile_bkey_field() local
844 bit_offset = format->key_u64s * 64; in compile_bkey_field()
846 bit_offset -= format->bits_per_field[i]; in compile_bkey_field()
848 byte = bit_offset / 8; in compile_bkey_field()
849 bit_offset -= byte * 8; in compile_bkey_field()
854 /* movzx eax, BYTE PTR [rsi + imm8] */ in compile_bkey_field()
855 I4(0x0f, 0xb6, 0x46, byte); in compile_bkey_field()
858 I4(0x0f, 0xb7, 0x46, byte); in compile_bkey_field()
860 align = min(4 - DIV_ROUND_UP(bit_offset + bits, 8), byte & 3); in compile_bkey_field()
861 byte -= align; in compile_bkey_field()
867 I3(0x8b, 0x46, byte); in compile_bkey_field()
875 unsigned mask = ~0U >> (32 - bits); in compile_bkey_field()
882 } else if (bit_offset + bits <= 64) { in compile_bkey_field()
883 align = min(8 - DIV_ROUND_UP(bit_offset + bits, 8), byte & 7); in compile_bkey_field()
884 byte -= align; in compile_bkey_field()
887 BUG_ON(bit_offset + bits > 64); in compile_bkey_field()
890 I4(0x48, 0x8b, 0x46, byte); in compile_bkey_field()
892 shl = 64 - bit_offset - bits; in compile_bkey_field()
905 align = min(4 - DIV_ROUND_UP(bit_offset + bits, 8), byte & 3); in compile_bkey_field()
906 byte -= align; in compile_bkey_field()
911 /* mov rax, [rsi + byte] */ in compile_bkey_field()
912 I4(0x48, 0x8b, 0x46, byte); in compile_bkey_field()
914 /* mov edx, [rsi + byte + 8] */ in compile_bkey_field()
915 I3(0x8b, 0x56, byte + 8); in compile_bkey_field()
918 shr = bit_offset + bits - 64; in compile_bkey_field()
925 I4(0x48, 0xc1, 0xe2, 64 - shr); in compile_bkey_field()
930 shr = bit_offset - shr; in compile_bkey_field()
946 } else if (offset + (~0ULL >> (64 - bits)) > U32_MAX) { in compile_bkey_field()
980 * rdi: dst - unpacked key in bch2_compile_bkey_format()
981 * rsi: src - packed key in bch2_compile_bkey_format()
984 /* k->u64s, k->format, k->type */ in bch2_compile_bkey_format()
989 /* add eax, BKEY_U64s - format->key_u64s */ in bch2_compile_bkey_format()
990 I5(0x05, BKEY_U64s - format->key_u64s, KEY_FORMAT_CURRENT, 0, 0); in bch2_compile_bkey_format()
992 /* and eax, imm32: mask out k->pad: */ in bch2_compile_bkey_format()
1001 sizeof(((struct bkey *) NULL)->field), \ in bch2_compile_bkey_format()
1009 return (void *) out - _out; in bch2_compile_bkey_format()
1047 ? bpos_cmp(l_unpacked->p, *r) in __bch2_bkey_cmp_left_packed()
1054 u8 *h = ((u8 *) &p[1]) - 1; in bch2_bpos_swab()
1059 --h; in bch2_bpos_swab()
1066 u8 *l = k->key_start; in bch2_bkey_swab_key()
1067 u8 *h = (u8 *) ((u64 *) k->_data + f->key_u64s) - 1; in bch2_bkey_swab_key()
1072 --h; in bch2_bkey_swab_key()
1087 64, in bch2_bkey_pack_test()
1097 for (i = 0; i < out_s.format->nr_fields; i++) { in bch2_bkey_pack_test()