fs/bcachefs/fsck.c

54 	int ret = dirent_points_to_inode_nowarn(c, dirent, inode);
55 	if (ret) {
61 	return ret;
73 	int ret = for_each_btree_key_max(trans, iter, BTREE_ID_extents,
82 	return ret ?: sectors;
90 	int ret = for_each_btree_key_max(trans, iter, BTREE_ID_dirents,
100 	return ret ?: subdirs;
107 	int ret = bch2_subvolume_get(trans, subvol, false, &s);
111 	return ret;
122 	int ret = bkey_err(k);
123 	if (ret)
124 		return ret;
142 	int ret;
144 	for_each_btree_key_norestart(trans, iter, BTREE_ID_snapshots, POS_MIN, 0, k, ret) {
157 	ret = bch_err_throw(trans->c, ENOENT_no_snapshot_tree_subvol);
160 	return ret;
173 	int ret;
176 	ret = bch2_snapshot_tree_lookup(trans,
178 	if (ret)
179 		return ret;
182 	ret = find_snapshot_tree_subvol(trans,
184 	bch_err_msg(c, ret, "finding subvol associated with snapshot tree %u",
186 	if (ret)
187 		return ret;
190 	ret = bch2_subvolume_get(trans, subvolid, false, &subvol);
191 	bch_err_msg(c, ret, "looking up subvol %u for snapshot %u", subvolid, snapshot);
192 	if (ret)
193 		return ret;
200 		ret = PTR_ERR_OR_ZERO(subvol);
201 		if (ret)
202 			return ret;
215 	ret = bch2_inode_find_by_inum_snapshot(trans, root_inum.inum, snapshot, &root_inode, 0);
216 	bch_err_msg(c, ret, "looking up root inode %llu for subvol %u",
218 	if (ret)
219 		return ret;
223 	ret = lookup_dirent_in_snapshot(trans, root_hash_info, root_inum,
225 	if (bch2_err_matches(ret, ENOENT))
228 	bch_err_fn(c, ret);
229 	if (ret)
230 		return ret;
241 	ret = bch2_inode_find_by_inum_snapshot(trans, inum, snapshot, lostfound, 0);
242 	bch_err_msg(c, ret, "looking up lost+found %llu:%u in (root inode %llu, snapshot root %u)",
244 	return ret;
257 	ret = bch2_inum_to_path(trans, root_inum, &path);
258 	if (ret)
275 	ret = bch2_inode_create(trans, &lostfound_iter, lostfound, snapshot, cpu);
276 	if (ret)
280 	ret = bch2_btree_iter_traverse(trans, &lostfound_iter);
281 	if (ret)
284 	ret =   bch2_dirent_create_snapshot(trans,
295 	bch_err_msg(c, ret, "creating lost+found");
297 	return ret;
342 	int ret = bkey_err(k);
343 	if (ret)
344 		return ret;
352 		ret = PTR_ERR_OR_ZERO(k);
353 		if (ret)
359 		ret = bch2_trans_update(trans, &iter, k, BTREE_UPDATE_internal_snapshot_node);
363 	return ret;
371 	int ret;
382 		ret = PTR_ERR_OR_ZERO(subvol);
383 		if (ret)
384 			return ret;
390 		ret = subvol_lookup(trans, inode->bi_parent_subvol,
392 		if (ret)
393 			return ret;
400 	ret = lookup_lostfound(trans, dirent_snapshot, &lostfound, inode->bi_inum);
401 	if (ret)
402 		return ret;
414 	ret = __bch2_fsck_write_inode(trans, &lostfound);
415 	if (ret)
416 		return ret;
423 	ret = bch2_dirent_create_snapshot(trans,
433 	if (ret) {
434 		bch_err_msg(c, ret, "error creating dirent");
435 		return ret;
438 	ret = __bch2_fsck_write_inode(trans, inode);
439 	if (ret)
440 		return ret;
444 		ret = bch2_inum_snapshot_to_path(trans, inode->bi_inum,
446 		if (ret)
447 			return ret;
466 				BTREE_ITER_all_snapshots|BTREE_ITER_intent, k, ret) {
476 			ret = bch2_inode_unpack(k, &child_inode);
477 			if (ret)
481 				ret = maybe_delete_dirent(trans,
485 				if (ret)
488 				ret = snapshot_list_add(c, &whiteouts_done, k.k->p.snapshot);
489 				if (ret)
496 				ret = bch2_inode_write_flags(trans, &iter, &child_inode,
498 				if (ret)
506 	return ret;
525 		int ret = bch2_subvolume_get_snapshot(trans, inode->bi_parent_subvol, &snapshot);
526 		if (ret)
527 			return ret;
534 	int ret = bkey_err(d) ?:
538 	return ret;
546 	int ret = bch2_inode_find_by_inum_trans(trans,
549 	if (ret)
550 		return ret;
552 	ret = remove_backpointer(trans, &inode);
553 	if (!bch2_err_matches(ret, ENOENT))
554 		bch_err_msg(c, ret, "removing dirent");
555 	if (ret)
556 		return ret;
558 	ret = reattach_inode(trans, &inode);
559 	bch_err_msg(c, ret, "reattaching inode %llu", inode.bi_inum);
560 	return ret;
587 		int ret = bch2_inode_create(trans, &inode_iter, &new_inode, snapshotid, cpu) ?:
591 		if (ret)
592 			return ret;
600 	int ret = PTR_ERR_OR_ZERO(new_subvol);
601 	if (ret)
602 		return ret;
608 	ret = bch2_btree_insert_trans(trans, BTREE_ID_subvolumes, &new_subvol->k_i, 0);
609 	if (ret)
610 		return ret;
616 	ret = PTR_ERR_OR_ZERO(s);
617 	bch_err_msg(c, ret, "getting snapshot %u", snapshotid);
618 	if (ret)
619 		return ret;
630 	ret = PTR_ERR_OR_ZERO(st);
631 	bch_err_msg(c, ret, "getting snapshot tree %u", snapshot_tree);
632 	if (ret)
633 		return ret;
655 		int ret = bkey_err(k);
656 		if (ret)
657 			return ret;
701 	int ret = darray_insert_item(&s->ids, i - s->ids.data, id);
702 	if (ret)
705 	return ret;
824 	int ret = darray_push(&w->inodes, ((struct inode_walker_entry) {
827 	if (ret)
828 		return ret;
846 	int ret;
859 			BTREE_ITER_all_snapshots, k, ret) {
860 		ret = add_inode(c, w, k);
861 		if (ret)
866 	if (ret)
867 		return ret;
882 	int ret;
888 			   BTREE_ITER_all_snapshots, k, ret) {
898 		ret = bkey_is_inode(k.k)
901 		if (ret)
906 	return ret;
921 	int ret = 0;
934 			ret = __bch2_fsck_write_inode(trans, &new);
940 			ret = bch2_btree_insert_nonextent(trans, BTREE_ID_inodes,
945 		if (ret)
948 		ret = bch2_trans_commit(trans, NULL, NULL, 0);
949 		if (ret)
962 		ret = darray_insert_item(&w->inodes, pos, new_entry);
963 		if (ret)
966 		ret = bch_err_throw(c, transaction_restart_nested);
974 	return ERR_PTR(ret);
982 		int ret = get_inodes_all_snapshots(trans, w, k.k->p.inode);
983 		if (ret)
984 			return ERR_PTR(ret);
1008 	int ret = 0;
1012 		ret = -BCH_ERR_fsck_repair_unimplemented;
1014 		ret = get_visible_inodes(trans, &target, s, le64_to_cpu(d->v.d_inum));
1015 		if (ret)
1020 			ret = __bch2_fsck_write_inode(trans, &i->inode);
1021 			if (ret)
1027 	return ret;
1037 		int ret = subvol_lookup(trans, inode->bi_parent_subvol, snapshot, &inum);
1038 		if (ret)
1039 			return ((struct bkey_s_c_dirent) { .k = ERR_PTR(ret) });
1049 	int ret = bkey_err(k) ?: k.k->type == KEY_TYPE_set;
1051 	return ret;
1064 	int ret = bkey_err(d);
1065 	if (ret && !bch2_err_matches(ret, ENOENT))
1066 		return ret;
1068 	if ((ret || dirent_points_to_inode_nowarn(c, d, inode)) &&
1085 	if (fsck_err_on(ret,
1089 	    fsck_err_on(!ret && dirent_points_to_inode_nowarn(c, d, inode),
1106 	ret = 0;
1110 	bch_err_fn(c, ret);
1111 	return ret;
1124 	int ret;
1126 	ret = bch2_check_key_has_snapshot(trans, iter, k);
1127 	if (ret < 0)
1129 	if (ret)
1132 	ret = snapshots_seen_update(c, s, iter->btree_id, k.k->p);
1133 	if (ret)
1139 	ret = bch2_inode_unpack(k, &u);
1140 	if (ret)
1144 		ret = bch2_inode_find_snapshot_root(trans, u.bi_inum, snapshot_root);
1145 		if (ret)
1151 		ret = bch2_repair_inode_hash_info(trans, snapshot_root);
1152 		BUG_ON(ret == -BCH_ERR_fsck_repair_unimplemented);
1153 		if (ret)
1157 	ret = bch2_check_inode_has_case_insensitive(trans, &u, &s->ids, &do_update);
1158 	if (ret)
1162 		ret = check_inode_dirent_inode(trans, &u, &do_update);
1163 		if (ret)
1181 		ret = bch2_empty_dir_snapshot(trans, k.k->p.offset, 0, k.k->p.snapshot);
1182 		if (ret && ret != -BCH_ERR_ENOTEMPTY_dir_not_empty)
1185 		fsck_err_on(ret, trans, inode_dir_unlinked_but_not_empty,
1192 		ret = 0;
1203 	ret = bch2_inode_has_child_snapshots(trans, k.k->p);
1204 	if (ret < 0)
1207 	if (fsck_err_on(ret != !!(u.bi_flags & BCH_INODE_has_child_snapshot),
1210 			ret,
1214 		if (ret)
1220 	ret = 0;
1235 			ret = check_inode_deleted_list(trans, k.k->p);
1236 			if (ret < 0)
1239 			fsck_err_on(!ret,
1244 			ret = bch2_btree_bit_mod_buffered(trans, BTREE_ID_deleted_inodes, k.k->p, 1);
1245 			if (ret)
1248 			ret = bch2_inode_or_descendents_is_open(trans, k.k->p);
1249 			if (ret < 0)
1252 			if (fsck_err_on(!ret,
1256 				ret = bch2_inode_rm_snapshot(trans, u.bi_inum, iter->pos.snapshot);
1257 				bch_err_msg(c, ret, "in fsck deleting inode");
1260 			ret = 0;
1277 		ret = bch2_subvolume_get(trans, u.bi_subvol, false, &s);
1278 		if (ret && !bch2_err_matches(ret, ENOENT))
1281 		if (ret && (c->sb.btrees_lost_data & BIT_ULL(BTREE_ID_subvolumes))) {
1282 			ret = reconstruct_subvol(trans, k.k->p.snapshot, u.bi_subvol, u.bi_inum);
1286 		if (fsck_err_on(ret,
1316 		ret = __bch2_fsck_write_inode(trans, &u);
1317 		bch_err_msg(c, ret, "in fsck updating inode");
1318 		if (ret)
1323 	bch_err_fn(c, ret);
1326 	return ret;
1336 	int ret = bch2_trans_run(c,
1344 	bch_err_fn(c, ret);
1345 	return ret;
1354 	int ret = 0;
1364 				     BTREE_ITER_all_snapshots, k, ret) {
1375 		ret = bch2_inode_unpack(k, &parent_inode);
1376 		if (ret)
1386 	return ret;
1394 	int ret = 0;
1400 	ret = bch2_inode_unpack(k, &inode);
1401 	if (ret)
1402 		return ret;
1407 	ret = find_oldest_inode_needs_reattach(trans, &inode);
1408 	if (ret)
1409 		return ret;
1415 		ret = reattach_inode(trans, &inode);
1418 	return ret;
1433 	int ret = bch2_trans_run(c,
1439 	bch_err_fn(c, ret);
1440 	return ret;
1466 	int ret = PTR_ERR_OR_ZERO(i);
1467 	if (ret)
1468 		return ret;
1503 					 0, k2, ret) {
1513 	if (ret)
1555 	bch_err_fn(c, ret);
1556 	return ret;
1563 	ret = bch2_btree_delete_at(trans, iter, BTREE_UPDATE_internal_snapshot_node);
1566 	ret =   reconstruct_inode(trans, iter->btree_id, k.k->p.snapshot, k.k->p.inode) ?:
1568 	if (ret)
1572 	ret = bch_err_throw(c, transaction_restart_nested);
1579 	int ret = 0;
1603 			ret = bch2_fsck_write_inode(trans, &i->inode);
1604 			if (ret)
1609 	bch_err_fn(c, ret);
1610 	return ret;
1691 	int ret;
1699 	ret = bkey_err(k1);
1700 	if (ret)
1714 		ret = bch_err_throw(c, internal_fsck_err);
1724 		ret = bkey_err(k2);
1725 		if (ret)
1739 		ret = bch_err_throw(c, internal_fsck_err);
1758 		ret =   bch2_trans_update_extent_overwrite(trans, old_iter,
1764 		bch_info(c, "repair ret %s", bch2_err_str(ret));
1766 		if (ret)
1781 			ret = snapshots_seen_add_inorder(c, pos1_seen, pos2.p.snapshot);
1787 			ret = bch_err_throw(c, transaction_restart_nested);
1795 	return ret;
1806 	int ret = 0;
1824 		ret = overlapping_extents_found(trans, iter->btree_id,
1830 		if (ret)
1836 	return ret;
1870 	int ret = 0;
1872 	ret = bch2_check_key_has_snapshot(trans, iter, k);
1873 	if (ret) {
1874 		ret = ret < 0 ? ret : 0;
1879 		ret = check_i_sectors(trans, inode);
1880 		if (ret)
1884 	ret = snapshots_seen_update(c, s, iter->btree_id, k.k->p);
1885 	if (ret)
1889 	ret = PTR_ERR_OR_ZERO(extent_i);
1890 	if (ret)
1893 	ret = check_key_has_inode(trans, iter, inode, extent_i, k);
1894 	if (ret)
1898 		ret = check_overlapping_extents(trans, s, extent_ends, k, iter,
1900 		if (ret)
1923 				ret =   snapshots_seen_add_inorder(c, s, i->inode.bi_snapshot) ?:
1929 				if (ret)
1938 	ret = bch2_trans_commit(trans, res, NULL, BCH_TRANS_COMMIT_no_enospc);
1939 	if (ret)
1956 		ret = extent_ends_at(c, extent_ends, s, k);
1957 		if (ret)
1964 	bch_err_fn(c, ret);
1965 	return ret;
1982 	int ret = bch2_trans_run(c,
1997 	bch_err_fn(c, ret);
1998 	return ret;
2005 	int ret = bch2_trans_run(c,
2016 	bch_err_fn(c, ret);
2017 	return ret;
2023 	int ret = 0;
2054 				ret = bch2_fsck_write_inode(trans, &i->inode);
2055 				if (ret)
2061 	bch_err_fn(c, ret);
2062 	return ret;
2077 	int ret;
2079 	for_each_btree_key_norestart(trans, iter, BTREE_ID_subvolumes, POS_MIN, 0, k, ret) {
2090 	if (!ret)
2091 		ret = -ENOENT;
2094 	return ret;
2110 	int ret = 0;
2112 	ret = subvol_lookup(trans, parent_subvol, &parent_snapshot, &parent_inum);
2113 	if (ret && !bch2_err_matches(ret, ENOENT))
2114 		return ret;
2116 	if (ret ||
2117 	    (!ret && !bch2_snapshot_is_ancestor(c, parent_snapshot, d.k->p.snapshot))) {
2119 		if (ret2 && !bch2_err_matches(ret, ENOENT))
2123 	if (ret &&
2130 		ret = reconstruct_subvol(trans, d.k->p.snapshot, parent_subvol, 0);
2131 		if (ret)
2132 			return ret;
2137 	if (fsck_err_on(ret,
2141 	    fsck_err_on(!ret && !bch2_snapshot_is_ancestor(c, parent_snapshot, d.k->p.snapshot),
2152 		ret = PTR_ERR_OR_ZERO(new_dirent);
2153 		if (ret)
2163 	ret = bkey_err(s.s_c);
2164 	if (ret && !bch2_err_matches(ret, ENOENT))
2167 	if (ret) {
2172 		ret = 0;
2182 		ret = bch2_inum_to_path(trans, (subvol_inum) { s.k->p.offset,
2184 		if (ret)
2192 			ret = PTR_ERR_OR_ZERO(n);
2193 			if (ret)
2203 	ret = bch2_inode_find_by_inum_snapshot(trans, target_inum, target_snapshot,
2205 	if (ret && !bch2_err_matches(ret, ENOENT))
2208 	if (ret) {
2210 		ret = bch_err_throw(c, fsck_repair_unimplemented);
2214 	if (fsck_err_on(!ret && parent_subvol != subvol_root.bi_parent_subvol,
2221 		ret = __bch2_fsck_write_inode(trans, &subvol_root);
2222 		if (ret)
2226 	ret = bch2_check_dirent_target(trans, iter, d, &subvol_root, true);
2227 	if (ret)
2234 	return ret;
2248 	int ret = 0;
2250 	ret = bch2_check_key_has_snapshot(trans, iter, k);
2251 	if (ret) {
2252 		ret = ret < 0 ? ret : 0;
2256 	ret = snapshots_seen_update(c, s, iter->btree_id, k.k->p);
2257 	if (ret)
2264 		ret = check_subdir_dirents_count(trans, dir);
2265 		if (ret)
2270 	ret = PTR_ERR_OR_ZERO(i);
2271 	if (ret < 0)
2274 	ret = check_key_has_inode(trans, iter, dir, i, k);
2275 	if (ret)
2287 	ret = bch2_str_hash_check_key(trans, s, &bch2_dirent_hash_desc, hash_info,
2289 	if (ret < 0)
2291 	if (ret) {
2293 		ret = 0;
2321 		ret = PTR_ERR_OR_ZERO(new_d);
2322 		if (ret)
2329 		ret =	bch2_hash_delete_at(trans,
2341 		ret = check_dirent_to_subvol(trans, iter, d);
2342 		if (ret)
2345 		ret = get_visible_inodes(trans, target, s, le64_to_cpu(d.v->d_inum));
2346 		if (ret)
2355 			ret = bch2_fsck_remove_dirent(trans, d.k->p);
2356 			if (ret)
2361 			ret = bch2_check_dirent_target(trans, iter, d, &i->inode, true);
2362 			if (ret)
2379 				ret =   bch2_btree_iter_traverse(trans, &delete_iter) ?:
2385 				if (ret)
2391 	ret = bch2_trans_commit(trans, NULL, NULL, BCH_TRANS_COMMIT_no_enospc);
2392 	if (ret)
2404 	return ret;
2418 	int ret;
2422 	ret = bch2_trans_run(c,
2431 	if (!ret && need_second_pass && !did_second_pass) {
2437 	if (!ret && need_second_pass) {
2439 		ret = -EINVAL;
2445 	bch_err_fn(c, ret);
2446 	return ret;
2456 	int ret = bch2_check_key_has_snapshot(trans, iter, k);
2457 	if (ret < 0)
2458 		return ret;
2459 	if (ret)
2463 	ret = PTR_ERR_OR_ZERO(i);
2464 	if (ret)
2465 		return ret;
2467 	ret = check_key_has_inode(trans, iter, inode, i, k);
2468 	if (ret)
2469 		return ret;
2490 	int ret = 0;
2492 	ret = bch2_trans_run(c,
2502 	bch_err_fn(c, ret);
2503 	return ret;
2512 	int ret;
2514 	ret = subvol_lookup(trans, BCACHEFS_ROOT_SUBVOL, &snapshot, &inum);
2515 	if (ret && !bch2_err_matches(ret, ENOENT))
2516 		return ret;
2518 	if (mustfix_fsck_err_on(ret, trans, root_subvol_missing,
2522 		ret = PTR_ERR_OR_ZERO(root_subvol);
2523 		if (ret)
2534 		ret = bch2_btree_insert_trans(trans, BTREE_ID_subvolumes, &root_subvol->k_i, 0);
2535 		bch_err_msg(c, ret, "writing root subvol");
2536 		if (ret)
2540 	ret = bch2_inode_find_by_inum_snapshot(trans, BCACHEFS_ROOT_INO, snapshot,
2542 	if (ret && !bch2_err_matches(ret, ENOENT))
2543 		return ret;
2545 	if (mustfix_fsck_err_on(ret,
2556 		ret = __bch2_fsck_write_inode(trans, &root_inode);
2557 		bch_err_msg(c, ret, "writing root inode");
2561 	return ret;
2567 	int ret = bch2_trans_commit_do(c, NULL, NULL, BCH_TRANS_COMMIT_no_enospc,
2569 	bch_err_fn(c, ret);
2570 	return ret;
2587 	int ret = 0;
2598 		ret = darray_push(&subvol_path, k.k->p.offset);
2599 		if (ret)
2605 		ret = bch2_inode_find_by_inum_trans(trans,
2608 		if (ret)
2617 			ret = bch2_inum_to_path(trans, start, &buf);
2618 			if (ret)
2622 				ret = reattach_subvol(trans, s);
2630 		ret = bkey_err(k);
2631 		if (ret)
2640 			ret = reattach_subvol(trans, s);
2649 	return ret;
2654 	int ret = bch2_trans_run(c,
2659 	bch_err_fn(c, ret);
2660 	return ret;
2672 	int ret = bkey_err(k) ?:
2675 	if (ret)
2680 		ret = __bch2_fsck_write_inode(trans, &inode) ?:
2685 	return ret;
2692 	int ret = 0;
2695 		ret = nested_lockrestart_do(trans,
2697 		bch_err_fn(trans->c, ret);
2698 		if (ret)
2704 	return ret ?: trans_was_restarted(trans, restart_count);
2716 	int ret = 0;
2721 	ret = bch2_inode_unpack(inode_k, &inode);
2722 	if (ret)
2723 		return ret;
2737 		ret = bkey_err(d.s_c);
2738 		if (ret && !bch2_err_matches(ret, ENOENT))
2741 		if (!ret && (ret = dirent_points_to_inode(c, d, &inode)))
2744 		if (bch2_err_matches(ret, ENOENT)) {
2748 				bch2_err_str(ret), buf.buf);
2754 		ret = darray_push(&path, inode.bi_inum);
2755 		if (ret)
2756 			return ret;
2763 		ret = bkey_err(inode_k) ?:
2766 		if (ret) {
2768 			bch_err_msg(c, ret, "error looking up parent directory");
2786 			ret = bch2_inum_snapshot_to_path(trans, start.offset, start.snapshot, NULL, &buf);
2787 			if (ret)
2797 				ret = remove_backpointer(trans, &inode);
2798 				bch_err_msg(c, ret, "removing dirent");
2799 				if (ret)
2802 				ret = reattach_inode(trans, &inode);
2803 				bch_err_msg(c, ret, "reattaching inode %llu", inode.bi_inum);
2814 		ret = bch2_bi_depth_renumber(trans, &path, snapshot, min_bi_depth);
2820 	bch_err_fn(c, ret);
2821 	return ret;
2830 	int ret = bch2_trans_run(c,
2845 	bch_err_fn(c, ret);
2846 	return ret;
2930 	int ret = bch2_trans_run(c,
2959 			ret = add_nlink(c, t, k.k->p.offset, k.k->p.snapshot);
2960 			if (ret) {
2962 				ret = 0;
2968 	bch_err_fn(c, ret);
2969 	return ret;
2980 	int ret = bch2_trans_run(c,
2985 			ret = snapshots_seen_update(c, &s, iter.btree_id, k.k->p);
2986 			if (ret)
3002 	bch_err_fn(c, ret);
3003 	return ret;
3013 	int ret = 0;
3021 	ret = bch2_inode_unpack(k, &u);
3022 	if (ret)
3023 		return ret;
3043 		ret = __bch2_fsck_write_inode(trans, &u);
3046 	return ret;
3056 	int ret = bch2_trans_run(c,
3062 	if (ret < 0) {
3063 		bch_err(c, "error in fsck walking inodes: %s", bch2_err_str(ret));
3064 		return ret;
3074 	int ret = 0;
3080 		ret = check_nlinks_find_hardlinks(c, &links,
3084 		ret = check_nlinks_walk_dirents(c, &links,
3087 		if (ret)
3090 		ret = check_nlinks_update_hardlinks(c, &links,
3093 		if (ret)
3100 	bch_err_fn(c, ret);
3101 	return ret;
3119 	int ret = PTR_ERR_OR_ZERO(u);
3120 	if (ret)
3121 		return ret;
3135 	int ret = bch2_trans_run(c,
3142 	bch_err_fn(c, ret);
3143 	return ret;
3165 	int ret = PTR_ERR_OR_ZERO(c);
3166 	if (ret)
3167 		return ret;
3169 	ret = bch2_fs_start(thr->c);
3170 	if (ret)
3175 		ret |= 1;
3179 		ret |= 4;
3183 	return ret;
3196 	long ret = 0;
3209 		ret = copy_from_user_errcode(&dev_u64, &user_arg->devs[i], sizeof(u64));
3210 		if (ret)
3214 		ret = PTR_ERR_OR_ZERO(dev_str);
3215 		if (ret)
3218 		ret = darray_push(&devs, dev_str);
3219 		if (ret) {
3227 		ret = -ENOMEM;
3235 		ret =   PTR_ERR_OR_ZERO(optstr) ?:
3240 		if (ret)
3259 	ret = __bch2_run_thread_with_stdio(&thr->thr);
3264 	return ret;
3268 	pr_err("ret %s", bch2_err_str(ret));
3292 	int ret = bch2_run_online_recovery_passes(c, ~0ULL);
3295 	bch_err_fn(c, ret);
3303 	return ret;
3314 	long ret = 0;
3332 		ret = -ENOMEM;
3342 		ret =   PTR_ERR_OR_ZERO(optstr) ?:
3347 		if (ret)
3351 	ret = bch2_run_thread_with_stdio(&thr->thr, &bch2_online_fsck_ops);
3353 	if (ret < 0) {
3354 		bch_err_fn(c, ret);
3360 	return ret;