diff --git a/include/multipass/platform_unix.h b/include/multipass/platform_unix.h
index 981330e894..53e450decc 100644
--- a/include/multipass/platform_unix.h
+++ b/include/multipass/platform_unix.h
@@ -20,23 +20,23 @@
 
 #include <vector>
 
-#include <signal.h>
+#include <csignal>
 
 #include "singleton.h"
 
-#define MP_POSIX_SIGNAL multipass::platform::SignalWrapper::instance()
+#define MP_POSIX_SIGNAL multipass::platform::PosixSignal::instance()
 
 namespace multipass::platform
 {
 
-class SignalWrapper : public Singleton<SignalWrapper>
+class PosixSignal : public Singleton<PosixSignal>
 {
 public:
-    SignalWrapper(const PrivatePass&) noexcept;
+    PosixSignal(const PrivatePass&) noexcept;
 
-    virtual int mask_signals(int how, const sigset_t* sigset, sigset_t* old_set = nullptr) const;
-    virtual int send(pthread_t target, int signal) const;
-    virtual int wait(const sigset_t& sigset, int& got) const;
+    virtual int pthread_sigmask(int how, const sigset_t* sigset, sigset_t* old_set = nullptr) const;
+    virtual int pthread_kill(pthread_t target, int signal) const;
+    virtual int sigwait(const sigset_t& sigset, int& got) const;
 };
 
 sigset_t make_sigset(const std::vector<int>& sigs);
diff --git a/src/platform/platform_unix.cpp b/src/platform/platform_unix.cpp
index d3e02d01eb..32f48227f9 100644
--- a/src/platform/platform_unix.cpp
+++ b/src/platform/platform_unix.cpp
@@ -158,23 +158,23 @@ int mp::platform::symlink_attr_from(const char* path, sftp_attributes_struct* at
     return 0;
 }
 
-mp::platform::SignalWrapper::SignalWrapper(const PrivatePass& pass) noexcept : Singleton(pass)
+mp::platform::PosixSignal::PosixSignal(const PrivatePass& pass) noexcept : Singleton(pass)
 {
 }
 
-int mp::platform::SignalWrapper::mask_signals(int how, const sigset_t* sigset, sigset_t* old_set) const
+int mp::platform::PosixSignal::pthread_sigmask(int how, const sigset_t* sigset, sigset_t* old_set) const
 {
-    return pthread_sigmask(how, sigset, old_set);
+    return ::pthread_sigmask(how, sigset, old_set);
 }
 
-int mp::platform::SignalWrapper::send(pthread_t target, int signal) const
+int mp::platform::PosixSignal::pthread_kill(pthread_t target, int signal) const
 {
-    return pthread_kill(target, signal);
+    return ::pthread_kill(target, signal);
 }
 
-int mp::platform::SignalWrapper::wait(const sigset_t& sigset, int& got) const
+int mp::platform::PosixSignal::sigwait(const sigset_t& sigset, int& got) const
 {
-    return sigwait(std::addressof(sigset), std::addressof(got));
+    return ::sigwait(std::addressof(sigset), std::addressof(got));
 }
 
 sigset_t mp::platform::make_sigset(const std::vector<int>& sigs)
@@ -191,7 +191,7 @@ sigset_t mp::platform::make_sigset(const std::vector<int>& sigs)
 sigset_t mp::platform::make_and_block_signals(const std::vector<int>& sigs)
 {
     auto sigset{make_sigset(sigs)};
-    MP_POSIX_SIGNAL.mask_signals(SIG_BLOCK, &sigset, nullptr);
+    MP_POSIX_SIGNAL.pthread_sigmask(SIG_BLOCK, &sigset, nullptr);
     return sigset;
 }
 
@@ -208,7 +208,8 @@ std::function<std::optional<int>(const std::function<bool()>&)> mp::platform::ma
     return [sigset = make_and_block_signals({SIGQUIT, SIGTERM, SIGHUP, SIGUSR2}),
             period](const std::function<bool()>& condition) -> std::optional<int> {
         // create a timer to periodically send SIGUSR2
-        utils::Timer signal_generator{period, [signalee = pthread_self()] { MP_POSIX_SIGNAL.send(signalee, SIGUSR2); }};
+        utils::Timer signal_generator{period,
+                                      [signalee = pthread_self()] { MP_POSIX_SIGNAL.pthread_kill(signalee, SIGUSR2); }};
 
         // wait on signals and condition
         int latest_signal = SIGUSR2;
@@ -217,7 +218,7 @@ std::function<std::optional<int>(const std::function<bool()>&)> mp::platform::ma
             signal_generator.start();
 
             // can't use sigtimedwait since macOS doesn't support it
-            MP_POSIX_SIGNAL.wait(sigset, latest_signal);
+            MP_POSIX_SIGNAL.sigwait(sigset, latest_signal);
         }
 
         signal_generator.stop();
diff --git a/tests/unix/mock_signal_wrapper.h b/tests/unix/mock_signal_wrapper.h
index 9701f278a0..a668429239 100644
--- a/tests/unix/mock_signal_wrapper.h
+++ b/tests/unix/mock_signal_wrapper.h
@@ -25,16 +25,16 @@
 namespace multipass::test
 {
 
-class MockSignalWrapper : public platform::SignalWrapper
+class MockPosixSignal : public platform::PosixSignal
 {
 public:
-    using SignalWrapper::SignalWrapper;
+    using PosixSignal::PosixSignal;
 
-    MOCK_METHOD(int, mask_signals, (int, const sigset_t*, sigset_t*), (const, override));
-    MOCK_METHOD(int, send, (pthread_t, int), (const, override));
-    MOCK_METHOD(int, wait, (const sigset_t&, int&), (const, override));
+    MOCK_METHOD(int, pthread_sigmask, (int, const sigset_t*, sigset_t*), (const, override));
+    MOCK_METHOD(int, pthread_kill, (pthread_t, int), (const, override));
+    MOCK_METHOD(int, sigwait, (const sigset_t&, int&), (const, override));
 
-    MP_MOCK_SINGLETON_BOILERPLATE(MockSignalWrapper, platform::SignalWrapper);
+    MP_MOCK_SINGLETON_BOILERPLATE(MockPosixSignal, platform::PosixSignal);
 };
 
 } // namespace multipass::test
diff --git a/tests/unix/test_platform_unix.cpp b/tests/unix/test_platform_unix.cpp
index 3a4cc69028..89c83850bd 100644
--- a/tests/unix/test_platform_unix.cpp
+++ b/tests/unix/test_platform_unix.cpp
@@ -199,11 +199,11 @@ TEST_F(TestPlatformUnix, make_sigset_makes_sigset)
 
 TEST_F(TestPlatformUnix, make_and_block_signals_works)
 {
-    auto [mock_signals, guard] = mpt::MockSignalWrapper::inject<StrictMock>();
+    auto [mock_signals, guard] = mpt::MockPosixSignal::inject<StrictMock>();
 
     EXPECT_CALL(
         *mock_signals,
-        mask_signals(SIG_BLOCK, Pointee(Truly([](const auto& set) { return test_sigset_has(set, {SIGINT}); })), _));
+        pthread_sigmask(SIG_BLOCK, Pointee(Truly([](const auto& set) { return test_sigset_has(set, {SIGINT}); })), _));
 
     auto set = mp::platform::make_and_block_signals({SIGINT});
 
@@ -215,25 +215,25 @@ TEST_F(TestPlatformUnix, make_and_block_signals_works)
 
 TEST_F(TestPlatformUnix, make_quit_watchdog_blocks_signals)
 {
-    auto [mock_signals, guard] = mpt::MockSignalWrapper::inject<StrictMock>();
+    auto [mock_signals, guard] = mpt::MockPosixSignal::inject<StrictMock>();
 
     EXPECT_CALL(*mock_signals,
-                mask_signals(SIG_BLOCK,
-                             Pointee(Truly([](const auto& set) {
-                                 return test_sigset_has(set, {SIGQUIT, SIGTERM, SIGHUP, SIGUSR2});
-                             })),
-                             _));
+                pthread_sigmask(SIG_BLOCK,
+                                Pointee(Truly([](const auto& set) {
+                                    return test_sigset_has(set, {SIGQUIT, SIGTERM, SIGHUP, SIGUSR2});
+                                })),
+                                _));
 
     mp::platform::make_quit_watchdog(std::chrono::milliseconds{1});
 }
 
 TEST_F(TestPlatformUnix, quit_watchdog_quits_on_condition)
 {
-    auto [mock_signals, guard] = mpt::MockSignalWrapper::inject<StrictMock>();
+    auto [mock_signals, guard] = mpt::MockPosixSignal::inject<StrictMock>();
 
-    EXPECT_CALL(*mock_signals, mask_signals(SIG_BLOCK, _, _));
-    EXPECT_CALL(*mock_signals, wait(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(SIGUSR2), Return(0)));
-    ON_CALL(*mock_signals, send(pthread_self(), SIGUSR2)).WillByDefault(Return(0));
+    EXPECT_CALL(*mock_signals, pthread_sigmask(SIG_BLOCK, _, _));
+    EXPECT_CALL(*mock_signals, sigwait(_, _)).WillRepeatedly(DoAll(SetArgReferee<1>(SIGUSR2), Return(0)));
+    ON_CALL(*mock_signals, pthread_kill(pthread_self(), SIGUSR2)).WillByDefault(Return(0));
 
     auto watchdog = mp::platform::make_quit_watchdog(std::chrono::milliseconds{1});
     EXPECT_EQ(watchdog([] { return false; }), std::nullopt);
@@ -241,13 +241,13 @@ TEST_F(TestPlatformUnix, quit_watchdog_quits_on_condition)
 
 TEST_F(TestPlatformUnix, quit_watchdog_quits_on_signal)
 {
-    auto [mock_signals, guard] = mpt::MockSignalWrapper::inject<StrictMock>();
+    auto [mock_signals, guard] = mpt::MockPosixSignal::inject<StrictMock>();
 
-    EXPECT_CALL(*mock_signals, mask_signals(SIG_BLOCK, _, _));
-    EXPECT_CALL(*mock_signals, wait(_, _))
+    EXPECT_CALL(*mock_signals, pthread_sigmask(SIG_BLOCK, _, _));
+    EXPECT_CALL(*mock_signals, sigwait(_, _))
         .WillOnce(DoAll(SetArgReferee<1>(SIGUSR2), Return(0)))
         .WillOnce(DoAll(SetArgReferee<1>(SIGTERM), Return(0)));
-    ON_CALL(*mock_signals, send(pthread_self(), SIGUSR2)).WillByDefault(Return(0));
+    ON_CALL(*mock_signals, pthread_kill(pthread_self(), SIGUSR2)).WillByDefault(Return(0));
 
     auto watchdog = mp::platform::make_quit_watchdog(std::chrono::milliseconds{1});
     EXPECT_EQ(watchdog([] { return true; }), SIGTERM);
@@ -255,13 +255,13 @@ TEST_F(TestPlatformUnix, quit_watchdog_quits_on_signal)
 
 TEST_F(TestPlatformUnix, quit_watchdog_signals_itself_asynchronously)
 {
-    auto [mock_signals, guard] = mpt::MockSignalWrapper::inject<StrictMock>();
+    auto [mock_signals, guard] = mpt::MockPosixSignal::inject<StrictMock>();
 
     std::atomic<bool> signaled = false;
     std::atomic<int> times = 0;
 
-    EXPECT_CALL(*mock_signals, mask_signals(SIG_BLOCK, _, _));
-    EXPECT_CALL(*mock_signals, wait(_, _))
+    EXPECT_CALL(*mock_signals, pthread_sigmask(SIG_BLOCK, _, _));
+    EXPECT_CALL(*mock_signals, sigwait(_, _))
         .WillRepeatedly(DoAll(
             [&signaled, &times] {
                 // busy wait until signaled
@@ -275,7 +275,7 @@ TEST_F(TestPlatformUnix, quit_watchdog_signals_itself_asynchronously)
             SetArgReferee<1>(SIGUSR2),
             Return(0)));
 
-    EXPECT_CALL(*mock_signals, send(pthread_self(), SIGUSR2))
+    EXPECT_CALL(*mock_signals, pthread_kill(pthread_self(), SIGUSR2))
         .WillRepeatedly(DoAll([&signaled] { signaled.store(true, std::memory_order_release); }, Return(0)));
 
     auto watchdog = mp::platform::make_quit_watchdog(std::chrono::milliseconds{1});