Instance: move the /dev/cachefiles code to class DevCachefiles

Author: MaxKellermann

src/Cull.cxx

@@ -4,6 +4,7 @@
 
 #include "Cull.hxx"
 #include "Walk.hxx"
+#include "DevCachefiles.hxx"
 #include "io/uring/CoOperation.hxx"
 #include "system/Error.hxx"
 #include "co/InvokeTask.hxx"
@@ -73,7 +74,7 @@ class Cull::Operation final
 };
 
 Cull::Cull(EventLoop &event_loop, Uring::Queue &_uring,
-	   FileDescriptor _dev_cachefiles,
+	   DevCachefiles &_dev_cachefiles,
 	   uint_least64_t _cull_files, std::size_t _cull_bytes,
 	   Callback _callback)
 	:uring(_uring), dev_cachefiles(_dev_cachefiles),

src/Cull.hxx

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "DevCachefiles.hxx"
 #include "WHandler.hxx"
 #include "Chdir.hxx"
 #include "event/DeferEvent.hxx"
@@ -20,6 +19,7 @@
 
 namespace Co { class InvokeTask; }
 namespace Uring { class Queue; }
+class DevCachefiles;
 class Walk;
 class WalkDirectoryRef;
 
@@ -30,7 +30,7 @@ class WalkDirectoryRef;
  */
 class Cull final : WalkHandler {
 	Uring::Queue ů
-	DevCachefiles dev_cachefiles;
+	DevCachefiles &dev_cachefiles;
 
 	using Callback = BoundMethod<void() noexcept>;
 	const Callback callback;
@@ -56,7 +56,7 @@ class Cull final : WalkHandler {
 public:
 	[[nodiscard]]
 	Cull(EventLoop &event_loop, Uring::Queue &_uring,
-	     FileDescriptor _dev_cachefiles,
+	     DevCachefiles &_dev_cachefiles,
 	     std::size_t _cull_files, uint_least64_t _cull_bytes,
 	     Callback _callback);
 	~Cull() noexcept;

src/DevCachefiles.cxx

@@ -3,12 +3,54 @@
 // author: Max Kellermann <max.kellermann@ionos.com>
 
 #include "DevCachefiles.hxx"
+#include "io/UniqueFileDescriptor.hxx"
+#include "util/IterableSplitString.hxx"
 #include "util/SpanCast.hxx"
+#include "util/StringSplit.hxx"
 
 #include <fmt/core.h>
 
 #include <string.h> // for strerror()
 
+using std::string_view_literals::operator""sv;
+
+DevCachefiles::DevCachefiles(EventLoop &event_loop, UniqueFileDescriptor _fd,
+			     BoundMethod<void() noexcept> _cull_callback) noexcept
+	:device(event_loop, BIND_THIS_METHOD(OnDeviceReady), _fd.Release()),
+	 cull_callback(_cull_callback)
+{
+	device.ScheduleRead();
+}
+
+DevCachefiles::~DevCachefiles() noexcept
+{
+	device.Close();
+}
+
+void
+DevCachefiles::OnDeviceReady([[maybe_unused]] unsigned events) noexcept
+{
+	char buffer[1024];
+	ssize_t nbytes = GetFileDescriptor().Read(std::as_writable_bytes(std::span{buffer}));
+	if (nbytes <= 0) {
+		// TODO
+		Disable();
+		return;
+	}
+
+	const std::string_view line{buffer, static_cast<std::size_t>(nbytes)};
+
+	bool start_cull = false;
+	for (const std::string_view i : IterableSplitString(line, ' ')) {
+		const auto [name, value] = Split(i, '=');
+		if (name == "cull"sv)
+			start_cull = value != "0"sv;
+	}
+
+	if (start_cull)
+		cull_callback();
+}
+
 std::span<const std::byte>
 DevCachefiles::FormatCullFile(Buffer &buffer, std::string_view filename) noexcept
 {

src/DevCachefiles.hxx

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "io/FileDescriptor.hxx"
+#include "event/PipeEvent.hxx"
 #include "util/StringBuffer.hxx"
 
 #include <cstddef>
@@ -13,22 +13,32 @@
 
 #include <limits.h> // for NAME_MAX
 
+class UniqueFileDescriptor;
+
 /**
  * OO wrapper for a /dev/cachefiles file descriptor (non-owning).
  */
 class DevCachefiles {
-	FileDescriptor fd;
+	PipeEvent device;
+
+	BoundMethod<void() noexcept> cull_callback;
 
 public:
 	[[nodiscard]]
-	explicit DevCachefiles(FileDescriptor _fd) noexcept
-		:fd(_fd) {}
+	DevCachefiles(EventLoop &event_loop, UniqueFileDescriptor _fd,
+		      BoundMethod<void() noexcept> _cull_callback) noexcept;
+
+	~DevCachefiles() noexcept;
 
 	DevCachefiles(const DevCachefiles &) = delete;
 	DevCachefiles &operator=(const DevCachefiles &) = delete;
 
 	FileDescriptor GetFileDescriptor() const noexcept {
-		return fd;
+		return device.GetFileDescriptor();
+	}
+
+	void Disable() noexcept {
+		device.Cancel();
 	}
 
 	using Buffer = StringBuffer<NAME_MAX + 8>;
@@ -43,4 +53,7 @@ public:
 
 	[[nodiscard]]
 	static CullResult CheckCullFileResult(std::string_view filename, int res) noexcept;
+
+private:
+	void OnDeviceReady(unsigned events) noexcept;
 };

src/Instance.hxx

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "DevCachefiles.hxx"
 #include "Cull.hxx"
 #include "event/Loop.hxx"
 #include "event/PipeEvent.hxx"
@@ -29,7 +30,7 @@ class Instance {
 
 	UniqueFileDescriptor cache_fd, graveyard_fd;
 
-	PipeEvent dev_cachefiles{event_loop, BIND_THIS_METHOD(OnDevCachefiles)};
+	DevCachefiles dev_cachefiles;
 
 	std::optional<Cull> cull;
 
@@ -44,14 +45,13 @@ public:
 	void Run();
 
 private:
-	void OnDevCachefiles(unsigned events) noexcept;
-
+	void OnCull() noexcept;
 	void StartCull();
 	void OnCullComplete() noexcept;
 
 	void OnShutdown() noexcept {
 		cull.reset();
-		dev_cachefiles.Cancel();
+		dev_cachefiles.Disable();
 
 #ifdef HAVE_LIBSYSTEMD
 		systemd_watchdog.Disable();

src/Main.cxx

@@ -9,10 +9,8 @@
 #include "system/SetupProcess.hxx"
 #include "io/Open.hxx"
 #include "io/uring/Queue.hxx"
-#include "util/IterableSplitString.hxx"
 #include "util/PrintException.hxx"
 #include "util/SpanCast.hxx"
-#include "util/StringSplit.hxx"
 #include "config.h"
 
 #include <fmt/core.h>
@@ -55,15 +53,13 @@ OpenDevCachefiles(const Config &config)
 
 inline
 Instance::Instance(const Config &config)
-	:brun(config.brun), frun(config.frun),
+	:dev_cachefiles(event_loop, OpenDevCachefiles(config), BIND_THIS_METHOD(OnCull)),
+	 brun(config.brun), frun(config.frun),
 	 culling_disabled(config.culling_disabled)
 {
 	event_loop.EnableUring(16384, IORING_SETUP_SINGLE_ISSUER|IORING_SETUP_COOP_TASKRUN);
 	event_loop.GetUring()->SetMaxWorkers(16, 16);
 
-	dev_cachefiles.Open(OpenDevCachefiles(config).Release());
-	dev_cachefiles.ScheduleRead();
-
 	const auto fscache_fd = OpenPath(config.dir.c_str(), O_DIRECTORY);
 	cache_fd = OpenPath(fscache_fd, "cache", O_DIRECTORY);
 	graveyard_fd = OpenPath(fscache_fd, "graveyard", O_DIRECTORY);
@@ -76,7 +72,6 @@ Instance::Instance(const Config &config)
 inline
 Instance::~Instance() noexcept
 {
-	dev_cachefiles.Close();
 }
 
 inline void
@@ -101,7 +96,7 @@ Instance::StartCull()
 	fmt::print(stderr, "Cull: start files={} bytes={}\n", cull_files, cull_bytes);
 
 	cull.emplace(event_loop, *event_loop.GetUring(),
-		     dev_cachefiles.GetFileDescriptor(),
+		     dev_cachefiles,
 		     cull_files, cull_bytes, BIND_THIS_METHOD(OnCullComplete));
 	cull->Start(cache_fd);
 }
@@ -110,31 +105,12 @@ inline void
 Instance::OnCullComplete() noexcept
 {
 	cull.reset();
-
-	dev_cachefiles.ScheduleRead();
 }
 
 inline void
-Instance::OnDevCachefiles([[maybe_unused]] unsigned events) noexcept
+Instance::OnCull() noexcept
 {
-	char buffer[1024];
-	ssize_t nbytes = dev_cachefiles.GetFileDescriptor().Read(std::as_writable_bytes(std::span{buffer}));
-	if (nbytes <= 0) {
-		// TODO
-		dev_cachefiles.CancelRead();
-		return;
-	}
-
-	const std::string_view line{buffer, static_cast<std::size_t>(nbytes)};
-
-	bool start_cull = false;
-	for (const std::string_view i : IterableSplitString(line, ' ')) {
-		const auto [name, value] = Split(i, '=');
-		if (name == "cull"sv)
-			start_cull = value != "0"sv;
-	}
-
-	if (start_cull && !cull && !culling_disabled)
+	if (!cull && !culling_disabled)
 		StartCull();
 }
 

test/RunCull.cxx

@@ -3,6 +3,7 @@
 // author: Max Kellermann <max.kellermann@ionos.com>
 
 #include "Cull.hxx"
+#include "DevCachefiles.hxx"
 #include "event/Loop.hxx"
 #include "event/ShutdownListener.hxx"
 #include "system/Error.hxx"
@@ -39,7 +40,7 @@ struct Instance final {
 	EventLoop event_loop;
 	ShutdownListener shutdown_listener{event_loop, BIND_THIS_METHOD(OnShutdown)};
 
-	const UniqueFileDescriptor dev_cachefiles = OpenDevCachefiles();
+	DevCachefiles dev_cachefiles{event_loop, OpenDevCachefiles(), BIND_THIS_METHOD(OnCull)};
 
 	std::optional<Cull> cull;
 
@@ -56,6 +57,8 @@ struct Instance final {
 		cull.reset();
 	}
 
+	void OnCull() noexcept {}
+
 	void OnCullComplete() noexcept {
 		cull.reset();
 		shutdown_listener.Disable();