man: Fix cmd-option format

.bcachefs_revision

@@ -1 +1 @@
-8c94740b1bf8645d3398170f41c9c88b78332252
+feaca6edbd240bbd98d261097a97037c56a09eec

bcachefs.8

@@ -307,9 +307,9 @@ Enable POSIX acls
 Enable user quotas
 .It Fl -grpquota
 Enable group quotas
-.It Fl prjquota
+.It Fl -prjquota
 Enable project quotas
-.It Fl degraded
+.It Fl -degraded
 Allow mounting in degraded mode
 .It Fl -very_degraded
 Allow mounting in when data will be missing

cmd_device.c

@@ -324,13 +324,15 @@ int cmd_device_evacuate(int argc, char *argv[])
 	int dev_idx;
 	struct bchfs_handle fs = bchu_fs_open_by_dev(dev_path, &dev_idx);
 
-	struct bch_ioctl_dev_usage u = bchu_dev_usage(fs, dev_idx);
+	struct bch_ioctl_dev_usage_v2 *u = bchu_dev_usage(fs, dev_idx);
 
-	if (u.state == BCH_MEMBER_STATE_rw) {
+	if (u->state == BCH_MEMBER_STATE_rw) {
 		printf("Setting %s readonly\n", dev_path);
 		bchu_disk_set_state(fs, dev_idx, BCH_MEMBER_STATE_ro, 0);
 	}
 
+	free(u);
+
 	return bchu_data(fs, (struct bch_ioctl_data) {
 		.op		= BCH_DATA_OP_migrate,
 		.start_btree	= 0,

cmd_fs.c

@@ -36,7 +36,7 @@ static void __dev_usage_type_to_text(struct printbuf *out,
 }
 
 static void dev_usage_type_to_text(struct printbuf *out,
-				   struct bch_ioctl_dev_usage *u,
+				   struct bch_ioctl_dev_usage_v2 *u,
 				   enum bch_data_type type)
 {
 	__dev_usage_type_to_text(out, bch2_data_types[type],
@@ -50,16 +50,15 @@ static void dev_usage_to_text(struct printbuf *out,
 			      struct bchfs_handle fs,
 			      struct dev_name *d)
 {
-	struct bch_ioctl_dev_usage u = bchu_dev_usage(fs, d->idx);
-	unsigned i;
+	struct bch_ioctl_dev_usage_v2 *u = bchu_dev_usage(fs, d->idx);
 
 	prt_newline(out);
 	prt_printf(out, "%s (device %u):", d->label ?: "(no label)", d->idx);
 	prt_tab(out);
 	prt_str(out, d->dev ?: "(device not found)");
 	prt_tab_rjust(out);
 
-	prt_str(out, bch2_member_states[u.state]);
+	prt_str(out, bch2_member_states[u->state]);
 	prt_tab_rjust(out);
 
 	prt_newline(out);
@@ -78,23 +77,21 @@ static void dev_usage_to_text(struct printbuf *out,
 
 	prt_newline(out);
 
-	for (i = 0; i < BCH_DATA_NR; i++)
-		dev_usage_type_to_text(out, &u, i);
-	__dev_usage_type_to_text(out, "erasure coded",
-				 u.bucket_size,
-				 u.buckets_ec, u.buckets_ec * u.bucket_size, 0);
+	for (unsigned i = 0; i < u->nr_data_types; i++)
+		dev_usage_type_to_text(out, u, i);
 
 	prt_str(out, "capacity:");
 	prt_tab(out);
 
-	prt_units_u64(out, (u.nr_buckets * u.bucket_size) << 9);
+	prt_units_u64(out, (u->nr_buckets * u->bucket_size) << 9);
 	prt_tab_rjust(out);
-	prt_printf(out, "%llu", u.nr_buckets);
+	prt_printf(out, "%llu", u->nr_buckets);
 	prt_tab_rjust(out);
 
 	printbuf_indent_sub(out, 2);
 
 	prt_newline(out);
+	free(u);
 }
 
 static int dev_by_label_cmp(const void *_l, const void *_r)

cmd_fsck.c

@@ -97,11 +97,11 @@ int cmd_fsck(int argc, char *argv[])
 		exit(8);
 	}
 
-	if (test_bit(BCH_FS_ERRORS_FIXED, &c->flags)) {
+	if (test_bit(BCH_FS_errors_fixed, &c->flags)) {
 		fprintf(stderr, "%s: errors fixed\n", c->name);
 		ret |= 1;
 	}
-	if (test_bit(BCH_FS_ERROR, &c->flags)) {
+	if (test_bit(BCH_FS_error, &c->flags)) {
 		fprintf(stderr, "%s: still has errors\n", c->name);
 		ret |= 4;
 	}

libbcachefs.h

@@ -167,14 +167,31 @@ static inline struct bch_ioctl_fs_usage *bchu_fs_usage(struct bchfs_handle fs)
 	}
 }
 
-static inline struct bch_ioctl_dev_usage bchu_dev_usage(struct bchfs_handle fs,
-							unsigned idx)
+static inline struct bch_ioctl_dev_usage_v2 *bchu_dev_usage(struct bchfs_handle fs,
+							    unsigned idx)
 {
-	struct bch_ioctl_dev_usage i = { .dev = idx, .flags = BCH_BY_INDEX};
+	struct bch_ioctl_dev_usage_v2 *u = xcalloc(sizeof(*u) + sizeof(u->d[0]) * BCH_DATA_NR, 1);
 
-	if (xioctl(fs.ioctl_fd, BCH_IOCTL_DEV_USAGE, &i))
-		die("BCH_IOCTL_DEV_USAGE error: %m");
-	return i;
+	u->dev			= idx;
+	u->flags		= BCH_BY_INDEX;
+	u->nr_data_types	= BCH_DATA_NR;
+
+	if (!xioctl(fs.ioctl_fd, BCH_IOCTL_DEV_USAGE_V2, u))
+		return u;
+
+	struct bch_ioctl_dev_usage u_v1;
+	if (xioctl(fs.ioctl_fd, BCH_IOCTL_DEV_USAGE, &u_v1))
+		die("BCH_IOCTL_DEV_USAGE_V2 error: %m");
+
+	u->state	= u_v1.state;
+	u->nr_data_types = ARRAY_SIZE(u_v1.d);
+	u->bucket_size	= u_v1.bucket_size;
+	u->nr_buckets	= u_v1.nr_buckets;
+
+	for (unsigned i = 0; i < ARRAY_SIZE(u_v1.d); i++)
+		u->d[i] = u_v1.d[i];
+
+	return u;
 }
 
 static inline struct bch_sb *bchu_read_super(struct bchfs_handle fs, unsigned idx)

libbcachefs/backpointers.c

@@ -136,15 +136,30 @@ static noinline int backpointer_mod_err(struct btree_trans *trans,
 }
 
 int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *trans,
-				struct bkey_i_backpointer *bp_k,
+				struct bpos bucket,
 				struct bch_backpointer bp,
 				struct bkey_s_c orig_k,
 				bool insert)
 {
 	struct btree_iter bp_iter;
 	struct bkey_s_c k;
+	struct bkey_i_backpointer *bp_k;
 	int ret;
 
+	bp_k = bch2_trans_kmalloc_nomemzero(trans, sizeof(struct bkey_i_backpointer));
+	ret = PTR_ERR_OR_ZERO(bp_k);
+	if (ret)
+		return ret;
+
+	bkey_backpointer_init(&bp_k->k_i);
+	bp_k->k.p = bucket_pos_to_bp(trans->c, bucket, bp.bucket_offset);
+	bp_k->v = bp;
+
+	if (!insert) {
+		bp_k->k.type = KEY_TYPE_deleted;
+		set_bkey_val_u64s(&bp_k->k, 0);
+	}
+
 	k = bch2_bkey_get_iter(trans, &bp_iter, BTREE_ID_backpointers,
 			       bp_k->k.p,
 			       BTREE_ITER_INTENT|

libbcachefs/backpointers.h

@@ -63,7 +63,7 @@ static inline struct bpos bucket_pos_to_bp(const struct bch_fs *c,
 	return ret;
 }
 
-int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *, struct bkey_i_backpointer *,
+int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *, struct bpos bucket,
 				struct bch_backpointer, struct bkey_s_c, bool);
 
 static inline int bch2_bucket_backpointer_mod(struct btree_trans *trans,
@@ -72,28 +72,21 @@ static inline int bch2_bucket_backpointer_mod(struct btree_trans *trans,
 				struct bkey_s_c orig_k,
 				bool insert)
 {
-	struct bch_fs *c = trans->c;
-	struct bkey_i_backpointer *bp_k;
-	int ret;
+	if (unlikely(bch2_backpointers_no_use_write_buffer))
+		return bch2_bucket_backpointer_mod_nowritebuffer(trans, bucket, bp, orig_k, insert);
 
-	bp_k = bch2_trans_kmalloc_nomemzero(trans, sizeof(struct bkey_i_backpointer));
-	ret = PTR_ERR_OR_ZERO(bp_k);
-	if (ret)
-		return ret;
+	struct bkey_i_backpointer bp_k;
 
-	bkey_backpointer_init(&bp_k->k_i);
-	bp_k->k.p = bucket_pos_to_bp(c, bucket, bp.bucket_offset);
-	bp_k->v = bp;
+	bkey_backpointer_init(&bp_k.k_i);
+	bp_k.k.p = bucket_pos_to_bp(trans->c, bucket, bp.bucket_offset);
+	bp_k.v = bp;
 
 	if (!insert) {
-		bp_k->k.type = KEY_TYPE_deleted;
-		set_bkey_val_u64s(&bp_k->k, 0);
+		bp_k.k.type = KEY_TYPE_deleted;
+		set_bkey_val_u64s(&bp_k.k, 0);
 	}
 
-	if (unlikely(bch2_backpointers_no_use_write_buffer))
-		return bch2_bucket_backpointer_mod_nowritebuffer(trans, bp_k, bp, orig_k, insert);
-
-	return bch2_trans_update_buffered(trans, BTREE_ID_backpointers, &bp_k->k_i);
+	return bch2_trans_update_buffered(trans, BTREE_ID_backpointers, &bp_k.k_i);
 }
 
 static inline enum bch_data_type bkey_ptr_data_type(enum btree_id btree_id, unsigned level,

libbcachefs/bcachefs.h

@@ -406,7 +406,6 @@ BCH_DEBUG_PARAMS_DEBUG()
 	x(blocked_journal_max_in_flight)	\
 	x(blocked_allocate)			\
 	x(blocked_allocate_open_bucket)		\
-	x(blocked_write_buffer_full)		\
 	x(nocow_lock_contended)
 
 enum bch_time_stats {
@@ -567,32 +566,38 @@ struct bch_dev {
 	struct io_count __percpu *io_done;
 };
 
-enum {
-	/* startup: */
-	BCH_FS_STARTED,
-	BCH_FS_MAY_GO_RW,
-	BCH_FS_RW,
-	BCH_FS_WAS_RW,
-
-	/* shutdown: */
-	BCH_FS_STOPPING,
-	BCH_FS_EMERGENCY_RO,
-	BCH_FS_GOING_RO,
-	BCH_FS_WRITE_DISABLE_COMPLETE,
-	BCH_FS_CLEAN_SHUTDOWN,
-
-	/* fsck passes: */
-	BCH_FS_FSCK_DONE,
-	BCH_FS_INITIAL_GC_UNFIXED,	/* kill when we enumerate fsck errors */
-	BCH_FS_NEED_ANOTHER_GC,
-
-	BCH_FS_NEED_DELETE_DEAD_SNAPSHOTS,
-
-	/* errors: */
-	BCH_FS_ERROR,
-	BCH_FS_TOPOLOGY_ERROR,
-	BCH_FS_ERRORS_FIXED,
-	BCH_FS_ERRORS_NOT_FIXED,
+/*
+ * fsck_done - kill?
+ *
+ * replace with something more general from enumated fsck passes/errors:
+ * initial_gc_unfixed
+ * error
+ * topology error
+ */
+
+#define BCH_FS_FLAGS()			\
+	x(started)			\
+	x(may_go_rw)			\
+	x(rw)				\
+	x(was_rw)			\
+	x(stopping)			\
+	x(emergency_ro)			\
+	x(going_ro)			\
+	x(write_disable_complete)	\
+	x(clean_shutdown)		\
+	x(fsck_done)			\
+	x(initial_gc_unfixed)		\
+	x(need_another_gc)		\
+	x(need_delete_dead_snapshots)	\
+	x(error)			\
+	x(topology_error)		\
+	x(errors_fixed)			\
+	x(errors_not_fixed)
+
+enum bch_fs_flags {
+#define x(n)		BCH_FS_##n,
+	BCH_FS_FLAGS()
+#undef x
 };
 
 struct btree_debug {
@@ -1068,20 +1073,10 @@ static inline void bch2_write_ref_get(struct bch_fs *c, enum bch_write_ref ref)
 #endif
 }
 
-static inline bool __bch2_write_ref_tryget(struct bch_fs *c, enum bch_write_ref ref)
-{
-#ifdef BCH_WRITE_REF_DEBUG
-	return !test_bit(BCH_FS_GOING_RO, &c->flags) &&
-		atomic_long_inc_not_zero(&c->writes[ref]);
-#else
-	return percpu_ref_tryget(&c->writes);
-#endif
-}
-
 static inline bool bch2_write_ref_tryget(struct bch_fs *c, enum bch_write_ref ref)
 {
 #ifdef BCH_WRITE_REF_DEBUG
-	return !test_bit(BCH_FS_GOING_RO, &c->flags) &&
+	return !test_bit(BCH_FS_going_ro, &c->flags) &&
 		atomic_long_inc_not_zero(&c->writes[ref]);
 #else
 	return percpu_ref_tryget_live(&c->writes);
@@ -1100,7 +1095,7 @@ static inline void bch2_write_ref_put(struct bch_fs *c, enum bch_write_ref ref)
 		if (atomic_long_read(&c->writes[i]))
 			return;
 
-	set_bit(BCH_FS_WRITE_DISABLE_COMPLETE, &c->flags);
+	set_bit(BCH_FS_write_disable_complete, &c->flags);
 	wake_up(&bch2_read_only_wait);
 #else
 	percpu_ref_put(&c->writes);

libbcachefs/bcachefs_format.h

@@ -1539,7 +1539,7 @@ struct bch_sb_field_disk_groups {
 	x(move_extent_write,				36)	\
 	x(move_extent_finish,				37)	\
 	x(move_extent_fail,				38)	\
-	x(move_extent_alloc_mem_fail,			39)	\
+	x(move_extent_start_fail,			39)	\
 	x(copygc,					40)	\
 	x(copygc_wait,					41)	\
 	x(gc_gens_end,					42)	\
@@ -1576,7 +1576,9 @@ struct bch_sb_field_disk_groups {
 	x(write_super,					73)	\
 	x(trans_restart_would_deadlock_recursion_limit,	74)	\
 	x(trans_restart_write_buffer_flush,		75)	\
-	x(trans_restart_split_race,			76)
+	x(trans_restart_split_race,			76)	\
+	x(write_buffer_flush_slowpath,			77)	\
+	x(write_buffer_flush_sync,			78)
 
 enum bch_persistent_counters {
 #define x(t, n, ...) BCH_COUNTER_##t,
@@ -2135,8 +2137,7 @@ static inline __u64 __bset_magic(struct bch_sb *sb)
 	x(clock,		7)		\
 	x(dev_usage,		8)		\
 	x(log,			9)		\
-	x(overwrite,		10)		\
-	x(write_buffer_keys,	11)
+	x(overwrite,		10)
 
 enum {
 #define x(f, nr)	BCH_JSET_ENTRY_##f	= nr,