service/oss: use devd for device monitoring

Author: charlesrocket

src/services/oss/oss.cpp

@@ -1,29 +1,40 @@
 #include "oss.hpp"
 #include <algorithm>
+#include <array>
 #include <cerrno>
 #include <cstdlib>
 #include <cstring>
 #include <utility>
 
 #include <QFile>
 #include <QProcess>
+#include <QSocketNotifier>
 #include <QTextStream>
 #include <fcntl.h>
 #include <qalgorithms.h>
 #include <qlist.h>
 #include <qlogging.h>
+#include <qloggingcategory.h>
 #include <qobject.h>
 #include <qtimer.h>
 #include <qtmetamacros.h>
 #ifdef __FreeBSD__
 #include <sys/ioccom.h>
+#include <sys/socket.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
+#include <sys/un.h>
 #endif
 #include <sys/ioctl.h>
 #include <sys/soundcard.h>
 #include <unistd.h>
 
+#include "../../core/logcat.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logPolkit, "quickshell.service.oss", QtWarningMsg);
+}
+
 namespace qs::service::oss {
 
 // OSSMixerControl Implementation
@@ -86,7 +97,7 @@ bool OSSMixerControl::updateValue() {
 	auto fd = open(mixerPath.toUtf8().constData(), O_RDONLY);
 
 	if (fd < 0) {
-		qWarning() << "Failed to open mixer device:" << mixerPath;
+		qCWarning(logPolkit) << "Failed to open mixer device:" << mixerPath;
 		return false;
 	}
 
@@ -126,7 +137,7 @@ bool OSSMixerControl::writeValue() {
 	auto fd = open(mixerPath.toUtf8().constData(), O_WRONLY);
 
 	if (fd < 0) {
-		qWarning() << "Failed to open mixer device for writing:" << mixerPath;
+		qCWarning(logPolkit) << "Failed to open mixer device for writing:" << mixerPath;
 		return false;
 	}
 
@@ -136,7 +147,7 @@ bool OSSMixerControl::writeValue() {
 
 	if (ioctl(fd, MIXER_WRITE(this->mMixerId), &value) < 0) { // NOLINT
 		close(fd);
-		qWarning() << "Failed to write mixer value for control:" << this->mName;
+		qCWarning(logPolkit) << "Failed to write mixer value for control:" << this->mName;
 		return false;
 	}
 
@@ -164,8 +175,8 @@ bool OSSSoundDevice::initialize() {
 	auto fd = open(mixerPath.toUtf8().constData(), O_RDONLY);
 
 	if (fd < 0) {
-		qWarning() << "OSS: Failed to open mixer device:" << mixerPath
-		           << "error:" << qt_error_string(errno);
+		qCWarning(logPolkit) << "Failed to open mixer device:" << mixerPath
+		                     << "error:" << qt_error_string(errno);
 		return false;
 	}
 
@@ -174,7 +185,7 @@ bool OSSSoundDevice::initialize() {
 	if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &devmask) >= 0) { // NOLINT
 		this->loadControls();
 	} else {
-		qWarning() << "OSS: Failed to read devmask for" << mixerPath;
+		qCWarning(logPolkit) << "Failed to read devmask for" << mixerPath;
 		close(fd);
 		return false;
 	}
@@ -212,7 +223,7 @@ bool OSSSoundDevice::initialize() {
 
 		sndstat.close();
 	} else {
-		qWarning() << "OSS: Could not open /dev/sndstat";
+		qCWarning(logPolkit) << "Could not open /dev/sndstat";
 	}
 
 	close(fd);
@@ -287,17 +298,30 @@ QList<QObject*> OSSSoundDevice::controls() const {
 }
 
 // OSS Implementation
-OSS::OSS(QObject* parent): QObject(parent), mPollTimer(new QTimer(this)) {
+OSS::OSS(QObject* parent): QObject(parent), mRescanTimer(new QTimer(this)) {
 	if (QFile::exists("/dev/sndstat")) {
 		this->mAvailable = true;
 
 		this->scanDevices();
 		this->updateDefault();
 
-		connect(this->mPollTimer, &QTimer::timeout, this, &OSS::refresh);
-		this->mPollTimer->start(5000);
+		this->mRescanTimer->setSingleShot(true);
+		this->mRescanTimer->setInterval(100); // debounce
+
+		connect(this->mRescanTimer, &QTimer::timeout, this, [this]() {
+			this->scanDevices();
+			this->updateDefault();
+		});
+
+		this->connectToDevd();
 	} else {
-		qWarning() << "OSS sound system is not available";
+		qCWarning(logPolkit) << "OSS sound system is not available";
+	}
+}
+
+OSS::~OSS() {
+	if (this->mDevdSocket >= 0) {
+		close(this->mDevdSocket);
 	}
 }
 
@@ -315,6 +339,113 @@ QList<QObject*> OSS::devices() const {
 OSSSoundDevice* OSS::defaultDevice() const { return this->mDefaultDevice; }
 bool OSS::isAvailable() const { return this->mAvailable; }
 
+void OSS::connectToDevd() {
+	// clang-format off
+	#ifdef __FreeBSD__
+	// Try seqpacket first
+	const char* pipePaths[] = {
+	    "/var/run/devd.seqpacket.pipe",
+	    "/var/run/devd.pipe",
+	};
+
+	for (const auto* path: pipePaths) {
+		if (!QFile::exists(path)) {
+			qCInfo(logPolkit) << "devd pipe" << path << "does not exist, trying next";
+			continue;
+		}
+
+		this->mDevdSocket = socket(PF_UNIX, SOCK_SEQPACKET, 0);
+		if (this->mDevdSocket < 0) {
+			this->mDevdSocket = socket(PF_UNIX, SOCK_STREAM, 0);
+		}
+
+		if (this->mDevdSocket < 0) {
+			qCWarning(logPolkit) << "Failed to create socket for devd:" << qt_error_string(errno);
+			continue;
+		}
+
+		struct sockaddr_un addr = {};
+		addr.sun_family = AF_UNIX;
+		strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
+
+		if (::connect(this->mDevdSocket, (struct sockaddr*) &addr, SUN_LEN(&addr)) == 0) {
+			int flags = fcntl(this->mDevdSocket, F_GETFL, 0);
+			fcntl(this->mDevdSocket, F_SETFL, flags | O_NONBLOCK);
+
+			this->mDevdNotifier = new QSocketNotifier(this->mDevdSocket, QSocketNotifier::Read, this);
+			connect(this->mDevdNotifier, &QSocketNotifier::activated, this, &OSS::handleDevdEvent);
+
+			this->mDevdNotifier->setEnabled(true);
+			qCInfo(logPolkit) << "Successfully connected to devd at" << path;
+
+			return;
+		} else {
+			qCWarning(logPolkit) << "Failed to connect to" << path << ":" << qt_error_string(errno);
+		}
+
+		close(this->mDevdSocket);
+		this->mDevdSocket = -1;
+	}
+
+	qCWarning(logPolkit) << "Failed to connect to a devd pipe—device monitoring disabled";
+	#else
+	qCInfo(logPolkit) << "devd monitoring only available on FreeBSD";
+	#endif
+	// clang-format on
+	(void) this;
+}
+
+void OSS::handleDevdEvent() {
+	std::array<char, 4096> buffer {};
+	const ssize_t n = read(this->mDevdSocket, buffer.data(), buffer.size() - 1);
+
+	if (n <= 0) {
+		if (n < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
+			qCWarning(logPolkit) << "devd socket read error:" << qt_error_string(errno);
+		}
+		return;
+	}
+
+	buffer[n] = '\0';
+
+	const std::array<const char*, 4> audioKeywords = {"dsp", "mixer", "pcm", "snd"};
+	bool isAudioRelated = false;
+
+	for (const auto* keyword: audioKeywords) {
+		if (strstr(buffer.data(), keyword) != nullptr) {
+			isAudioRelated = true;
+			break;
+		}
+	}
+
+	if (!isAudioRelated) {
+		return; // Skip non-audio events
+	}
+
+	const QString event = QString::fromUtf8(buffer.data());
+
+	bool needsRescan = false;
+
+	if (event.contains("system=DEVFS")
+	    && (event.contains("cdev=dsp") || event.contains("cdev=mixer") || event.contains("cdev=snd")
+	        || event.contains("cdev=pcm")))
+	{
+
+		qCInfo(logPolkit) << "Audio device event detected, scheduling rescan";
+		needsRescan = true;
+	}
+
+	if (event.contains("hw.snd.default_unit")) {
+		qCInfo(logPolkit) << "Default device changed, scheduling update";
+		needsRescan = true;
+	}
+
+	// Prevent multiple rapid rescans when devices are changing quickly
+	if (needsRescan && !this->mRescanTimer->isActive()) {
+		this->mRescanTimer->start();
+	}
+}
+
 void OSS::scanDevices() {
 	if (this->mDefaultDevice != nullptr) {
 		this->mDefaultDevice = nullptr;
@@ -332,8 +463,9 @@ void OSS::scanDevices() {
 
 			if (device->initialize()) {
 				this->mDevices.append(device);
+				qCInfo(logPolkit) << "Device added:" << device;
 			} else {
-				qWarning() << "OSS: Failed to initialize device:" << mixerPath;
+				qCWarning(logPolkit) << "Failed to initialize device:" << device;
 				delete device;
 			}
 		}
@@ -385,7 +517,7 @@ void OSS::updateDefault() {
 
 		sndstat.close();
 	} else {
-		qWarning() << "OSS: Failed to open /dev/sndstat for reading default device";
+		qCWarning(logPolkit) << "Failed to read default device via /dev/sndstat";
 	}
 
 	if (!newDefault && !this->mDevices.isEmpty()) {
@@ -406,20 +538,22 @@ bool OSS::setDefaultDevice(int deviceId) {
 	#ifdef __FreeBSD__
 	if (sysctlbyname("hw.snd.default_unit", nullptr, nullptr, &deviceId, size) == 0) {
 		this->updateDefault();
+		qCInfo(logPolkit) << "Set default device to" << deviceId;
 		return true;
 	}
 	#else
 	(void)this;
 	(void)size;
 
 	if (!this->mAvailable) {
-		qWarning() << "OSS is not available on this system";
+		qCWarning(logPolkit) << "OSS is not available on this system";
 		return false;
 	}
 	#endif
 	// clang-format on
 
-	qWarning() << "Failed to set default device to" << deviceId << "error:" << qt_error_string(errno);
+	qCWarning(logPolkit) << "Failed to set default device to" << deviceId
+	                     << "error:" << qt_error_string(errno);
 
 	return false;
 }

src/services/oss/oss.hpp

@@ -4,6 +4,7 @@
 
 #include <QObject>
 #include <QQmlEngine>
+#include <QSocketNotifier>
 #include <QString>
 #include <QTimer>
 #include <QVector>
@@ -130,10 +131,12 @@ class OSSSoundDevice: public QObject {
 
 ///! OSS sound system integration (FreeBSD)
 /// Provides access to OSS sound devices and mixer controls.
+/// Uses devd for real-time device change notifications.
 ///
 /// See @@OSSSoundDevice and @@OSSMixerControl for controlling individual devices.
 class OSS: public QObject {
 	Q_OBJECT;
+	Q_DISABLE_COPY_MOVE(OSS);
 	/// All available sound devices
 	Q_PROPERTY(QList<QObject*> devices READ devices NOTIFY devicesChanged);
 	/// The current system default device
@@ -145,6 +148,7 @@ class OSS: public QObject {
 
 public:
 	explicit OSS(QObject* parent = nullptr);
+	~OSS() override;
 
 	[[nodiscard]] QList<QObject*> devices() const;
 	[[nodiscard]] OSSSoundDevice* defaultDevice() const;
@@ -162,11 +166,15 @@ class OSS: public QObject {
 private:
 	void scanDevices();
 	void updateDefault();
+	void connectToDevd();
+	void handleDevdEvent();
 
 	QVector<OSSSoundDevice*> mDevices;
 	OSSSoundDevice* mDefaultDevice = nullptr;
 	bool mAvailable = false;
-	QTimer* mPollTimer;
+	QTimer* mRescanTimer = nullptr;
+	int mDevdSocket = -1;
+	QSocketNotifier* mDevdNotifier = nullptr;
 };
 
 } // namespace qs::service::oss