Lines Matching +full:gen +full:- +full:2
1 // SPDX-License-Identifier: GPL-2.0
34 acc_u64s_percpu((u64 *) usage, (u64 __percpu *) ca->usage, dev_usage_u64s()); in bch2_dev_usage_read_fast()
48 ret.capacity = c->capacity - in __bch2_fs_usage_read_short()
49 percpu_u64_get(&c->usage->hidden); in __bch2_fs_usage_read_short()
51 data = percpu_u64_get(&c->usage->data) + in __bch2_fs_usage_read_short()
52 percpu_u64_get(&c->usage->btree); in __bch2_fs_usage_read_short()
53 reserved = percpu_u64_get(&c->usage->reserved) + in __bch2_fs_usage_read_short()
54 percpu_u64_get(c->online_reserved); in __bch2_fs_usage_read_short()
57 ret.free = ret.capacity - ret.used; in __bch2_fs_usage_read_short()
59 ret.nr_inodes = percpu_u64_get(&c->usage->nr_inodes); in __bch2_fs_usage_read_short()
69 percpu_down_read(&c->mark_lock); in bch2_fs_usage_read_short()
71 percpu_up_read(&c->mark_lock); in bch2_fs_usage_read_short()
80 if (out->nr_tabstops < 5) { in bch2_dev_usage_to_text()
94 usage->d[i].buckets, in bch2_dev_usage_to_text()
95 usage->d[i].sectors, in bch2_dev_usage_to_text()
96 usage->d[i].fragmented); in bch2_dev_usage_to_text()
99 prt_printf(out, "capacity\t%llu\r\n", ca->mi.nbuckets); in bch2_dev_usage_to_text()
108 struct bch_fs *c = trans->c; in bch2_check_fix_ptr()
139 if (fsck_err_on(!g->gen_valid, in bch2_check_fix_ptr()
141 "bucket %u:%zu data type %s ptr gen %u missing in alloc btree\n" in bch2_check_fix_ptr()
145 p.ptr.gen, in bch2_check_fix_ptr()
149 g->gen_valid = true; in bch2_check_fix_ptr()
150 g->gen = p.ptr.gen; in bch2_check_fix_ptr()
156 if (fsck_err_on(gen_cmp(p.ptr.gen, g->gen) > 0, in bch2_check_fix_ptr()
158 "bucket %u:%zu data type %s ptr gen in the future: %u > %u\n" in bch2_check_fix_ptr()
162 p.ptr.gen, g->gen, in bch2_check_fix_ptr()
166 (g->data_type != BCH_DATA_btree || in bch2_check_fix_ptr()
168 g->gen_valid = true; in bch2_check_fix_ptr()
169 g->gen = p.ptr.gen; in bch2_check_fix_ptr()
170 g->data_type = 0; in bch2_check_fix_ptr()
171 g->stripe_sectors = 0; in bch2_check_fix_ptr()
172 g->dirty_sectors = 0; in bch2_check_fix_ptr()
173 g->cached_sectors = 0; in bch2_check_fix_ptr()
179 if (fsck_err_on(gen_cmp(g->gen, p.ptr.gen) > BUCKET_GC_GEN_MAX, in bch2_check_fix_ptr()
181 "bucket %u:%zu gen %u data type %s: ptr gen %u too stale\n" in bch2_check_fix_ptr()
183 p.ptr.dev, PTR_BUCKET_NR(ca, &p.ptr), g->gen, in bch2_check_fix_ptr()
185 p.ptr.gen, in bch2_check_fix_ptr()
190 if (fsck_err_on(!p.ptr.cached && gen_cmp(p.ptr.gen, g->gen) < 0, in bch2_check_fix_ptr()
196 p.ptr.gen, g->gen, in bch2_check_fix_ptr()
201 if (data_type != BCH_DATA_btree && p.ptr.gen != g->gen) in bch2_check_fix_ptr()
204 if (fsck_err_on(bucket_data_type_mismatch(g->data_type, data_type), in bch2_check_fix_ptr()
206 "bucket %u:%zu gen %u different types of data in same bucket: %s, %s\n" in bch2_check_fix_ptr()
208 p.ptr.dev, PTR_BUCKET_NR(ca, &p.ptr), g->gen, in bch2_check_fix_ptr()
209 bch2_data_type_str(g->data_type), in bch2_check_fix_ptr()
214 g->gen_valid = true; in bch2_check_fix_ptr()
215 g->gen = p.ptr.gen; in bch2_check_fix_ptr()
216 g->data_type = data_type; in bch2_check_fix_ptr()
217 g->stripe_sectors = 0; in bch2_check_fix_ptr()
218 g->dirty_sectors = 0; in bch2_check_fix_ptr()
219 g->cached_sectors = 0; in bch2_check_fix_ptr()
226 struct gc_stripe *m = genradix_ptr(&c->gc_stripes, p.ec.idx); in bch2_check_fix_ptr()
228 if (fsck_err_on(!m || !m->alive, in bch2_check_fix_ptr()
237 if (fsck_err_on(m && m->alive && !bch2_ptr_matches_stripe_m(m, p), in bch2_check_fix_ptr()
257 struct bch_fs *c = trans->c; in bch2_check_fix_ptrs()
274 ret = -EINVAL; in bch2_check_fix_ptrs()
284 bch2_bkey_drop_ptrs(bkey_i_to_s(new), ptr, !bch2_dev_exists(c, ptr->dev)); in bch2_check_fix_ptrs()
289 * We don't want to drop btree node pointers - if the in bch2_check_fix_ptrs()
296 struct bch_dev *ca = bch2_dev_rcu(c, ptr->dev); in bch2_check_fix_ptrs()
299 ptr->gen = g->gen; in bch2_check_fix_ptrs()
315 (!g->gen_valid || gen_cmp(p.ptr.gen, g->gen) > 0)) || in bch2_check_fix_ptrs()
317 gen_cmp(p.ptr.gen, g->gen) < 0) || in bch2_check_fix_ptrs()
318 gen_cmp(g->gen, p.ptr.gen) > BUCKET_GC_GEN_MAX || in bch2_check_fix_ptrs()
319 (g->data_type && in bch2_check_fix_ptrs()
320 g->data_type != data_type)) { in bch2_check_fix_ptrs()
321 bch2_bkey_drop_ptr(bkey_i_to_s(new), &entry->ptr); in bch2_check_fix_ptrs()
330 struct gc_stripe *m = genradix_ptr(&c->gc_stripes, in bch2_check_fix_ptrs()
331 entry->stripe_ptr.idx); in bch2_check_fix_ptrs()
344 if (!m || !m->alive || in bch2_check_fix_ptrs()
345 !__bch2_ptr_matches_stripe(&m->ptrs[entry->stripe_ptr.block], in bch2_check_fix_ptrs()
346 &next_ptr->ptr, in bch2_check_fix_ptrs()
347 m->sectors)) { in bch2_check_fix_ptrs()
366 bch2_trans_node_iter_init(trans, &iter, btree, new->k.p, 0, level, in bch2_check_fix_ptrs()
377 bch2_btree_node_update_key_early(trans, btree, level - 1, k, new); in bch2_check_fix_ptrs()
391 struct bch_fs *c = trans->c; in bch2_bucket_ref_update()
399 if (gen_after(ptr->gen, b_gen)) { in bch2_bucket_ref_update()
402 "bucket %u:%zu gen %u data type %s: ptr gen %u newer than bucket gen\n" in bch2_bucket_ref_update()
404 ptr->dev, bucket_nr, b_gen, in bch2_bucket_ref_update()
406 ptr->gen, in bch2_bucket_ref_update()
413 if (gen_cmp(b_gen, ptr->gen) > BUCKET_GC_GEN_MAX) { in bch2_bucket_ref_update()
416 "bucket %u:%zu gen %u data type %s: ptr gen %u too stale\n" in bch2_bucket_ref_update()
418 ptr->dev, bucket_nr, b_gen, in bch2_bucket_ref_update()
420 ptr->gen, in bch2_bucket_ref_update()
428 if (b_gen != ptr->gen && ptr->cached) { in bch2_bucket_ref_update()
433 if (b_gen != ptr->gen) { in bch2_bucket_ref_update()
436 "bucket %u:%zu gen %u (mem gen %u) data type %s: stale dirty ptr (gen %u)\n" in bch2_bucket_ref_update()
438 ptr->dev, bucket_nr, b_gen, in bch2_bucket_ref_update()
441 ptr->gen, in bch2_bucket_ref_update()
452 "bucket %u:%zu gen %u different types of data in same bucket: %s, %s\n" in bch2_bucket_ref_update()
454 ptr->dev, bucket_nr, b_gen, in bch2_bucket_ref_update()
467 "bucket %u:%zu gen %u data type %s sector count overflow: %u + %lli > U32_MAX\n" in bch2_bucket_ref_update()
469 ptr->dev, bucket_nr, b_gen, in bch2_bucket_ref_update()
476 sectors = -*bucket_sectors; in bch2_bucket_ref_update()
487 ret = -BCH_ERR_bucket_ref_update; in bch2_bucket_ref_update()
493 struct bch_fs *c = trans->c; in bch2_trans_account_disk_usage_change()
494 u64 disk_res_sectors = trans->disk_res ? trans->disk_res->sectors : 0; in bch2_trans_account_disk_usage_change()
498 percpu_down_read(&c->mark_lock); in bch2_trans_account_disk_usage_change()
499 struct bch_fs_usage_base *src = &trans->fs_usage_delta; in bch2_trans_account_disk_usage_change()
501 s64 added = src->btree + src->data + src->reserved; in bch2_trans_account_disk_usage_change()
507 s64 should_not_have_added = added - (s64) disk_res_sectors; in bch2_trans_account_disk_usage_change()
511 old = atomic64_read(&c->sectors_available); in bch2_trans_account_disk_usage_change()
513 new = max_t(s64, 0, old - should_not_have_added); in bch2_trans_account_disk_usage_change()
514 } while (!atomic64_try_cmpxchg(&c->sectors_available, in bch2_trans_account_disk_usage_change()
517 added -= should_not_have_added; in bch2_trans_account_disk_usage_change()
522 trans->disk_res->sectors -= added; in bch2_trans_account_disk_usage_change()
523 this_cpu_sub(*c->online_reserved, added); in bch2_trans_account_disk_usage_change()
527 struct bch_fs_usage_base *dst = this_cpu_ptr(c->usage); in bch2_trans_account_disk_usage_change()
530 percpu_up_read(&c->mark_lock); in bch2_trans_account_disk_usage_change()
547 u32 *dst_sectors = p->has_ec ? &a->stripe_sectors : in __mark_pointer()
548 !p->ptr.cached ? &a->dirty_sectors : in __mark_pointer()
549 &a->cached_sectors; in __mark_pointer()
550 int ret = bch2_bucket_ref_update(trans, ca, k, &p->ptr, sectors, ptr_data_type, in __mark_pointer()
551 a->gen, a->data_type, dst_sectors); in __mark_pointer()
567 struct bch_fs *c = trans->c; in bch2_trigger_pointer()
575 *sectors = insert ? bp.v.bucket_len : -(s64) bp.v.bucket_len; in bch2_trigger_pointer()
580 ret = -BCH_ERR_trigger_pointer; in bch2_trigger_pointer()
589 __mark_pointer(trans, ca, k, &p, *sectors, bp.v.data_type, &a->v, insert); in bch2_trigger_pointer()
605 ret = -BCH_ERR_trigger_pointer; in bch2_trigger_pointer()
644 if (!bch2_ptr_matches_stripe(&s->v, p)) { in bch2_trigger_stripe_ptr()
648 ret = -BCH_ERR_trigger_stripe_pointer; in bch2_trigger_stripe_ptr()
652 stripe_blockcount_set(&s->v, p.ec.block, in bch2_trigger_stripe_ptr()
653 stripe_blockcount_get(&s->v, p.ec.block) + in bch2_trigger_stripe_ptr()
659 bch2_bkey_to_replicas(&acc.replicas, bkey_i_to_s_c(&s->k_i)); in bch2_trigger_stripe_ptr()
668 struct bch_fs *c = trans->c; in bch2_trigger_stripe_ptr()
670 struct gc_stripe *m = genradix_ptr_alloc(&c->gc_stripes, p.ec.idx, GFP_KERNEL); in bch2_trigger_stripe_ptr()
674 return -BCH_ERR_ENOMEM_mark_stripe_ptr; in bch2_trigger_stripe_ptr()
677 mutex_lock(&c->ec_stripes_heap_lock); in bch2_trigger_stripe_ptr()
679 if (!m || !m->alive) { in bch2_trigger_stripe_ptr()
680 mutex_unlock(&c->ec_stripes_heap_lock); in bch2_trigger_stripe_ptr()
687 return -BCH_ERR_trigger_stripe_pointer; in bch2_trigger_stripe_ptr()
690 m->block_sectors[p.ec.block] += sectors; in bch2_trigger_stripe_ptr()
695 memcpy(&acc.replicas, &m->r.e, replicas_entry_bytes(&m->r.e)); in bch2_trigger_stripe_ptr()
696 mutex_unlock(&c->ec_stripes_heap_lock); in bch2_trigger_stripe_ptr()
777 compression_acct[2] = 0; in __trigger_extent()
783 compression_acct[2] += p.crc.compressed_size; in __trigger_extent()
793 if (acc_replicas_key.replicas.nr_devs && !level && k.k->p.snapshot) { in __trigger_extent()
796 .snapshot.id = k.k->p.snapshot, in __trigger_extent()
825 .inum.inum = k.k->p.inode, in __trigger_extent()
828 insert ? 1 : -1, in __trigger_extent()
829 insert ? k.k->size : -((s64) k.k->size), in __trigger_extent()
845 struct bch_fs *c = trans->c; in bch2_trigger_extent()
848 unsigned new_ptrs_bytes = (void *) new_ptrs.end - (void *) new_ptrs.start; in bch2_trigger_extent()
849 unsigned old_ptrs_bytes = (void *) old_ptrs.end - (void *) old_ptrs.start; in bch2_trigger_extent()
854 /* if pointers aren't changing - nothing to do: */ in bch2_trigger_extent()
864 if (old.k->type) { in bch2_trigger_extent()
872 if (new.k->type) { in bch2_trigger_extent()
884 need_rebalance_delta -= s != 0; in bch2_trigger_extent()
885 need_rebalance_sectors_delta -= s; in bch2_trigger_extent()
893 new.k->p, need_rebalance_delta > 0); in bch2_trigger_extent()
919 s64 sectors = k.k->size; in __trigger_reservation()
922 sectors = -sectors; in __trigger_reservation()
926 .persistent_reserved.nr_replicas = bkey_s_c_to_reservation(k).v->nr_replicas, in __trigger_reservation()
950 struct bch_fs *c = trans->c; in __bch2_trans_mark_metadata_bucket()
955 bch2_trans_start_alloc_update_noupdate(trans, &iter, POS(ca->dev_idx, b)); in __bch2_trans_mark_metadata_bucket()
959 if (a->v.data_type && type && a->v.data_type != type) { in __bch2_trans_mark_metadata_bucket()
962 "bucket %llu:%llu gen %u different types of data in same bucket: %s, %s\n" in __bch2_trans_mark_metadata_bucket()
964 iter.pos.inode, iter.pos.offset, a->v.gen, in __bch2_trans_mark_metadata_bucket()
965 bch2_data_type_str(a->v.data_type), in __bch2_trans_mark_metadata_bucket()
968 ret = -BCH_ERR_metadata_bucket_inconsistency; in __bch2_trans_mark_metadata_bucket()
972 if (a->v.data_type != type || in __bch2_trans_mark_metadata_bucket()
973 a->v.dirty_sectors != sectors) { in __bch2_trans_mark_metadata_bucket()
974 a->v.data_type = type; in __bch2_trans_mark_metadata_bucket()
975 a->v.dirty_sectors = sectors; in __bch2_trans_mark_metadata_bucket()
976 ret = bch2_trans_update(trans, &iter, &a->k_i, 0); in __bch2_trans_mark_metadata_bucket()
988 struct bch_fs *c = trans->c; in bch2_mark_metadata_bucket()
993 ca->dev_idx, bch2_data_type_str(data_type))) in bch2_mark_metadata_bucket()
999 if (bch2_fs_inconsistent_on(g->data_type && in bch2_mark_metadata_bucket()
1000 g->data_type != data_type, c, in bch2_mark_metadata_bucket()
1002 bch2_data_type_str(g->data_type), in bch2_mark_metadata_bucket()
1006 if (bch2_fs_inconsistent_on((u64) g->dirty_sectors + sectors > ca->mi.bucket_size, c, in bch2_mark_metadata_bucket()
1007 "bucket %u:%llu gen %u data type %s sector count overflow: %u + %u > bucket size", in bch2_mark_metadata_bucket()
1008 ca->dev_idx, b, g->gen, in bch2_mark_metadata_bucket()
1009 bch2_data_type_str(g->data_type ?: data_type), in bch2_mark_metadata_bucket()
1010 g->dirty_sectors, sectors)) in bch2_mark_metadata_bucket()
1013 g->data_type = data_type; in bch2_mark_metadata_bucket()
1014 g->dirty_sectors += sectors; in bch2_mark_metadata_bucket()
1022 return -BCH_ERR_metadata_bucket_inconsistency; in bch2_mark_metadata_bucket()
1037 if (b >= ca->mi.nbuckets) in bch2_trans_mark_metadata_bucket()
1057 min_t(u64, bucket_to_sector(ca, b + 1), end) - start; in bch2_trans_mark_metadata_sectors()
1079 struct bch_fs *c = trans->c; in __bch2_trans_mark_dev_sb()
1081 mutex_lock(&c->sb_lock); in __bch2_trans_mark_dev_sb()
1082 struct bch_sb_layout layout = ca->disk_sb.sb->layout; in __bch2_trans_mark_dev_sb()
1083 mutex_unlock(&c->sb_lock); in __bch2_trans_mark_dev_sb()
1114 for (i = 0; i < ca->journal.nr; i++) { in __bch2_trans_mark_dev_sb()
1116 ca->journal.buckets[i], in __bch2_trans_mark_dev_sb()
1117 BCH_DATA_journal, ca->mi.bucket_size, flags); in __bch2_trans_mark_dev_sb()
1140 percpu_ref_put(&ca->io_ref); in bch2_trans_mark_dev_sbs_flags()
1155 struct bch_sb_layout *layout = &ca->disk_sb.sb->layout; in bch2_is_superblock_bucket()
1163 for (i = 0; i < layout->nr_superblocks; i++) { in bch2_is_superblock_bucket()
1164 u64 offset = le64_to_cpu(layout->sb_offset[i]); in bch2_is_superblock_bucket()
1165 u64 end = offset + (1 << layout->sb_max_size_bits); in bch2_is_superblock_bucket()
1171 for (i = 0; i < ca->journal.nr; i++) in bch2_is_superblock_bucket()
1172 if (b == ca->journal.buckets[i]) in bch2_is_superblock_bucket()
1190 percpu_down_read(&c->mark_lock); in __bch2_disk_reservation_add()
1192 pcpu = this_cpu_ptr(c->pcpu); in __bch2_disk_reservation_add()
1194 if (sectors <= pcpu->sectors_available) in __bch2_disk_reservation_add()
1197 old = atomic64_read(&c->sectors_available); in __bch2_disk_reservation_add()
1205 } while (!atomic64_try_cmpxchg(&c->sectors_available, in __bch2_disk_reservation_add()
1206 &old, old - get)); in __bch2_disk_reservation_add()
1208 pcpu->sectors_available += get; in __bch2_disk_reservation_add()
1211 pcpu->sectors_available -= sectors; in __bch2_disk_reservation_add()
1212 this_cpu_add(*c->online_reserved, sectors); in __bch2_disk_reservation_add()
1213 res->sectors += sectors; in __bch2_disk_reservation_add()
1216 percpu_up_read(&c->mark_lock); in __bch2_disk_reservation_add()
1220 mutex_lock(&c->sectors_available_lock); in __bch2_disk_reservation_add()
1222 percpu_u64_set(&c->pcpu->sectors_available, 0); in __bch2_disk_reservation_add()
1230 atomic64_set(&c->sectors_available, in __bch2_disk_reservation_add()
1231 max_t(s64, 0, sectors_available - sectors)); in __bch2_disk_reservation_add()
1232 this_cpu_add(*c->online_reserved, sectors); in __bch2_disk_reservation_add()
1233 res->sectors += sectors; in __bch2_disk_reservation_add()
1236 atomic64_set(&c->sectors_available, sectors_available); in __bch2_disk_reservation_add()
1237 ret = -BCH_ERR_ENOSPC_disk_reservation; in __bch2_disk_reservation_add()
1240 mutex_unlock(&c->sectors_available_lock); in __bch2_disk_reservation_add()
1241 percpu_up_read(&c->mark_lock); in __bch2_disk_reservation_add()
1251 kvfree_rcu_mightsleep(ca->buckets_nouse); in bch2_buckets_nouse_free()
1252 ca->buckets_nouse = NULL; in bch2_buckets_nouse_free()
1259 BUG_ON(ca->buckets_nouse); in bch2_buckets_nouse_alloc()
1261 ca->buckets_nouse = bch2_kvmalloc(BITS_TO_LONGS(ca->mi.nbuckets) * in bch2_buckets_nouse_alloc()
1264 if (!ca->buckets_nouse) { in bch2_buckets_nouse_alloc()
1266 return -BCH_ERR_ENOMEM_buckets_nouse; in bch2_buckets_nouse_alloc()
1284 bool resize = ca->bucket_gens != NULL; in bch2_dev_buckets_resize()
1288 lockdep_assert_held(&c->state_lock); in bch2_dev_buckets_resize()
1290 if (resize && ca->buckets_nouse) in bch2_dev_buckets_resize()
1291 return -BCH_ERR_no_resize_with_buckets_nouse; in bch2_dev_buckets_resize()
1296 ret = -BCH_ERR_ENOMEM_bucket_gens; in bch2_dev_buckets_resize()
1300 bucket_gens->first_bucket = ca->mi.first_bucket; in bch2_dev_buckets_resize()
1301 bucket_gens->nbuckets = nbuckets; in bch2_dev_buckets_resize()
1302 bucket_gens->nbuckets_minus_first = in bch2_dev_buckets_resize()
1303 bucket_gens->nbuckets - bucket_gens->first_bucket; in bch2_dev_buckets_resize()
1305 old_bucket_gens = rcu_dereference_protected(ca->bucket_gens, 1); in bch2_dev_buckets_resize()
1308 bucket_gens->nbuckets = min(bucket_gens->nbuckets, in bch2_dev_buckets_resize()
1309 old_bucket_gens->nbuckets); in bch2_dev_buckets_resize()
1310 bucket_gens->nbuckets_minus_first = in bch2_dev_buckets_resize()
1311 bucket_gens->nbuckets - bucket_gens->first_bucket; in bch2_dev_buckets_resize()
1312 memcpy(bucket_gens->b, in bch2_dev_buckets_resize()
1313 old_bucket_gens->b, in bch2_dev_buckets_resize()
1314 bucket_gens->nbuckets); in bch2_dev_buckets_resize()
1317 rcu_assign_pointer(ca->bucket_gens, bucket_gens); in bch2_dev_buckets_resize()
1320 nbuckets = ca->mi.nbuckets; in bch2_dev_buckets_resize()
1325 call_rcu(&bucket_gens->rcu, bucket_gens_free_rcu); in bch2_dev_buckets_resize()
1332 kvfree(ca->buckets_nouse); in bch2_dev_buckets_free()
1333 kvfree(rcu_dereference_protected(ca->bucket_gens, 1)); in bch2_dev_buckets_free()
1334 free_percpu(ca->usage); in bch2_dev_buckets_free()
1339 ca->usage = alloc_percpu(struct bch_dev_usage); in bch2_dev_buckets_alloc()
1340 if (!ca->usage) in bch2_dev_buckets_alloc()
1341 return -BCH_ERR_ENOMEM_usage_init; in bch2_dev_buckets_alloc()
1343 return bch2_dev_buckets_resize(c, ca, ca->mi.nbuckets); in bch2_dev_buckets_alloc()