roots: reimplement transid_max_nocache using extent tree root

Commit 9a97699dd9 upstream.

This commit accidentally fixes a bug where we call btrfs_get_root_transid
with BTRFS_FS_TREE_OBJECTID instead of m_ctx->root_fd().  This leads
to storms of messages like this:

	crawl_transid[5334]: exception type std::system_error: BTRFS_IOC_INO_LOOKUP: rv = readlink(path.c_str(), buf, size + 1): No such file or directory at fs.cc:430: No such file or directory

The code was working before because BTRFS_FS_TREE_OBJECTID == 5.
bees is constantly opening files, and the Linux kernel fills in unused
fd numbers starting from 0, so it's quite likely that the process has fd
5 open to some existing file somewhere on the target btrfs filesystem
most of the time.  If fd 5 is closed, or if it is open to an orphan
file (one without an existing name), the ioctl in btrfs_get_root_id
(called by btrfs_get_root_transid) will fail and throw and exception.
The exception breaks out of the crawl_transid task before it can do any
scanning work, so bees will stop deduping until FD 5 is open again with
an existing file.  This can only happen if other threads are opening
files, so if bees is idle at the instant when this failure occurs,
it will never dedupe again until the process is terminated and restarted.

The remainder is the original commit message:

ROOT_TREE contains the ROOT_ITEM for EXTENT_TREE.  Every modification
(that we care about) to a btrfs must go through EXTENT_TREE, and must
modify the page in ROOT_TREE pointing to the root of EXTENT_TREE...
which makes that a very good source for the filesystem transid.

Remove the loop and the root lookups, and just look at one item for
max_transid.

Also note that every caller of transid_max_nocache() immediately
feeds the return value to m_transid_re.update(), so don't do that
inside transid_max_nocache().

Signed-off-by: Zygo Blaxell <bees@furryterror.org>

src/bees-context.cc

@@ -773,11 +773,42 @@ BeesResolveAddrResult::BeesResolveAddrResult()
 {
 }
 
+void
+BeesContext::wait_for_balance()
+{
+	Timer balance_timer;
+	BEESNOTE("WORKAROUND: waiting for balance to stop");
+	while (true) {
+		btrfs_ioctl_balance_args args;
+		memset_zero<btrfs_ioctl_balance_args>(&args);
+		const int ret = ioctl(root_fd(), BTRFS_IOC_BALANCE_PROGRESS, &args);
+		if (ret < 0) {
+			// Either can't get balance status or not running, exit either way
+			break;
+		}
+
+		if (!(args.state & BTRFS_BALANCE_STATE_RUNNING)) {
+			// Balance not running, doesn't matter if paused or cancelled
+			break;
+		}
+
+		BEESLOGDEBUG("WORKAROUND: Waiting " << balance_timer << "s for balance to stop");
+		sleep(BEES_BALANCE_POLL_INTERVAL);
+	}
+}
+
 BeesResolveAddrResult
 BeesContext::resolve_addr_uncached(BeesAddress addr)
 {
 	THROW_CHECK1(invalid_argument, addr, !addr.is_magic());
 	THROW_CHECK0(invalid_argument, !!root_fd());
+
+	// Is there a bug where resolve and balance cause a crash (BUG_ON at fs/btrfs/ctree.c:1227)?
+	// Apparently yes, and more than one.
+	// Wait for the balance to finish before we run LOGICAL_INO
+	wait_for_balance();
+
+	// Time how long this takes
 	Timer resolve_timer;
 
 	// There is no performance benefit if we restrict the buffer size.

src/bees-roots.cc

@@ -207,19 +207,15 @@ uint64_t
 BeesRoots::transid_max_nocache()
 {
 	uint64_t rv = 0;
-	uint64_t root = BTRFS_FS_TREE_OBJECTID;
+	BEESNOTE("Calculating transid_max");
-	BEESNOTE("Calculating transid_max (" << rv << " as of root " << root << ")");
+	BEESTRACE("Calculating transid_max");
-	BEESTRACE("Calculating transid_max...");
-
-	rv = btrfs_get_root_transid(root);
-
-	// XXX:  Do we need any of this?  Or is
-	// m_transid_re.update(btrfs_get_root_transid(BTRFS_FS_TREE_OBJECTID)) good enough?
 
+	// We look for the root of the extent tree and read its transid.
+	// Should run in O(1) time and be fairly reliable.
 	BtrfsIoctlSearchKey sk;
 	sk.tree_id = BTRFS_ROOT_TREE_OBJECTID;
-	sk.min_type = sk.max_type = BTRFS_ROOT_BACKREF_KEY;
+	sk.min_type = sk.max_type = BTRFS_ROOT_ITEM_KEY;
-	sk.min_objectid = root;
+	sk.min_objectid = sk.max_objectid = BTRFS_EXTENT_TREE_OBJECTID;
 
 	while (true) {
 		sk.nr_items = 1024;
@@ -229,21 +225,18 @@ BeesRoots::transid_max_nocache()
 			break;
 		}
 
+		// We are just looking for the highest transid on the filesystem.
+		// We don't care which object it comes from.
 		for (auto i : sk.m_result) {
 			sk.next_min(i);
-			if (i.type == BTRFS_ROOT_BACKREF_KEY) {
-				if (i.transid > rv) {
-					BEESLOGDEBUG("transid_max root " << i.objectid << " parent " << i.offset << " transid " << i.transid);
-					BEESCOUNT(transid_max_miss);
-				}
-				root = i.objectid;
-			}
 			if (i.transid > rv) {
 				rv = i.transid;
 			}
 		}
 	}
-	m_transid_re.update(rv);
+
+	// transid must be greater than zero, or we did something very wrong
+	THROW_CHECK1(runtime_error, rv, rv > 0);
 	return rv;
 }
 

src/bees.cc

@@ -667,6 +667,7 @@ bees_main(int argc, char *argv[])
 	unsigned thread_min = 0;
 	double load_target = 0;
 	bool workaround_btrfs_send = false;
+	BeesRoots::ScanMode root_scan_mode = BeesRoots::SCAN_MODE_ZERO;
 
 	// Configure getopt_long
 	static const struct option long_options[] = {
@@ -735,7 +736,7 @@ bees_main(int argc, char *argv[])
 				load_target = stod(optarg);
 				break;
 			case 'm':
-				bc->roots()->set_scan_mode(static_cast<BeesRoots::ScanMode>(stoul(optarg)));
+				root_scan_mode = static_cast<BeesRoots::ScanMode>(stoul(optarg));
 				break;
 			case 'p':
 				crucible::set_relative_path("");
@@ -806,11 +807,16 @@ bees_main(int argc, char *argv[])
 	BEESLOGNOTICE("setting worker thread pool maximum size to " << thread_count);
 	TaskMaster::set_thread_count(thread_count);
 
+	// Set root path
+	string root_path = argv[optind++];
+	BEESLOGNOTICE("setting root path to '" << root_path << "'");
+	bc->set_root_path(root_path);
+
 	// Workaround for btrfs send
 	bc->roots()->set_workaround_btrfs_send(workaround_btrfs_send);
 
-	// Create a context and start crawlers
+	// Set root scan mode
-	bc->set_root_path(argv[optind++]);
+	bc->roots()->set_scan_mode(root_scan_mode);
 
 	BeesThread status_thread("status", [&]() {
 		bc->dump_status();

src/bees.h

@@ -117,6 +117,9 @@ const size_t BEES_TRANSID_FACTOR = 10;
 // The actual limit in LOGICAL_INO seems to be 2730, but let's leave a little headroom
 const size_t BEES_MAX_EXTENT_REF_COUNT = 2560;
 
+// Wait this long for a balance to stop
+const double BEES_BALANCE_POLL_INTERVAL = 60.0;
+
 // Flags
 const int FLAGS_OPEN_COMMON   = O_NOFOLLOW | O_NONBLOCK | O_CLOEXEC | O_NOATIME | O_LARGEFILE | O_NOCTTY;
 const int FLAGS_OPEN_DIR      = FLAGS_OPEN_COMMON | O_RDONLY | O_DIRECTORY;
@@ -716,6 +719,7 @@ class BeesContext : public enable_shared_from_this<BeesContext> {
 	void set_root_fd(Fd fd);
 
 	BeesResolveAddrResult resolve_addr_uncached(BeesAddress addr);
+	void wait_for_balance();
 
 	BeesFileRange scan_one_extent(const BeesFileRange &bfr, const Extent &e);
 	void rewrite_file_range(const BeesFileRange &bfr);