Logging system rewritten

GUI doesn't freeze anymore
Some things simplified

Utilities/Log.cpp

@@ -1,6 +1,4 @@
-#include "stdafx.h"
+#include "stdafx.h"
-#include <iostream>
-#include <cinttypes>
 #include "Thread.h"
 #include "File.h"
 #include "Log.h"
@@ -9,257 +7,144 @@
 #include <Windows.h>
 #endif
 
-using namespace Log;
+namespace _log
-
-std::unique_ptr<LogManager> g_log_manager;
-
-u32 LogMessage::size() const
 {
-	//1 byte for NULL terminator
+	logger& get_logger()
-	return (u32)(sizeof(LogMessage::size_type) + sizeof(LogType) + sizeof(Severity) + sizeof(std::string::value_type) * mText.size() + 1);
-}
-
-void LogMessage::serialize(char *output) const
-{
-	LogMessage::size_type size = this->size();
-	memcpy(output, &size, sizeof(LogMessage::size_type));
-	output += sizeof(LogMessage::size_type);
-	memcpy(output, &mType, sizeof(LogType));
-	output += sizeof(LogType);
-	memcpy(output, &mServerity, sizeof(Severity));
-	output += sizeof(Severity);
-	memcpy(output, mText.c_str(), mText.size() );
-	output += sizeof(std::string::value_type)*mText.size();
-	*output = '\0';
-
-}
-LogMessage LogMessage::deserialize(char *input, u32* size_out)
-{
-	LogMessage msg;
-	LogMessage::size_type msgSize = *(reinterpret_cast<LogMessage::size_type*>(input));
-	input += sizeof(LogMessage::size_type);
-	msg.mType = *(reinterpret_cast<LogType*>(input));
-	input += sizeof(LogType);
-	msg.mServerity = *(reinterpret_cast<Severity*>(input));
-	input += sizeof(Severity);
-	if (msgSize > 9000)
 	{
-		int wtf = 6;
+		// Use magic static for global logger instance
+		static logger instance;
+		return instance;
 	}
-	msg.mText.append(input, msgSize - 1 - sizeof(Severity) - sizeof(LogType));
+
-	if (size_out){(*size_out) = msgSize;}
+	file_listener g_log_file(_PRGNAME_ ".log");
-	return msg;
+
+	file_writer g_tty_file("TTY.log");
+
+	channel GENERAL("", level::notice);
+	channel LOADER("LDR", level::notice);
+	channel MEMORY("MEM", level::notice);
+	channel RSX("RSX", level::notice);
+	channel HLE("HLE", level::notice);
+	channel PPU("PPU", level::notice);
+	channel SPU("SPU", level::notice);
+	channel ARMv7("ARMv7");
 }
 
-
+_log::listener::listener()
-
-LogChannel::LogChannel() : LogChannel("unknown")
-{}
-
-LogChannel::LogChannel(const std::string& name) :
-	  name(name)
-	, mEnabled(true)
-	, mLogLevel(Severity::Warning)
-{}
-
-void LogChannel::log(const LogMessage &msg)
 {
-	std::lock_guard<std::mutex> lock(mListenerLock);
+	// Register self
-	for (auto &listener : mListeners)
+	get_logger().add_listener(this);
+}
+
+_log::listener::~listener()
+{
+	// Unregister self
+	get_logger().remove_listener(this);
+}
+
+_log::channel::channel(const std::string& name, _log::level init_level)
+	: name{ name }
+	, enabled{ init_level }
+{
+	// TODO: register config property "name" associated with "enabled" member
+}
+
+void _log::logger::add_listener(_log::listener* listener)
+{
+	std::lock_guard<shared_mutex> lock(m_mutex);
+
+	m_listeners.emplace(listener);
+}
+
+void _log::logger::remove_listener(_log::listener* listener)
+{
+	std::lock_guard<shared_mutex> lock(m_mutex);
+
+	m_listeners.erase(listener);
+}
+
+void _log::logger::broadcast(const _log::channel& ch, _log::level sev, const std::string& text) const
+{
+	reader_lock lock(m_mutex);
+
+	for (auto listener : m_listeners)
 	{
-		listener->log(msg);
+		listener->log(ch, sev, text);
 	}
 }
 
-void LogChannel::addListener(std::shared_ptr<LogListener> listener)
+void _log::broadcast(const _log::channel& ch, _log::level sev, const std::string& text)
 {
-	std::lock_guard<std::mutex> lock(mListenerLock);
+	get_logger().broadcast(ch, sev, text);
-	mListeners.insert(listener);
-}
-void LogChannel::removeListener(std::shared_ptr<LogListener> listener)
-{
-	std::lock_guard<std::mutex> lock(mListenerLock);
-	mListeners.erase(listener);
 }
 
-struct CoutListener : LogListener
+_log::file_writer::file_writer(const std::string& name)
 {
-	void log(const LogMessage &msg) override
+	try
 	{
-		std::cerr << msg.mText << std::endl;
+		if (!m_file.open(fs::get_config_dir() + name, fom::rewrite | fom::append))
-	}
-};
-
-struct FileListener : LogListener
-{
-	fs::file mFile;
-	bool mPrependChannelName;
-
-	FileListener(const std::string& name = _PRGNAME_ ".log", bool prependChannel = true)
-		: mFile(fs::get_config_dir() + name, fom::rewrite)
-		, mPrependChannelName(prependChannel)
-	{
-		if (!mFile)
 		{
+			throw EXCEPTION("Can't create log file %s (error %d)", name, errno);
+		}
+	}
+	catch (const fmt::exception& e)
+	{
 #ifdef _WIN32
-			MessageBoxA(0, ("Can't create log file: " + name).c_str(), "Error", MB_ICONERROR);
+		MessageBoxA(0, e.what(), "_log::file_writer() failed", MB_ICONERROR);
 #else
-			std::printf("Can't create log file: %s\n", name.c_str());
+		std::printf("_log::file_writer() failed: %s\n", e.what());
 #endif
-		}
 	}
+}
 
-	void log(const LogMessage &msg) override
+void _log::file_writer::log(const std::string& text)
+{
+	m_file.write(text);
+}
+
+std::size_t _log::file_writer::size() const
+{
+	return m_file.seek(0, fs::seek_cur);
+}
+
+void _log::file_listener::log(const _log::channel& ch, _log::level sev, const std::string& text)
+{
+	std::string msg; msg.reserve(text.size() + 200);
+
+	// Used character: U+00B7 (Middle Dot)
+	switch (sev)
 	{
-		std::string text = msg.mText;
+	case level::always:  msg = u8"·A "; break;
-		if (mPrependChannelName)
+	case level::fatal:   msg = u8"·F "; break;
-		{
+	case level::error:   msg = u8"·E "; break;
-			text.insert(0, gTypeNameTable[static_cast<u32>(msg.mType)].mName);
+	case level::todo:    msg = u8"·U "; break;
-			
+	case level::success: msg = u8"·S "; break;
-			if (msg.mType == Log::TTY)
+	case level::warning: msg = u8"·W "; break;
-			{
+	case level::notice:  msg = u8"·! "; break;
-				text = fmt::escape(text);
+	case level::trace:   msg = u8"·T "; break;
-				if (text[text.length() - 1] != '\n')
-				{
-					text += '\n';
-				}
-			}
-		}
-
-		mFile.write(text);
 	}
-};
 
-LogManager::LogManager() 
+	// TODO: print time?
-#ifdef BUFFERED_LOGGING
+
-	: mExiting(false), mLogConsumer()
+	if (auto t = thread_ctrl::get_current())
-#endif
-{
-	auto it = mChannels.begin();
-	std::shared_ptr<LogListener> listener(new FileListener());
-	for (const LogTypeName& name : gTypeNameTable)
 	{
-		it->name = name.mName;
+		msg += '{';
-		it->addListener(listener);
+		msg += t->get_name();
-		it++;
+		msg += "} ";
 	}
-	std::shared_ptr<LogListener> TTYListener(new FileListener("TTY.log", false));
-	getChannel(TTY).addListener(TTYListener);
-#ifdef BUFFERED_LOGGING
-	mLogConsumer = std::thread(&LogManager::consumeLog, this);
-#endif
-}
 
-LogManager::~LogManager()
+	if (ch.name.size())
-{
-#ifdef BUFFERED_LOGGING
-	mExiting = true;
-	mBufferReady.notify_all();
-	mLogConsumer.join();
-}
-
-void LogManager::consumeLog()
-{
-	std::unique_lock<std::mutex> lock(mStatusMut);
-	while (!mExiting)
 	{
-		mBufferReady.wait(lock);
+		msg += ch.name;
-		mBuffer.lockGet();
+		msg += sev == level::todo ? " TODO: " : ": ";
-		size_t size = mBuffer.size();
-		std::vector<char> local_messages(size);
-		mBuffer.popN(&local_messages.front(), size);
-		mBuffer.unlockGet();
-
-		u32 cursor = 0;
-		u32 removed = 0;
-		while (cursor < size)
-		{
-			Log::LogMessage msg = Log::LogMessage::deserialize(local_messages.data() + cursor, &removed);
-			cursor += removed;
-			getChannel(msg.mType).log(msg);
-		}
 	}
-#endif
+	else if (sev == level::todo)
-}
-
-void LogManager::log(LogMessage msg)
-{
-	//don't do any formatting changes or filtering to the TTY output since we
-	//use the raw output to do diffs with the output of a real PS3 and some
-	//programs write text in single bytes to the console
-	if (msg.mType != TTY)
 	{
-		std::string prefix;
+		msg += "TODO: ";
-		switch (msg.mServerity)
-		{
-		case Severity::Success:
-			prefix = "S ";
-			break;
-		case Severity::Notice:
-			prefix = "! ";
-			break;
-		case Severity::Warning:
-			prefix = "W ";
-			break;
-		case Severity::Error:
-			prefix = "E ";
-			break;
-		}
-		if (auto thr = thread_ctrl::get_current())
-		{
-			prefix += "{" + thr->get_name() + "} ";
-		}
-		msg.mText.insert(0, prefix);
-		msg.mText.append(1,'\n');
 	}
-#ifdef BUFFERED_LOGGING
+	
-	size_t size = msg.size();
+	msg += text;
-	std::vector<char> temp_buffer(size);
+	msg += '\n';
-	msg.serialize(temp_buffer.data());
-	mBuffer.pushRange(temp_buffer.begin(), temp_buffer.end());
-	mBufferReady.notify_one();
-#else
-	mChannels[static_cast<u32>(msg.mType)].log(msg);
-#endif
-}
 
-void LogManager::addListener(std::shared_ptr<LogListener> listener)
+	file_writer::log(msg);
-{
-	for (auto& channel : mChannels)
-	{
-		channel.addListener(listener);
-	}
-}
-
-void LogManager::removeListener(std::shared_ptr<LogListener> listener)
-{
-	for (auto& channel : mChannels)
-	{
-		channel.removeListener(listener);
-	}
-}
-
-LogManager& LogManager::getInstance()
-{
-	if (!g_log_manager)
-	{
-		g_log_manager.reset(new LogManager());
-	}
-
-	return *g_log_manager;
-}
-
-LogChannel &LogManager::getChannel(LogType type)
-{
-	return mChannels[static_cast<u32>(type)];
-}
-
-void log_message(Log::LogType type, Log::Severity sev, const char* text)
-{
-	log_message(type, sev, std::string(text));
-}
-
-void log_message(Log::LogType type, Log::Severity sev, std::string text)
-{
-	g_log_manager->log({ type, sev, std::move(text) });
 }

Utilities/Log.h

@@ -1,134 +1,155 @@
 #pragma once
-#include "Utilities/MTRingbuffer.h"
 
-//#define BUFFERED_LOGGING 1
+#include "SharedMutex.h"
 
-//first parameter is of type Log::LogType and text is of type std::string
+namespace _log
-
-#define LOG_SUCCESS(logType, text, ...)           log_message(logType, Log::Severity::Success, text, ##__VA_ARGS__)
-#define LOG_NOTICE(logType, text, ...)            log_message(logType, Log::Severity::Notice,  text, ##__VA_ARGS__) 
-#define LOG_WARNING(logType, text, ...)           log_message(logType, Log::Severity::Warning, text, ##__VA_ARGS__) 
-#define LOG_ERROR(logType, text, ...)             log_message(logType, Log::Severity::Error,   text, ##__VA_ARGS__)
-
-namespace Log
 {
-	const unsigned int MAX_LOG_BUFFER_LENGTH = 1024*1024;
+	enum class level : uint
-	const unsigned int gBuffSize = 1000;
-
-	enum LogType : u32
 	{
-		GENERAL = 0,
+		always, // highest level (unused, cannot be disabled)
-		LOADER,
+		fatal,
-		MEMORY,
+		error,
-		RSX,
+		todo,
-		HLE,
+		success,
-		PPU,
+		warning,
-		SPU,
+		notice,
-		ARMv7,
+		trace, // lowest level (usually disabled)
-		TTY,
 	};
 
+	struct channel;
+	struct listener;
 
-	struct LogTypeName
+	// Log manager
+	class logger final
 	{
-		LogType mType;
+		mutable shared_mutex m_mutex;
-		std::string mName;
+
+		std::set<listener*> m_listeners;
+
+	public:
+		// Register listener
+		void add_listener(listener* listener);
+
+		// Unregister listener
+		void remove_listener(listener* listener);
+
+		// Send log message to all listeners
+		void broadcast(const channel& ch, level sev, const std::string& text) const;
 	};
 
-	//well I'd love make_array() but alas manually counting is not the end of the world
+	// Send log message to global logger instance
-	static const std::array<LogTypeName, 9> gTypeNameTable = { {
+	void broadcast(const channel& ch, level sev, const std::string& text);
-			{ GENERAL, "G: " },
-			{ LOADER, "LDR: " },
-			{ MEMORY, "MEM: " },
-			{ RSX, "RSX: " },
-			{ HLE, "HLE: " },
-			{ PPU, "PPU: " },
-			{ SPU, "SPU: " },
-			{ ARMv7, "ARM: " },
-			{ TTY, "TTY: " }
-			} };
 
-	enum class Severity : u32
+	// Log channel (source)
+	struct channel
 	{
-		Notice = 0,
+		// Channel prefix (also used for identification)
-		Warning,
+		const std::string name;
-		Success,
+
-		Error,
+		// The lowest logging level enabled for this channel (used for early filtering)
+		std::atomic<level> enabled;
+
+		// Initialization (max level enabled by default)
+		channel(const std::string& name, level = level::trace);
+
+		virtual ~channel() = default;
+
+		// Log without formatting
+		force_inline void log(level sev, const std::string& text) const
+		{
+			if (sev <= enabled)
+				broadcast(*this, sev, text);
+		}
+
+		// Log with formatting
+		template<typename... Args>
+		force_inline safe_buffers void format(level sev, const char* fmt, const Args&... args) const
+		{
+			if (sev <= enabled)
+				broadcast(*this, sev, fmt::format(fmt, fmt::do_unveil(args)...));
+		}
+
+#define GEN_LOG_METHOD(_sev)\
+		template<typename... Args>\
+		force_inline void _sev(const char* fmt, const Args&... args)\
+		{\
+			return format<Args...>(level::_sev, fmt, args...);\
+		}
+
+		GEN_LOG_METHOD(fatal)
+		GEN_LOG_METHOD(error)
+		GEN_LOG_METHOD(todo)
+		GEN_LOG_METHOD(success)
+		GEN_LOG_METHOD(warning)
+		GEN_LOG_METHOD(notice)
+		GEN_LOG_METHOD(trace)
+
+#undef GEN_LOG_METHOD
 	};
 
-	struct LogMessage
+	// Log listener (destination)
+	struct listener
 	{
-		using size_type = u32;
+		listener();
-		LogType mType;
+		
-		Severity mServerity;
+		virtual ~listener();
-		std::string mText;
 
-		u32 size() const;
+		virtual void log(const channel& ch, level sev, const std::string& text) = 0;
-		void serialize(char *output) const;
-		static LogMessage deserialize(char *input, u32* size_out=nullptr);
 	};
 
-	struct LogListener
+	class file_writer
 	{
-		virtual ~LogListener() {};
+		// Could be memory-mapped file
-		virtual void log(const LogMessage &msg) = 0;
+		fs::file m_file;
+
+	public:
+		file_writer(const std::string& name);
+
+		virtual ~file_writer() = default;
+
+		// Append raw data
+		void log(const std::string& text);
+
+		// Get current file size (may be used by secondary readers)
+		std::size_t size() const;
 	};
 
-	struct LogChannel
+	struct file_listener : public file_writer, public listener
 	{
-		LogChannel();
+		file_listener(const std::string& name)
-		LogChannel(const std::string& name);
+			: file_writer(name)
-		LogChannel(LogChannel& other) = delete;
+			, listener()
-		void log(const LogMessage &msg);
+		{
-		void addListener(std::shared_ptr<LogListener> listener);
+		}
-		void removeListener(std::shared_ptr<LogListener> listener);
+
-		std::string name;
+		// Encode level, current thread name, channel name and write log message
-	private:
+		virtual void log(const channel& ch, level sev, const std::string& text) override;
-		bool mEnabled;
-		Severity mLogLevel;
-		std::mutex mListenerLock;
-		std::set<std::shared_ptr<LogListener>> mListeners;
 	};
 
-	struct LogManager
+	// Global variable for RPCS3.log
-	{
+	extern file_listener g_log_file;
-		LogManager();
+
-		~LogManager();
+	// Global variable for TTY.log
-		static LogManager& getInstance();
+	extern file_writer g_tty_file;
-		LogChannel& getChannel(LogType type);
+
-		void log(LogMessage msg);
+	// Small set of predefined channels:
-		void addListener(std::shared_ptr<LogListener> listener);
+
-		void removeListener(std::shared_ptr<LogListener> listener);
+	extern channel GENERAL;
-#ifdef BUFFERED_LOGGING
+	extern channel LOADER;
-		void consumeLog();
+	extern channel MEMORY;
-#endif
+	extern channel RSX;
-	private:
+	extern channel HLE;
-#ifdef BUFFERED_LOGGING
+	extern channel PPU;
-		MTRingbuffer<char, MAX_LOG_BUFFER_LENGTH> mBuffer;
+	extern channel SPU;
-		std::condition_variable mBufferReady;
+	extern channel ARMv7;
-		std::mutex mStatusMut;
-		std::atomic<bool> mExiting;
-		std::thread mLogConsumer;
-#endif
-		std::array<LogChannel, std::tuple_size<decltype(gTypeNameTable)>::value> mChannels;
-		//std::array<LogChannel,gTypeNameTable.size()> mChannels; //TODO: use this once Microsoft sorts their shit out
-	};
 }
 
-static struct { inline operator Log::LogType() { return Log::LogType::GENERAL; } } GENERAL;
+// Legacy:
-static struct { inline operator Log::LogType() { return Log::LogType::LOADER; } } LOADER;
-static struct { inline operator Log::LogType() { return Log::LogType::MEMORY; } } MEMORY;
-static struct { inline operator Log::LogType() { return Log::LogType::RSX; } } RSX;
-static struct { inline operator Log::LogType() { return Log::LogType::HLE; } } HLE;
-static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU;
-static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU;
-static struct { inline operator Log::LogType() { return Log::LogType::ARMv7; } } ARMv7;
-static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY;
 
-void log_message(Log::LogType type, Log::Severity sev, const char* text);
+#define LOG_SUCCESS(ch, fmt, ...) _log::ch.success(fmt, ##__VA_ARGS__)
-void log_message(Log::LogType type, Log::Severity sev, std::string text);
+#define LOG_NOTICE(ch, fmt, ...)  _log::ch.notice (fmt, ##__VA_ARGS__)
-
+#define LOG_WARNING(ch, fmt, ...) _log::ch.warning(fmt, ##__VA_ARGS__)
-template<typename... Args> never_inline void log_message(Log::LogType type, Log::Severity sev, const char* fmt, Args... args)
+#define LOG_ERROR(ch, fmt, ...)   _log::ch.error  (fmt, ##__VA_ARGS__)
-{
+#define LOG_TODO(ch, fmt, ...)    _log::ch.todo   (fmt, ##__VA_ARGS__)
-	log_message(type, sev, fmt::format(fmt, fmt::do_unveil(args)...));
+#define LOG_TRACE(ch, fmt, ...)   _log::ch.trace  (fmt, ##__VA_ARGS__)
-}
+#define LOG_FATAL(ch, fmt, ...)   _log::ch.fatal  (fmt, ##__VA_ARGS__)

Utilities/MTRingbuffer.h

@@ -1,155 +0,0 @@
-#pragma once
-
-//Simple non-resizable FIFO Ringbuffer that can be simultaneously be read from and written to
-//if we ever get to use boost please replace this with boost::circular_buffer, there's no reason
-//why we would have to keep this amateur attempt at such a fundamental data-structure around
-template< typename T, unsigned int MAX_MTRINGBUFFER_BUFFER_SIZE>
-class MTRingbuffer{
-	std::array<T, MAX_MTRINGBUFFER_BUFFER_SIZE> mBuffer;
-	//this is a recursive mutex because the get methods lock it but the only
-	//way to be sure that they do not block is to check the size and the only
-	//way to check the size and use get atomically is to lock this mutex,
-	//so it goes:
-	//lock get mutex-->check size-->call get-->lock get mutex-->unlock get mutex-->return from get-->unlock get mutex
-	std::recursive_mutex mMutGet;
-	std::mutex mMutPut;
-
-	size_t mGet;
-	size_t mPut;
-	size_t moveGet(size_t by = 1){ return (mGet + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
-	size_t movePut(size_t by = 1){ return (mPut + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
-public:
-	MTRingbuffer() : mGet(0), mPut(0){}
-
-	//blocks until there's something to get, so check "spaceLeft()" if you want to avoid blocking
-	//also lock the get mutex around the spaceLeft() check and the pop if you want to avoid racing
-	T pop()
-	{
-		std::lock_guard<std::recursive_mutex> lock(mMutGet);
-		while (mGet == mPut)
-		{
-			//wait until there's actually something to get
-			//throwing an exception might be better, blocking here is a little awkward
-			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
-		}
-		size_t ret = mGet;
-		mGet = moveGet();
-		return mBuffer[ret];
-	}
-
-	//blocks if the buffer is full until there's enough room
-	void push(T &putEle)
-	{
-		std::lock_guard<std::mutex> lock(mMutPut);
-		while (movePut() == mGet)
-		{
-			//if this is reached a lot it's time to increase the buffer size
-			//or implement dynamic re-sizing
-			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
-		}
-		mBuffer[mPut] = std::forward(putEle);
-		mPut = movePut();
-	}
-
-	bool empty()
-	{
-		return mGet == mPut;
-	}
-
-	//returns the amount of free places, this is the amount of actual free spaces-1
-	//since mGet==mPut signals an empty buffer we can't actually use the last free
-	//space, so we shouldn't report it as free.
-	size_t spaceLeft() //apparently free() is a macro definition in msvc in some conditions
-	{
-		if (mGet < mPut)
-		{
-			return mBuffer.size() - (mPut - mGet) - 1;
-		}
-		else if (mGet > mPut)
-		{
-			return mGet - mPut - 1;
-		}
-		else
-		{
-			return mBuffer.size() - 1;
-		}
-	}
-
-	size_t size()
-	{
-		//the magic -1 is the same magic 1 that is explained in the spaceLeft() function
-		return mBuffer.size() - spaceLeft() - 1;
-	}
-
-	//takes random access iterator to T
-	template<typename IteratorType>
-	void pushRange(IteratorType from, IteratorType until)
-	{
-		std::lock_guard<std::mutex> lock(mMutPut);
-		size_t length = until - from;
-
-		//if whatever we're trying to store is greater than the entire buffer the following loop will be infinite
-		assert(mBuffer.size() > length);
-		while (spaceLeft() < length)
-		{
-			//if this is reached a lot it's time to increase the buffer size
-			//or implement dynamic re-sizing
-			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
-		}
-		if (mPut + length <= mBuffer.size())
-		{
-			std::copy(from, until, mBuffer.begin() + mPut);
-		}
-		else
-		{
-			size_t tillEnd = mBuffer.size() - mPut;
-			std::copy(from, from + tillEnd, mBuffer.begin() + mPut);
-			std::copy(from + tillEnd, until, mBuffer.begin());
-		}
-		mPut = movePut(length);
-
-	}
-
-	//takes output iterator to T
-	template<typename IteratorType>
-	void popN(IteratorType output, size_t n)
-	{
-		std::lock_guard<std::recursive_mutex> lock(mMutGet);
-		//make sure we're not trying to retrieve more than is in
-		assert(n <= size());
-		peekN<IteratorType>(output, n);
-		mGet = moveGet(n);
-	}
-
-	//takes output iterator to T
-	template<typename IteratorType>
-	void peekN(IteratorType output, size_t n)
-	{
-		size_t lGet = mGet;
-		if (lGet + n <= mBuffer.size())
-		{
-			std::copy_n(mBuffer.begin() + lGet, n, output);
-		}
-		else
-		{
-			auto next = std::copy(mBuffer.begin() + lGet, mBuffer.end(), output);
-			std::copy_n(mBuffer.begin(), n - (mBuffer.size() - lGet), next);
-		}
-	}
-
-	//well this is just asking for trouble
-	//but the comment above the declaration of mMutGet explains why it's there
-	//if there's a better way please remove this
-	void lockGet()
-	{
-		mMutGet.lock();
-	}
-
-	//well this is just asking for trouble
-	//but the comment above the declaration of mMutGet explains why it's there
-	//if there's a better way please remove this
-	void unlockGet()
-	{
-		mMutGet.unlock();
-	}
-};

Utilities/StrFmt.h

@@ -155,19 +155,19 @@ namespace fmt
 		}
 	};
 
-	template<> struct unveil<char*, false>
+	template<> struct unveil<const char*, false>
 	{
-		using result_type = const char*;
+		using result_type = const char* const;
 
-		force_inline static result_type get_value(const char* arg)
+		force_inline static result_type get_value(const char* const& arg)
 		{
 			return arg;
 		}
 	};
 
-	template<std::size_t N> struct unveil<const char[N], false>
+	template<std::size_t N> struct unveil<char[N], false>
 	{
-		using result_type = const char*;
+		using result_type = const char* const;
 
 		force_inline static result_type get_value(const char(&arg)[N])
 		{
@@ -220,7 +220,8 @@ namespace fmt
 	// vm::ptr, vm::bptr, ... (fmt::do_unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
 	// vm::ref, vm::bref, ... (fmt::do_unveil) (vm_ref.h)
 	//
-	template<typename... Args> safe_buffers std::string format(const char* fmt, Args... args)
+	template<typename... Args>
+	safe_buffers std::string format(const char* fmt, const Args&... args)
 	{
 		// fixed stack buffer for the first attempt
 		std::array<char, 4096> fixed_buf;

Utilities/Thread.cpp

@@ -1351,21 +1351,15 @@ void named_thread_t::start()
 	{
 		try
 		{
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(GENERAL, "Thread started");
-			{
-				LOG_NOTICE(GENERAL, "Thread started");
-			}
 
 			thread->on_task();
 
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(GENERAL, "Thread ended");
-			{
-				LOG_NOTICE(GENERAL, "Thread ended");
-			}
 		}
 		catch (const std::exception& e)
 		{
-			LOG_ERROR(GENERAL, "Exception: %s\nPlease report this to the developers.", e.what());
+			LOG_FATAL(GENERAL, "Exception: %s\nPlease report this to the developers.", e.what());
 			Emu.Pause();
 		}
 		catch (EmulationStopped)

rpcs3/Crypto/unself.cpp

@@ -1330,7 +1330,7 @@ bool CheckDebugSelf(const std::string& self, const std::string& elf)
 
 bool DecryptSelf(const std::string& elf, const std::string& self)
 {
-	LOG_NOTICE(GENERAL, "Decrypting %s", self);
+	LOG_NOTICE(LOADER, "Decrypting %s", self);
 
 	// Check for a debug SELF first.
 	if (!CheckDebugSelf(self, elf))

rpcs3/Emu/ARMv7/ARMv7Decoder.cpp

@@ -1125,7 +1125,7 @@ struct ARMv7_op2_table_t
 			{
 				if (opcode.code & ~opcode.mask)
 				{
-					LOG_ERROR(GENERAL, "%s: wrong opcode mask (mask=0x%04x, code=0x%04x)", opcode.name, opcode.mask >> 16, opcode.code >> 16);
+					LOG_ERROR(ARMv7, "%s: wrong opcode mask (mask=0x%04x, code=0x%04x)", opcode.name, opcode.mask >> 16, opcode.code >> 16);
 				}
 
 				t2.push_back(&opcode);
@@ -1164,7 +1164,7 @@ struct ARMv7_op4t_table_t
 			{
 				if (opcode.code & ~opcode.mask)
 				{
-					LOG_ERROR(GENERAL, "%s: wrong opcode mask (mask=0x%04x 0x%04x, code=0x%04x 0x%04x)", opcode.name, opcode.mask >> 16, (u16)opcode.mask, opcode.code >> 16, (u16)opcode.code);
+					LOG_ERROR(ARMv7, "%s: wrong opcode mask (mask=0x%04x 0x%04x, code=0x%04x 0x%04x)", opcode.name, opcode.mask >> 16, (u16)opcode.mask, opcode.code >> 16, (u16)opcode.code);
 				}
 
 				table.push_back(&opcode);
@@ -1199,7 +1199,7 @@ struct ARMv7_op4arm_table_t
 			{
 				if (opcode.code & ~opcode.mask)
 				{
-					LOG_ERROR(GENERAL, "%s: wrong opcode mask (mask=0x%08x, code=0x%08x)", opcode.name, opcode.mask, opcode.code);
+					LOG_ERROR(ARMv7, "%s: wrong opcode mask (mask=0x%08x, code=0x%08x)", opcode.name, opcode.mask, opcode.code);
 				}
 
 				table.push_back(&opcode);
@@ -1365,7 +1365,7 @@ u32 ARMv7Decoder::DecodeMemory(const u32 address)
 	// "group" decoding algorithm (temporarily disabled)
 
 	//execute_main_group(&m_thr);
-	//// LOG_NOTICE(GENERAL, "%s, %d \n\n", m_thr.m_last_instr_name, m_thr.m_last_instr_size);
+	//// LOG_NOTICE(ARMv7, "%s, %d \n\n", m_thr.m_last_instr_name, m_thr.m_last_instr_size);
 	//m_thr.m_last_instr_name = "Unknown";
 	//return m_thr.m_last_instr_size;
 }

rpcs3/Emu/ARMv7/ARMv7Opcodes.h

@@ -2005,7 +2005,7 @@ static void execute_main_group(ARMv7Thread* thr)
 	case 0xe: (*g_table_0xe).func(thr, (*g_table_0xe).type); break;
 	case 0xf: (*g_table_0xf).func(thr, (*g_table_0xf).type); break;
 
-	default: LOG_ERROR(GENERAL, "ARMv7Decoder: unknown group 0x%x", (thr->code.code0 & 0xf000) >> 12); Emu.Pause(); break;
+	default: LOG_ERROR(ARMv7, "ARMv7Decoder: unknown group 0x%x", (thr->code.code0 & 0xf000) >> 12); Emu.Pause(); break;
 	}
 }
 

rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp

@@ -33,7 +33,7 @@ s32 sceKernelGetMemBlockInfoByAddr(vm::ptr<void> vbase, vm::ptr<SceKernelMemBloc
 
 s32 sceKernelCreateThread(vm::cptr<char> pName, vm::ptr<SceKernelThreadEntry> entry, s32 initPriority, u32 stackSize, u32 attr, s32 cpuAffinityMask, vm::cptr<SceKernelThreadOptParam> pOptParam)
 {
-	sceLibKernel.Warning("sceKernelCreateThread(pName=*0x%x, entry=*0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam=*0x%x)",
+	sceLibKernel.warning("sceKernelCreateThread(pName=*0x%x, entry=*0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam=*0x%x)",
 		pName, entry, initPriority, stackSize, attr, cpuAffinityMask, pOptParam);
 
 	auto armv7 = idm::make_ptr<ARMv7Thread>(pName.get_ptr());
@@ -48,7 +48,7 @@ s32 sceKernelCreateThread(vm::cptr<char> pName, vm::ptr<SceKernelThreadEntry> en
 
 s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::cptr<void> pArgBlock)
 {
-	sceLibKernel.Warning("sceKernelStartThread(threadId=0x%x, argSize=0x%x, pArgBlock=*0x%x)", threadId, argSize, pArgBlock);
+	sceLibKernel.warning("sceKernelStartThread(threadId=0x%x, argSize=0x%x, pArgBlock=*0x%x)", threadId, argSize, pArgBlock);
 
 	const auto thread = idm::get<ARMv7Thread>(threadId);
 
@@ -78,7 +78,7 @@ s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::cptr<void> pArgBlock)
 
 s32 sceKernelExitThread(ARMv7Thread& context, s32 exitStatus)
 {
-	sceLibKernel.Warning("sceKernelExitThread(exitStatus=0x%x)", exitStatus);
+	sceLibKernel.warning("sceKernelExitThread(exitStatus=0x%x)", exitStatus);
 
 	// exit status is stored in r0
 	context.exit();
@@ -88,7 +88,7 @@ s32 sceKernelExitThread(ARMv7Thread& context, s32 exitStatus)
 
 s32 sceKernelDeleteThread(s32 threadId)
 {
-	sceLibKernel.Warning("sceKernelDeleteThread(threadId=0x%x)", threadId);
+	sceLibKernel.warning("sceKernelDeleteThread(threadId=0x%x)", threadId);
 
 	const auto thread = idm::get<ARMv7Thread>(threadId);
 
@@ -110,7 +110,7 @@ s32 sceKernelDeleteThread(s32 threadId)
 
 s32 sceKernelExitDeleteThread(ARMv7Thread& context, s32 exitStatus)
 {
-	sceLibKernel.Warning("sceKernelExitDeleteThread(exitStatus=0x%x)", exitStatus);
+	sceLibKernel.warning("sceKernelExitDeleteThread(exitStatus=0x%x)", exitStatus);
 
 	// exit status is stored in r0
 	context.stop();
@@ -123,91 +123,91 @@ s32 sceKernelExitDeleteThread(ARMv7Thread& context, s32 exitStatus)
 
 s32 sceKernelChangeThreadCpuAffinityMask(s32 threadId, s32 cpuAffinityMask)
 {
-	sceLibKernel.Todo("sceKernelChangeThreadCpuAffinityMask(threadId=0x%x, cpuAffinityMask=0x%x)", threadId, cpuAffinityMask);
+	sceLibKernel.todo("sceKernelChangeThreadCpuAffinityMask(threadId=0x%x, cpuAffinityMask=0x%x)", threadId, cpuAffinityMask);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadCpuAffinityMask(s32 threadId)
 {
-	sceLibKernel.Todo("sceKernelGetThreadCpuAffinityMask(threadId=0x%x)", threadId);
+	sceLibKernel.todo("sceKernelGetThreadCpuAffinityMask(threadId=0x%x)", threadId);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelChangeThreadPriority(s32 threadId, s32 priority)
 {
-	sceLibKernel.Todo("sceKernelChangeThreadPriority(threadId=0x%x, priority=%d)", threadId, priority);
+	sceLibKernel.todo("sceKernelChangeThreadPriority(threadId=0x%x, priority=%d)", threadId, priority);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadCurrentPriority()
 {
-	sceLibKernel.Todo("sceKernelGetThreadCurrentPriority()");
+	sceLibKernel.todo("sceKernelGetThreadCurrentPriority()");
 
 	throw EXCEPTION("");
 }
 
 u32 sceKernelGetThreadId(ARMv7Thread& context)
 {
-	sceLibKernel.Log("sceKernelGetThreadId()");
+	sceLibKernel.trace("sceKernelGetThreadId()");
 
 	return context.get_id();
 }
 
 s32 sceKernelChangeCurrentThreadAttr(u32 clearAttr, u32 setAttr)
 {
-	sceLibKernel.Todo("sceKernelChangeCurrentThreadAttr()");
+	sceLibKernel.todo("sceKernelChangeCurrentThreadAttr()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadExitStatus(s32 threadId, vm::ptr<s32> pExitStatus)
 {
-	sceLibKernel.Todo("sceKernelGetThreadExitStatus(threadId=0x%x, pExitStatus=*0x%x)", threadId, pExitStatus);
+	sceLibKernel.todo("sceKernelGetThreadExitStatus(threadId=0x%x, pExitStatus=*0x%x)", threadId, pExitStatus);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetProcessId()
 {
-	sceLibKernel.Todo("sceKernelGetProcessId()");
+	sceLibKernel.todo("sceKernelGetProcessId()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelCheckWaitableStatus()
 {
-	sceLibKernel.Todo("sceKernelCheckWaitableStatus()");
+	sceLibKernel.todo("sceKernelCheckWaitableStatus()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadInfo(s32 threadId, vm::ptr<SceKernelThreadInfo> pInfo)
 {
-	sceLibKernel.Todo("sceKernelGetThreadInfo(threadId=0x%x, pInfo=*0x%x)", threadId, pInfo);
+	sceLibKernel.todo("sceKernelGetThreadInfo(threadId=0x%x, pInfo=*0x%x)", threadId, pInfo);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadRunStatus(vm::ptr<SceKernelThreadRunStatus> pStatus)
 {
-	sceLibKernel.Todo("sceKernelGetThreadRunStatus(pStatus=*0x%x)", pStatus);
+	sceLibKernel.todo("sceKernelGetThreadRunStatus(pStatus=*0x%x)", pStatus);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetSystemInfo(vm::ptr<SceKernelSystemInfo> pInfo)
 {
-	sceLibKernel.Todo("sceKernelGetSystemInfo(pInfo=*0x%x)", pInfo);
+	sceLibKernel.todo("sceKernelGetSystemInfo(pInfo=*0x%x)", pInfo);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetThreadmgrUIDClass(s32 uid)
 {
-	sceLibKernel.Error("sceKernelGetThreadmgrUIDClass(uid=0x%x)", uid);
+	sceLibKernel.error("sceKernelGetThreadmgrUIDClass(uid=0x%x)", uid);
 
 	const auto type = idm::get_type(uid);
 
@@ -227,35 +227,35 @@ s32 sceKernelGetThreadmgrUIDClass(s32 uid)
 
 s32 sceKernelChangeThreadVfpException(s32 clearMask, s32 setMask)
 {
-	sceLibKernel.Todo("sceKernelChangeThreadVfpException(clearMask=0x%x, setMask=0x%x)", clearMask, setMask);
+	sceLibKernel.todo("sceKernelChangeThreadVfpException(clearMask=0x%x, setMask=0x%x)", clearMask, setMask);
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelGetCurrentThreadVfpException()
 {
-	sceLibKernel.Todo("sceKernelGetCurrentThreadVfpException()");
+	sceLibKernel.todo("sceKernelGetCurrentThreadVfpException()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelDelayThread(u32 usec)
 {
-	sceLibKernel.Todo("sceKernelDelayThread()");
+	sceLibKernel.todo("sceKernelDelayThread()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelDelayThreadCB(u32 usec)
 {
-	sceLibKernel.Todo("sceKernelDelayThreadCB()");
+	sceLibKernel.todo("sceKernelDelayThreadCB()");
 
 	throw EXCEPTION("");
 }
 
 s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32> pTimeout)
 {
-	sceLibKernel.Warning("sceKernelWaitThreadEnd(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);
+	sceLibKernel.warning("sceKernelWaitThreadEnd(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);
 
 	const auto thread = idm::get<ARMv7Thread>(threadId);
 
@@ -285,7 +285,7 @@ s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32>
 
 s32 sceKernelWaitThreadEndCB(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32> pTimeout)
 {
-	sceLibKernel.Todo("sceKernelWaitThreadEndCB(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);
+	sceLibKernel.todo("sceKernelWaitThreadEndCB(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);
 
 	throw EXCEPTION("");
 }
@@ -383,14 +383,14 @@ s32 sceKernelWaitMultipleEventsCB(vm::ptr<SceKernelWaitEvent> pWaitEventList, s3
 
 s32 sceKernelCreateEventFlag(vm::cptr<char> pName, u32 attr, u32 initPattern, vm::cptr<SceKernelEventFlagOptParam> pOptParam)
 {
-	sceLibKernel.Error("sceKernelCreateEventFlag(pName=*0x%x, attr=0x%x, initPattern=0x%x, pOptParam=*0x%x)", pName, attr, initPattern, pOptParam);
+	sceLibKernel.error("sceKernelCreateEventFlag(pName=*0x%x, attr=0x%x, initPattern=0x%x, pOptParam=*0x%x)", pName, attr, initPattern, pOptParam);
 
 	return idm::make<psv_event_flag_t>(pName.get_ptr(), attr, initPattern);
 }
 
 s32 sceKernelDeleteEventFlag(s32 evfId)
 {
-	sceLibKernel.Error("sceKernelDeleteEventFlag(evfId=0x%x)", evfId);
+	sceLibKernel.error("sceKernelDeleteEventFlag(evfId=0x%x)", evfId);
 
 	const auto evf = idm::withdraw<psv_event_flag_t>(evfId);
 
@@ -410,7 +410,7 @@ s32 sceKernelDeleteEventFlag(s32 evfId)
 
 s32 sceKernelOpenEventFlag(vm::cptr<char> pName)
 {
-	sceLibKernel.Error("sceKernelOpenEventFlag(pName=*0x%x)", pName);
+	sceLibKernel.error("sceKernelOpenEventFlag(pName=*0x%x)", pName);
 
 	// For now, go through all objects to find the name
 	for (const auto& data : idm::get_map<psv_event_flag_t>())
@@ -428,7 +428,7 @@ s32 sceKernelOpenEventFlag(vm::cptr<char> pName)
 
 s32 sceKernelCloseEventFlag(s32 evfId)
 {
-	sceLibKernel.Error("sceKernelCloseEventFlag(evfId=0x%x)", evfId);
+	sceLibKernel.error("sceKernelCloseEventFlag(evfId=0x%x)", evfId);
 
 	const auto evf = idm::withdraw<psv_event_flag_t>(evfId);
 
@@ -448,7 +448,7 @@ s32 sceKernelCloseEventFlag(s32 evfId)
 
 s32 sceKernelWaitEventFlag(ARMv7Thread& context, s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat, vm::ptr<u32> pTimeout)
 {
-	sceLibKernel.Error("sceKernelWaitEventFlag(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x, pTimeout=*0x%x)", evfId, bitPattern, waitMode, pResultPat, pTimeout);
+	sceLibKernel.error("sceKernelWaitEventFlag(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x, pTimeout=*0x%x)", evfId, bitPattern, waitMode, pResultPat, pTimeout);
 
 	const u64 start_time = pTimeout ? get_system_time() : 0;
 	const u32 timeout = pTimeout ? pTimeout->value() : 0;
@@ -509,14 +509,14 @@ s32 sceKernelWaitEventFlag(ARMv7Thread& context, s32 evfId, u32 bitPattern, u32
 
 s32 sceKernelWaitEventFlagCB(ARMv7Thread& context, s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat, vm::ptr<u32> pTimeout)
 {
-	sceLibKernel.Todo("sceKernelWaitEventFlagCB(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x, pTimeout=*0x%x)", evfId, bitPattern, waitMode, pResultPat, pTimeout);
+	sceLibKernel.todo("sceKernelWaitEventFlagCB(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x, pTimeout=*0x%x)", evfId, bitPattern, waitMode, pResultPat, pTimeout);
 
 	return sceKernelWaitEventFlag(context, evfId, bitPattern, waitMode, pResultPat, pTimeout);
 }
 
 s32 sceKernelPollEventFlag(s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32> pResultPat)
 {
-	sceLibKernel.Error("sceKernelPollEventFlag(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x)", evfId, bitPattern, waitMode, pResultPat);
+	sceLibKernel.error("sceKernelPollEventFlag(evfId=0x%x, bitPattern=0x%x, waitMode=0x%x, pResultPat=*0x%x)", evfId, bitPattern, waitMode, pResultPat);
 
 	const auto evf = idm::get<psv_event_flag_t>(evfId);
 
@@ -541,7 +541,7 @@ s32 sceKernelPollEventFlag(s32 evfId, u32 bitPattern, u32 waitMode, vm::ptr<u32>
 
 s32 sceKernelSetEventFlag(s32 evfId, u32 bitPattern)
 {
-	sceLibKernel.Error("sceKernelSetEventFlag(evfId=0x%x, bitPattern=0x%x)", evfId, bitPattern);
+	sceLibKernel.error("sceKernelSetEventFlag(evfId=0x%x, bitPattern=0x%x)", evfId, bitPattern);
 
 	const auto evf = idm::get<psv_event_flag_t>(evfId);
 
@@ -586,7 +586,7 @@ s32 sceKernelSetEventFlag(s32 evfId, u32 bitPattern)
 
 s32 sceKernelClearEventFlag(s32 evfId, u32 bitPattern)
 {
-	sceLibKernel.Error("sceKernelClearEventFlag(evfId=0x%x, bitPattern=0x%x)", evfId, bitPattern);
+	sceLibKernel.error("sceKernelClearEventFlag(evfId=0x%x, bitPattern=0x%x)", evfId, bitPattern);
 
 	const auto evf = idm::get<psv_event_flag_t>(evfId);
 
@@ -604,7 +604,7 @@ s32 sceKernelClearEventFlag(s32 evfId, u32 bitPattern)
 
 s32 sceKernelCancelEventFlag(s32 evfId, u32 setPattern, vm::ptr<s32> pNumWaitThreads)
 {
-	sceLibKernel.Error("sceKernelCancelEventFlag(evfId=0x%x, setPattern=0x%x, pNumWaitThreads=*0x%x)", evfId, setPattern, pNumWaitThreads);
+	sceLibKernel.error("sceKernelCancelEventFlag(evfId=0x%x, setPattern=0x%x, pNumWaitThreads=*0x%x)", evfId, setPattern, pNumWaitThreads);
 
 	const auto evf = idm::get<psv_event_flag_t>(evfId);
 
@@ -632,7 +632,7 @@ s32 sceKernelCancelEventFlag(s32 evfId, u32 setPattern, vm::ptr<s32> pNumWaitThr
 
 s32 sceKernelGetEventFlagInfo(s32 evfId, vm::ptr<SceKernelEventFlagInfo> pInfo)
 {
-	sceLibKernel.Error("sceKernelGetEventFlagInfo(evfId=0x%x, pInfo=*0x%x)", evfId, pInfo);
+	sceLibKernel.error("sceKernelGetEventFlagInfo(evfId=0x%x, pInfo=*0x%x)", evfId, pInfo);
 
 	const auto evf = idm::get<psv_event_flag_t>(evfId);
 
@@ -660,14 +660,14 @@ s32 sceKernelGetEventFlagInfo(s32 evfId, vm::ptr<SceKernelEventFlagInfo> pInfo)
 
 s32 sceKernelCreateSema(vm::cptr<char> pName, u32 attr, s32 initCount, s32 maxCount, vm::cptr<SceKernelSemaOptParam> pOptParam)
 {
-	sceLibKernel.Error("sceKernelCreateSema(pName=*0x%x, attr=0x%x, initCount=%d, maxCount=%d, pOptParam=*0x%x)", pName, attr, initCount, maxCount, pOptParam);
+	sceLibKernel.error("sceKernelCreateSema(pName=*0x%x, attr=0x%x, initCount=%d, maxCount=%d, pOptParam=*0x%x)", pName, attr, initCount, maxCount, pOptParam);
 
 	return idm::make<psv_semaphore_t>(pName.get_ptr(), attr, initCount, maxCount);
 }
 
 s32 sceKernelDeleteSema(s32 semaId)
 {
-	sceLibKernel.Error("sceKernelDeleteSema(semaId=0x%x)", semaId);
+	sceLibKernel.error("sceKernelDeleteSema(semaId=0x%x)", semaId);
 
 	const auto sema = idm::withdraw<psv_semaphore_t>(semaId);
 
@@ -693,7 +693,7 @@ s32 sceKernelCloseSema(s32 semaId)
 
 s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
 {
-	sceLibKernel.Error("sceKernelWaitSema(semaId=0x%x, needCount=%d, pTimeout=*0x%x)", semaId, needCount, pTimeout);
+	sceLibKernel.error("sceKernelWaitSema(semaId=0x%x, needCount=%d, pTimeout=*0x%x)", semaId, needCount, pTimeout);
 
 	const auto sema = idm::get<psv_semaphore_t>(semaId);
 
@@ -702,7 +702,7 @@ s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
 		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
-	sceLibKernel.Error("*** name = %s", sema->name);
+	sceLibKernel.error("*** name = %s", sema->name);
 	Emu.Pause();
 	return SCE_OK;
 }
@@ -736,14 +736,14 @@ s32 sceKernelGetSemaInfo(s32 semaId, vm::ptr<SceKernelSemaInfo> pInfo)
 
 s32 sceKernelCreateMutex(vm::cptr<char> pName, u32 attr, s32 initCount, vm::cptr<SceKernelMutexOptParam> pOptParam)
 {
-	sceLibKernel.Error("sceKernelCreateMutex(pName=*0x%x, attr=0x%x, initCount=%d, pOptParam=*0x%x)", pName, attr, initCount, pOptParam);
+	sceLibKernel.error("sceKernelCreateMutex(pName=*0x%x, attr=0x%x, initCount=%d, pOptParam=*0x%x)", pName, attr, initCount, pOptParam);
 
 	return idm::make<psv_mutex_t>(pName.get_ptr(), attr, initCount);
 }
 
 s32 sceKernelDeleteMutex(s32 mutexId)
 {
-	sceLibKernel.Error("sceKernelDeleteMutex(mutexId=0x%x)", mutexId);
+	sceLibKernel.error("sceKernelDeleteMutex(mutexId=0x%x)", mutexId);
 
 	const auto mutex = idm::withdraw<psv_mutex_t>(mutexId);
 
@@ -843,7 +843,7 @@ s32 sceKernelGetLwMutexInfoById(s32 lwMutexId, vm::ptr<SceKernelLwMutexInfo> pIn
 
 s32 sceKernelCreateCond(vm::cptr<char> pName, u32 attr, s32 mutexId, vm::cptr<SceKernelCondOptParam> pOptParam)
 {
-	sceLibKernel.Error("sceKernelCreateCond(pName=*0x%x, attr=0x%x, mutexId=0x%x, pOptParam=*0x%x)", pName, attr, mutexId, pOptParam);
+	sceLibKernel.error("sceKernelCreateCond(pName=*0x%x, attr=0x%x, mutexId=0x%x, pOptParam=*0x%x)", pName, attr, mutexId, pOptParam);
 
 	const auto mutex = idm::get<psv_mutex_t>(mutexId);
 
@@ -857,7 +857,7 @@ s32 sceKernelCreateCond(vm::cptr<char> pName, u32 attr, s32 mutexId, vm::cptr<Sc
 
 s32 sceKernelDeleteCond(s32 condId)
 {
-	sceLibKernel.Error("sceKernelDeleteCond(condId=0x%x)", condId);
+	sceLibKernel.error("sceKernelDeleteCond(condId=0x%x)", condId);
 
 	const auto cond = idm::withdraw<psv_cond_t>(condId);
 

rpcs3/Emu/ARMv7/Modules/sceLibc.cpp

@@ -150,7 +150,7 @@ namespace sce_libc_func
 {
 	void __cxa_atexit(vm::ptr<atexit_func_t> func, vm::ptr<void> arg, vm::ptr<void> dso)
 	{
-		sceLibc.Warning("__cxa_atexit(func=*0x%x, arg=*0x%x, dso=*0x%x)", func, arg, dso);
+		sceLibc.warning("__cxa_atexit(func=*0x%x, arg=*0x%x, dso=*0x%x)", func, arg, dso);
 		
 		std::lock_guard<std::mutex> lock(g_atexit_mutex);
 
@@ -162,7 +162,7 @@ namespace sce_libc_func
 
 	void __aeabi_atexit(vm::ptr<void> arg, vm::ptr<atexit_func_t> func, vm::ptr<void> dso)
 	{
-		sceLibc.Warning("__aeabi_atexit(arg=*0x%x, func=*0x%x, dso=*0x%x)", arg, func, dso);
+		sceLibc.warning("__aeabi_atexit(arg=*0x%x, func=*0x%x, dso=*0x%x)", arg, func, dso);
 
 		std::lock_guard<std::mutex> lock(g_atexit_mutex);
 
@@ -174,7 +174,7 @@ namespace sce_libc_func
 
 	void exit(ARMv7Thread& context)
 	{
-		sceLibc.Warning("exit()");
+		sceLibc.warning("exit()");
 
 		std::lock_guard<std::mutex> lock(g_atexit_mutex);
 
@@ -185,7 +185,7 @@ namespace sce_libc_func
 			func(context);
 		}
 
-		sceLibc.Success("Process finished");
+		sceLibc.success("Process finished");
 
 		Emu.CallAfter([]()
 		{
@@ -202,52 +202,52 @@ namespace sce_libc_func
 
 	void printf(ARMv7Thread& context, vm::cptr<char> fmt, armv7_va_args_t va_args)
 	{
-		sceLibc.Warning("printf(fmt=*0x%x)", fmt);
+		sceLibc.warning("printf(fmt=*0x%x)", fmt);
-		sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
+		sceLibc.trace("*** *fmt = '%s'", fmt.get_ptr());
 
 		const std::string& result = armv7_fmt(context, fmt, va_args.g_count, va_args.f_count, va_args.v_count);
-		sceLibc.Log("***     -> '%s'", result);
+		sceLibc.trace("***     -> '%s'", result);
 
-		LOG_NOTICE(TTY, result);
+		_log::g_tty_file.log(result);
 	}
 
 	void sprintf(ARMv7Thread& context, vm::ptr<char> str, vm::cptr<char> fmt, armv7_va_args_t va_args)
 	{
-		sceLibc.Warning("sprintf(str=*0x%x, fmt=*0x%x)", str, fmt);
+		sceLibc.warning("sprintf(str=*0x%x, fmt=*0x%x)", str, fmt);
-		sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
+		sceLibc.trace("*** *fmt = '%s'", fmt.get_ptr());
 
 		const std::string& result = armv7_fmt(context, fmt, va_args.g_count, va_args.f_count, va_args.v_count);
-		sceLibc.Log("***     -> '%s'", result);
+		sceLibc.trace("***     -> '%s'", result);
 
 		::memcpy(str.get_ptr(), result.c_str(), result.size() + 1);
 	}
 
 	void __cxa_set_dso_handle_main(vm::ptr<void> dso)
 	{
-		sceLibc.Warning("__cxa_set_dso_handle_main(dso=*0x%x)", dso);
+		sceLibc.warning("__cxa_set_dso_handle_main(dso=*0x%x)", dso);
 
 		g_dso = dso;
 	}
 
 	void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 	{
-		sceLibc.Warning("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
+		sceLibc.warning("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
 
 		::memcpy(dst.get_ptr(), src.get_ptr(), size);
 	}
 
 	void memset(vm::ptr<void> dst, s32 value, u32 size)
 	{
-		sceLibc.Warning("memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
+		sceLibc.warning("memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
 
 		::memset(dst.get_ptr(), value, size);
 	}
 
 	void _Assert(vm::cptr<char> text, vm::cptr<char> func)
 	{
-		sceLibc.Error("_Assert(text=*0x%x, func=*0x%x)", text, func);
+		sceLibc.error("_Assert(text=*0x%x, func=*0x%x)", text, func);
 
-		LOG_ERROR(TTY, "%s : %s\n", func.get_ptr(), text.get_ptr());
+		LOG_FATAL(HLE, "%s : %s\n", func.get_ptr(), text.get_ptr());
 		Emu.Pause();
 	}
 }

rpcs3/Emu/ARMv7/Modules/scePerf.cpp

@@ -8,7 +8,7 @@ extern u64 get_system_time();
 
 s32 scePerfArmPmonReset(ARMv7Thread& context, s32 threadId)
 {
-	scePerf.Warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
+	scePerf.warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
@@ -22,7 +22,7 @@ s32 scePerfArmPmonReset(ARMv7Thread& context, s32 threadId)
 
 s32 scePerfArmPmonSelectEvent(ARMv7Thread& context, s32 threadId, u32 counter, u8 eventCode)
 {
-	scePerf.Warning("scePerfArmPmonSelectEvent(threadId=0x%x, counter=0x%x, eventCode=0x%x)", threadId, counter, eventCode);
+	scePerf.warning("scePerfArmPmonSelectEvent(threadId=0x%x, counter=0x%x, eventCode=0x%x)", threadId, counter, eventCode);
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
@@ -74,7 +74,7 @@ s32 scePerfArmPmonSelectEvent(ARMv7Thread& context, s32 threadId, u32 counter, u
 
 s32 scePerfArmPmonStart(ARMv7Thread& context, s32 threadId)
 {
-	scePerf.Warning("scePerfArmPmonStart(threadId=0x%x)", threadId);
+	scePerf.warning("scePerfArmPmonStart(threadId=0x%x)", threadId);
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
@@ -86,7 +86,7 @@ s32 scePerfArmPmonStart(ARMv7Thread& context, s32 threadId)
 
 s32 scePerfArmPmonStop(ARMv7Thread& context, s32 threadId)
 {
-	scePerf.Warning("scePerfArmPmonStop(threadId=0x%x)");
+	scePerf.warning("scePerfArmPmonStop(threadId=0x%x)");
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
@@ -98,7 +98,7 @@ s32 scePerfArmPmonStop(ARMv7Thread& context, s32 threadId)
 
 s32 scePerfArmPmonGetCounterValue(ARMv7Thread& context, s32 threadId, u32 counter, vm::ptr<u32> pValue)
 {
-	scePerf.Warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=*0x%x)", threadId, counter, pValue);
+	scePerf.warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=*0x%x)", threadId, counter, pValue);
 
 	if (threadId != SCE_PERF_ARM_PMON_THREAD_ID_SELF)
 	{
@@ -124,7 +124,7 @@ s32 scePerfArmPmonGetCounterValue(ARMv7Thread& context, s32 threadId, u32 counte
 
 s32 scePerfArmPmonSoftwareIncrement(ARMv7Thread& context, u32 mask)
 {
-	scePerf.Warning("scePerfArmPmonSoftwareIncrement(mask=0x%x)", mask);
+	scePerf.warning("scePerfArmPmonSoftwareIncrement(mask=0x%x)", mask);
 
 	if (mask > SCE_PERF_ARM_PMON_COUNTER_MASK_ALL)
 	{
@@ -144,14 +144,14 @@ s32 scePerfArmPmonSoftwareIncrement(ARMv7Thread& context, u32 mask)
 
 u64 scePerfGetTimebaseValue()
 {
-	scePerf.Warning("scePerfGetTimebaseValue()");
+	scePerf.warning("scePerfGetTimebaseValue()");
 
 	return get_system_time();
 }
 
 u32 scePerfGetTimebaseFrequency()
 {
-	scePerf.Warning("scePerfGetTimebaseFrequency()");
+	scePerf.warning("scePerfGetTimebaseFrequency()");
 
 	return 1;
 }
@@ -198,4 +198,4 @@ psv_log_base scePerf("ScePerf", []()
 	REG_FUNC(0xC3DE4C0A, sceRazorCpuPushMarker);
 	REG_FUNC(0xDC3224C3, sceRazorCpuPopMarker);
 	REG_FUNC(0x4F1385E3, sceRazorCpuSync);
-});
+});

rpcs3/Emu/ARMv7/Modules/sceSysmodule.cpp

@@ -6,21 +6,21 @@
 
 s32 sceSysmoduleLoadModule(u16 id)
 {
-	sceSysmodule.Warning("sceSysmoduleLoadModule(id=0x%04x) -> SCE_OK", id);
+	sceSysmodule.warning("sceSysmoduleLoadModule(id=0x%04x) -> SCE_OK", id);
 
 	return SCE_OK; // loading succeeded
 }
 
 s32 sceSysmoduleUnloadModule(u16 id)
 {
-	sceSysmodule.Warning("sceSysmoduleUnloadModule(id=0x%04x) -> SCE_OK", id);
+	sceSysmodule.warning("sceSysmoduleUnloadModule(id=0x%04x) -> SCE_OK", id);
 
 	return SCE_OK; // unloading succeeded
 }
 
 s32 sceSysmoduleIsLoaded(u16 id)
 {
-	sceSysmodule.Warning("sceSysmoduleIsLoaded(id=0x%04x) -> SCE_OK", id);
+	sceSysmodule.warning("sceSysmoduleIsLoaded(id=0x%04x) -> SCE_OK", id);
 
 	return SCE_OK; // module is loaded
 }

rpcs3/Emu/ARMv7/PSVFuncList.cpp

@@ -4,14 +4,14 @@
 #include "PSVFuncList.h"
 
 psv_log_base::psv_log_base(const std::string& name, init_func_t init)
-	: m_name(name)
+	: _log::channel(name)
 	, m_init(init)
 {
 	on_error = [this](s32 code, psv_func* func)
 	{
 		if (code < 0)
 		{
-			Error("%s() failed: 0x%08X", func->name, code);
+			error("%s() failed: 0x%08X", func->name, code);
 			Emu.Pause();
 		}
 	};

rpcs3/Emu/ARMv7/PSVFuncList.h

@@ -2,16 +2,14 @@
 
 #include "Emu/Memory/Memory.h"
 #include "ARMv7Thread.h"
-#include "Emu/SysCalls/LogBase.h"
 
 namespace vm { using namespace psv; }
 
 // PSV module class
-class psv_log_base : public LogBase
+class psv_log_base : public _log::channel
 {
 	using init_func_t = void(*)();
 
-	std::string m_name;
 	init_func_t m_init;
 
 public:
@@ -32,12 +30,6 @@ public:
 
 		m_init();
 	}
-
-	virtual const std::string& GetName() const override
-	{
-		return m_name;
-	}
-
 };
 
 using armv7_func_caller = void(*)(ARMv7Thread&);

rpcs3/Emu/CPU/CPUThread.cpp

@@ -89,7 +89,7 @@ void CPUThread::dump_info() const
 {
 	if (!Emu.IsStopped())
 	{
-		LOG_NOTICE(GENERAL, RegsToString());
+		LOG_NOTICE(GENERAL, "%s", RegsToString());
 	}
 }
 

rpcs3/Emu/Cell/PPULLVMRecompiler.cpp

@@ -188,7 +188,7 @@ void ppu_recompiler_llvm::Compiler::translate_to_llvm_ir(llvm::Module *module, c
 	std::string        verify;
 	raw_string_ostream verify_ostream(verify);
 	if (verifyFunction(*m_state.function, &verify_ostream)) {
-//		m_recompilation_engine.Log() << "Verification failed: " << verify_ostream.str() << "\n";
+//		m_recompilation_engine.trace() << "Verification failed: " << verify_ostream.str() << "\n";
 	}
 
 	m_module = nullptr;
@@ -421,13 +421,13 @@ std::pair<Executable, llvm::ExecutionEngine *> RecompilationEngine::compile(cons
 	Function *llvm_function = module_ptr->getFunction(name);
 	void *function = execution_engine->getPointerToFunction(llvm_function);
 
-	/*    m_recompilation_engine.Log() << "\nDisassembly:\n";
+	/*    m_recompilation_engine.trace() << "\nDisassembly:\n";
 	auto disassembler = LLVMCreateDisasm(sys::getProcessTriple().c_str(), nullptr, 0, nullptr, nullptr);
 	for (size_t pc = 0; pc < mci.size();) {
 	char str[1024];
 
 	auto size = LLVMDisasmInstruction(disassembler, ((u8 *)mci.address()) + pc, mci.size() - pc, (uint64_t)(((u8 *)mci.address()) + pc), str, sizeof(str));
-	m_recompilation_engine.Log() << fmt::format("0x%08X: ", (u64)(((u8 *)mci.address()) + pc)) << str << '\n';
+	m_recompilation_engine.trace() << fmt::format("0x%08X: ", (u64)(((u8 *)mci.address()) + pc)) << str << '\n';
 	pc += size;
 	}
 

rpcs3/Emu/Cell/RawSPUThread.cpp

@@ -60,7 +60,7 @@ bool RawSPUThread::read_reg(const u32 addr, u32& value)
 	}
 	}
 
-	LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Read32(0x%x): unknown/illegal offset (0x%x)", index, addr, offset);
+	LOG_ERROR(SPU, "RawSPUThread[%d]: Read32(0x%x): unknown/illegal offset (0x%x)", index, addr, offset);
 	return false;
 }
 

rpcs3/Emu/Cell/SPUThread.cpp

@@ -376,10 +376,7 @@ void SPUThread::do_dma_list_cmd(u32 cmd, spu_mfc_arg_t args)
 
 void SPUThread::process_mfc_cmd(u32 cmd)
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "DMA %s: cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x", get_mfc_cmd_name(cmd), cmd, ch_mfc_args.lsa, ch_mfc_args.ea, ch_mfc_args.tag, ch_mfc_args.size);
-	{
-		LOG_NOTICE(SPU, "DMA %s: cmd=0x%x, lsa=0x%x, ea=0x%llx, tag=0x%x, size=0x%x", get_mfc_cmd_name(cmd), cmd, ch_mfc_args.lsa, ch_mfc_args.ea, ch_mfc_args.tag, ch_mfc_args.size);
-	}
 
 	switch (cmd)
 	{
@@ -576,10 +573,7 @@ void SPUThread::set_interrupt_status(bool enable)
 
 u32 SPUThread::get_ch_count(u32 ch)
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "get_ch_count(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	{
-		LOG_NOTICE(SPU, "get_ch_count(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	}
 
 	switch (ch)
 	{
@@ -603,10 +597,7 @@ u32 SPUThread::get_ch_count(u32 ch)
 
 u32 SPUThread::get_ch_value(u32 ch)
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "get_ch_value(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	{
-		LOG_NOTICE(SPU, "get_ch_value(ch=%d [%s])", ch, ch < 128 ? spu_ch_name[ch] : "???");
-	}
 
 	auto read_channel = [this](spu_channel_t& channel) -> u32
 	{
@@ -767,10 +758,7 @@ u32 SPUThread::get_ch_value(u32 ch)
 
 void SPUThread::set_ch_value(u32 ch, u32 value)
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "set_ch_value(ch=%d [%s], value=0x%x)", ch, ch < 128 ? spu_ch_name[ch] : "???", value);
-	{
-		LOG_NOTICE(SPU, "set_ch_value(ch=%d [%s], value=0x%x)", ch, ch < 128 ? spu_ch_name[ch] : "???", value);
-	}
 
 	switch (ch)
 	{
@@ -826,10 +814,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 
 				ch_out_mbox.set_value(data, 0);
 
-				if (rpcs3::config.misc.log.hle_logging.value())
+				LOG_TRACE(SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, value & 0x00ffffff, data);
-				{
-					LOG_NOTICE(SPU, "sys_spu_thread_send_event(spup=%d, data0=0x%x, data1=0x%x)", spup, value & 0x00ffffff, data);
-				}
 
 				const auto queue = this->spup[spup].lock();
 
@@ -865,10 +850,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 
 				ch_out_mbox.set_value(data, 0);
 
-				if (rpcs3::config.misc.log.hle_logging.value())
+				LOG_TRACE(SPU, "sys_spu_thread_throw_event(spup=%d, data0=0x%x, data1=0x%x)", spup, value & 0x00ffffff, data);
-				{
-					LOG_WARNING(SPU, "sys_spu_thread_throw_event(spup=%d, data0=0x%x, data1=0x%x)", spup, value & 0x00ffffff, data);
-				}
 
 				const auto queue = this->spup[spup].lock();
 
@@ -915,10 +897,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 					throw EXCEPTION("sys_event_flag_set_bit(id=%d, value=0x%x (flag=%d)): Invalid flag", data, value, flag);
 				}
 
-				if (rpcs3::config.misc.log.hle_logging.value())
+				LOG_TRACE(SPU, "sys_event_flag_set_bit(id=%d, value=0x%x (flag=%d))", data, value, flag);
-				{
-					LOG_WARNING(SPU, "sys_event_flag_set_bit(id=%d, value=0x%x (flag=%d))", data, value, flag);
-				}
 
 				const auto eflag = idm::get<lv2_event_flag_t>(data);
 
@@ -959,10 +938,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 					throw EXCEPTION("sys_event_flag_set_bit_impatient(id=%d, value=0x%x (flag=%d)): Invalid flag", data, value, flag);
 				}
 
-				if (rpcs3::config.misc.log.hle_logging.value())
+				LOG_TRACE(SPU, "sys_event_flag_set_bit_impatient(id=%d, value=0x%x (flag=%d))", data, value, flag);
-				{
-					LOG_WARNING(SPU, "sys_event_flag_set_bit_impatient(id=%d, value=0x%x (flag=%d))", data, value, flag);
-				}
 
 				const auto eflag = idm::get<lv2_event_flag_t>(data);
 
@@ -1158,10 +1134,7 @@ void SPUThread::set_ch_value(u32 ch, u32 value)
 
 void SPUThread::stop_and_signal(u32 code)
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "stop_and_signal(code=0x%x)", code);
-	{
-		LOG_NOTICE(SPU, "stop_and_signal(code=0x%x)", code);
-	}
 
 	if (m_type == CPU_THREAD_RAW_SPU)
 	{
@@ -1229,10 +1202,7 @@ void SPUThread::stop_and_signal(u32 code)
 
 		ch_out_mbox.set_value(spuq, 0);
 
-		if (rpcs3::config.misc.log.hle_logging.value())
+		LOG_TRACE(SPU, "sys_spu_thread_receive_event(spuq=0x%x)", spuq);
-		{
-			LOG_NOTICE(SPU, "sys_spu_thread_receive_event(spuq=0x%x)", spuq);
-		}
 
 		const auto group = tg.lock();
 
@@ -1355,10 +1325,7 @@ void SPUThread::stop_and_signal(u32 code)
 
 		ch_out_mbox.set_value(value, 0);
 
-		if (rpcs3::config.misc.log.hle_logging.value())
+		LOG_TRACE(SPU, "sys_spu_thread_group_exit(status=0x%x)", value);
-		{
-			LOG_NOTICE(SPU, "sys_spu_thread_group_exit(status=0x%x)", value);
-		}
 
 		const auto group = tg.lock();
 
@@ -1394,10 +1361,7 @@ void SPUThread::stop_and_signal(u32 code)
 			throw EXCEPTION("sys_spu_thread_exit(): Out_MBox is empty");
 		}
 
-		if (rpcs3::config.misc.log.hle_logging.value())
+		LOG_TRACE(SPU, "sys_spu_thread_exit(status=0x%x)", ch_out_mbox.get_value());
-		{
-			LOG_NOTICE(SPU, "sys_spu_thread_exit(status=0x%x)", ch_out_mbox.get_value());
-		}
 
 		const auto group = tg.lock();
 
@@ -1425,10 +1389,7 @@ void SPUThread::stop_and_signal(u32 code)
 
 void SPUThread::halt()
 {
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(SPU, "halt()");
-	{
-		LOG_NOTICE(SPU, "halt()");
-	}
 
 	if (m_type == CPU_THREAD_RAW_SPU)
 	{

rpcs3/Emu/RSX/CgBinaryVertexProgram.cpp

@@ -60,7 +60,7 @@ std::string CgBinaryDisasm::GetDSTDisasm(bool isSca)
 
 	default:
 		if (d3.dst > 15)
-			LOG_ERROR(RSX, fmt::format("dst index out of range: %u", d3.dst));
+			LOG_ERROR(RSX, "dst index out of range: %u", d3.dst);
 
 		ret += fmt::format("o[%d]", d3.dst) + GetVecMaskDisasm();
 		break;
@@ -94,7 +94,7 @@ std::string CgBinaryDisasm::GetSRCDisasm(const u32 n)
 		break;
 
 	default:
-		LOG_ERROR(RSX, fmt::format("Bad src%u reg type: %d", n, u32{ src[n].reg_type }));
+		LOG_ERROR(RSX, "Bad src%u reg type: %d", n, u32{ src[n].reg_type });
 		Emu.Pause();
 		break;
 	}

rpcs3/Emu/RSX/Common/VertexProgramDecompiler.cpp

@@ -47,7 +47,7 @@ std::string VertexProgramDecompiler::GetDST(bool isSca)
 
 	default:
 		if (d3.dst > 15)
-			LOG_ERROR(RSX, fmt::format("dst index out of range: %u", d3.dst));
+			LOG_ERROR(RSX, "dst index out of range: %u", d3.dst);
 		ret += m_parr.AddParam(PF_PARAM_NONE, getFloatTypeName(4), std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? getFloatTypeName(4) + "(0.0f, 0.0f, 0.0f, 1.0f)" : getFloatTypeName(4) + "(0.0, 0.0, 0.0, 0.0)");
 		break;
 	}
@@ -91,7 +91,7 @@ std::string VertexProgramDecompiler::GetSRC(const u32 n)
 		break;
 
 	default:
-		LOG_ERROR(RSX, fmt::format("Bad src%u reg type: %d", n, u32{ src[n].reg_type }));
+		LOG_ERROR(RSX, "Bad src%u reg type: %d", n, u32{ src[n].reg_type });
 		Emu.Pause();
 		break;
 	}

rpcs3/Emu/RSX/GL/GLGSRender.cpp

@@ -566,9 +566,9 @@ void GLGSRender::on_init_thread()
 	GSRender::on_init_thread();
 
 	gl::init();
-	LOG_NOTICE(Log::RSX, (const char*)glGetString(GL_VERSION));
+	LOG_NOTICE(RSX, "%s", (const char*)glGetString(GL_VERSION));
-	LOG_NOTICE(Log::RSX, (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
+	LOG_NOTICE(RSX, "%s", (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION));
-	LOG_NOTICE(Log::RSX, (const char*)glGetString(GL_VENDOR));
+	LOG_NOTICE(RSX, "%s", (const char*)glGetString(GL_VENDOR));
 
 	glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
 	m_vao.create();

rpcs3/Emu/RSX/RSXThread.cpp

@@ -424,7 +424,7 @@ namespace rsx
 
 			if (cmd & 0x3)
 			{
-				LOG_WARNING(Log::RSX, "unaligned command: %s (0x%x from 0x%x)", get_method_name(first_cmd).c_str(), first_cmd, cmd & 0xffff);
+				LOG_WARNING(RSX, "unaligned command: %s (0x%x from 0x%x)", get_method_name(first_cmd).c_str(), first_cmd, cmd & 0xffff);
 			}
 
 			for (u32 i = 0; i < count; i++)
@@ -434,7 +434,7 @@ namespace rsx
 
 				if (rpcs3::config.misc.log.rsx_logging.value())
 				{
-					LOG_NOTICE(Log::RSX, "%s(0x%x) = 0x%x", get_method_name(reg).c_str(), reg, value);
+					LOG_NOTICE(RSX, "%s(0x%x) = 0x%x", get_method_name(reg).c_str(), reg, value);
 				}
 
 				method_registers[reg] = value;

rpcs3/Emu/SysCalls/LogBase.cpp

@@ -1,21 +0,0 @@
-#include "stdafx.h"
-#include "Emu/System.h"
-#include "Emu/state.h"
-#include "LogBase.h"
-
-bool LogBase::CheckLogging() const
-{
-	return rpcs3::config.misc.log.hle_logging.value() || m_logging;
-}
-
-void LogBase::LogOutput(LogType type, std::string text) const
-{
-	switch (type)
-	{
-	case LogNotice: LOG_NOTICE(HLE, GetName() + ": " + text); break;
-	case LogSuccess: LOG_SUCCESS(HLE, GetName() + ": " + text); break;
-	case LogWarning: LOG_WARNING(HLE, GetName() + ": " + text); break;
-	case LogError: LOG_ERROR(HLE, GetName() + ": " + text); break;
-	case LogTodo: LOG_ERROR(HLE, GetName() + " TODO: " + text); break;
-	}
-}

rpcs3/Emu/SysCalls/LogBase.h

@@ -1,74 +0,0 @@
-#pragma once
-
-class LogBase
-{
-	bool m_logging;
-	bool CheckLogging() const;
-
-	enum LogType
-	{
-		LogNotice,
-		LogSuccess,
-		LogWarning,
-		LogError,
-		LogTodo,
-	};
-
-	void LogOutput(LogType type, std::string text) const;
-
-	template<typename... Args> never_inline safe_buffers void LogPrepare(LogType type, const char* fmt, Args... args) const
-	{
-		LogOutput(type, fmt::format(fmt, args...));
-	}
-
-	never_inline safe_buffers void LogPrepare(LogType type, const char* fmt) const
-	{
-		LogOutput(type, fmt);
-	}
-
-public:
-	void SetLogging(bool value)
-	{
-		m_logging = value;
-	}
-
-	LogBase()
-	{
-		SetLogging(false);
-	}
-
-	virtual const std::string& GetName() const = 0;
-
-	template<typename... Args> force_inline void Notice(const char* fmt, Args... args) const
-	{
-		LogPrepare(LogNotice, fmt, fmt::do_unveil(args)...);
-	}
-
-	template<typename... Args> force_inline void Log(const char* fmt, Args... args) const
-	{
-		if (CheckLogging())
-		{
-			Notice(fmt, args...);
-		}
-	}
-
-	template<typename... Args> force_inline void Success(const char* fmt, Args... args) const
-	{
-		LogPrepare(LogSuccess, fmt, fmt::do_unveil(args)...);
-	}
-
-	template<typename... Args> force_inline void Warning(const char* fmt, Args... args) const
-	{
-		LogPrepare(LogWarning, fmt, fmt::do_unveil(args)...);
-	}
-
-	template<typename... Args> force_inline void Error(const char* fmt, Args... args) const
-	{
-		LogPrepare(LogError, fmt, fmt::do_unveil(args)...);
-	}
-
-	template<typename... Args> force_inline void Todo(const char* fmt, Args... args) const
-	{
-		LogPrepare(LogTodo, fmt, fmt::do_unveil(args)...);
-	}
-};

rpcs3/Emu/SysCalls/Modules.cpp

@@ -144,10 +144,7 @@ void execute_ppu_func_by_index(PPUThread& ppu, u32 index)
 				throw EXCEPTION("Forced HLE enabled: %s (0x%llx)", get_ps3_function_name(func->id), func->id);
 			}
 
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(HLE, "Branch to LLE function: %s (0x%llx)", get_ps3_function_name(func->id), func->id);
-			{
-				LOG_NOTICE(HLE, "Branch to LLE function: %s (0x%llx)", get_ps3_function_name(func->id), func->id);
-			}
 
 			if (index & EIF_PERFORM_BLR)
 			{
@@ -173,35 +170,23 @@ void execute_ppu_func_by_index(PPUThread& ppu, u32 index)
 			const u32 pc = data[0];
 			const u32 rtoc = data[1];
 
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(HLE, "LLE function called: %s", get_ps3_function_name(func->id));
-			{
-				LOG_NOTICE(HLE, "LLE function called: %s", get_ps3_function_name(func->id));
-			}
 			
 			ppu.fast_call(pc, rtoc);
 
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(HLE, "LLE function finished: %s -> 0x%llx", get_ps3_function_name(func->id), ppu.GPR[3]);
-			{
-				LOG_NOTICE(HLE, "LLE function finished: %s -> 0x%llx", get_ps3_function_name(func->id), ppu.GPR[3]);
-			}
 		}
 		else if (func->func)
 		{
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(HLE, "HLE function called: %s", get_ps3_function_name(func->id));
-			{
-				LOG_NOTICE(HLE, "HLE function called: %s", get_ps3_function_name(func->id));
-			}
 
 			func->func(ppu);
 
-			if (rpcs3::config.misc.log.hle_logging.value())
+			LOG_TRACE(HLE, "HLE function finished: %s -> 0x%llx", get_ps3_function_name(func->id), ppu.GPR[3]);
-			{
-				LOG_NOTICE(HLE, "HLE function finished: %s -> 0x%llx", get_ps3_function_name(func->id), ppu.GPR[3]);
-			}
 		}
 		else
 		{
-			LOG_ERROR(HLE, "Unimplemented function: %s -> CELL_OK", get_ps3_function_name(func->id));
+			LOG_TODO(HLE, "Unimplemented function: %s -> CELL_OK", get_ps3_function_name(func->id));
 			ppu.GPR[3] = 0;
 		}
 
@@ -529,9 +514,9 @@ bool patch_ppu_import(u32 addr, u32 index)
 	return false;
 }
 
-Module<>::Module(const char* name, void(*init)())
+Module<>::Module(const std::string& name, void(*init)())
-	: m_is_loaded(false)
+	: _log::channel(name, _log::level::notice)
-	, m_name(name)
+	, m_is_loaded(false)
 	, m_init(init)
 {
 }
@@ -589,13 +574,3 @@ bool Module<>::IsLoaded() const
 {
 	return m_is_loaded;
 }
-
-const std::string& Module<>::GetName() const
-{
-	return m_name;
-}
-
-void Module<>::SetName(const std::string& name)
-{
-	m_name = name;
-}

rpcs3/Emu/SysCalls/Modules.h

@@ -3,7 +3,6 @@
 #include "Emu/SysCalls/SC_FUNC.h"
 #include "Emu/SysCalls/CB_FUNC.h"
 #include "ErrorCodes.h"
-#include "LogBase.h"
 
 namespace vm { using namespace ps3; }
 
@@ -67,11 +66,10 @@ struct StaticFunc
 	std::unordered_map<u32, u32> labels;
 };
 
-template<> class Module<void> : public LogBase
+template<> class Module<void> : public _log::channel
 {
 	friend class ModuleManager;
 
-	std::string m_name;
 	bool m_is_loaded;
 	void(*m_init)();
 
@@ -79,7 +77,7 @@ protected:
 	std::function<void()> on_alloc;
 
 public:
-	Module(const char* name, void(*init)());
+	Module(const std::string& name, void(*init)());
 
 	Module(const Module&) = delete; // Delete copy/move constructors and copy/move operators
 
@@ -96,9 +94,6 @@ public:
 
 	void SetLoaded(bool loaded = true);
 	bool IsLoaded() const;
-
-	virtual const std::string& GetName() const override;
-	void SetName(const std::string& name);
 };
 
 // Module<> with an instance of specified type in PS3 memory
@@ -187,4 +182,4 @@ template<typename T, T Func, typename... Args, typename RT = std::result_of_t<T(
 #define SP_LABEL_BR(op, label) SP_OP(SPET_BRANCH_TO_LABEL, op, label)
 #define SP_CALL(op, name) SP_OP(SPET_BRANCH_TO_FUNC, op, get_function_id(#name))
 
-#define UNIMPLEMENTED_FUNC(module) module.Error("%s", __FUNCTION__)
+#define UNIMPLEMENTED_FUNC(module) module.todo("%s", __FUNCTION__)

rpcs3/Emu/SysCalls/Modules/cellAdec.cpp

@@ -131,7 +131,7 @@ next:
 		OMAHeader oma(1 /* atrac3p id */, adec.sample_rate, adec.ch_cfg, adec.frame_size);
 		if (buf_size < sizeof(oma))
 		{
-			cellAdec.Error("adecRead(): OMAHeader writing failed");
+			cellAdec.error("adecRead(): OMAHeader writing failed");
 			Emu.Pause();
 			return 0;
 		}
@@ -149,7 +149,7 @@ next:
 		AdecTask task;
 		if (!adec.job.peek(task, 0, &adec.is_closed))
 		{
-			if (Emu.IsStopped()) cellAdec.Warning("adecRawRead() aborted");
+			if (Emu.IsStopped()) cellAdec.warning("adecRawRead() aborted");
 			return 0;
 		}
 
@@ -183,7 +183,7 @@ next:
 		
 		default:
 		{
-			cellAdec.Error("adecRawRead(): unknown task (%d)", task.type);
+			cellAdec.error("adecRawRead(): unknown task (%d)", task.type);
 			Emu.Pause();
 			return -1;
 		}
@@ -243,7 +243,7 @@ void adecOpen(u32 adec_id) // TODO: call from the constructor
 			case adecStartSeq:
 			{
 				// TODO: reset data
-				cellAdec.Warning("adecStartSeq:");
+				cellAdec.warning("adecStartSeq:");
 
 				adec.reader.addr = 0;
 				adec.reader.size = 0;
@@ -265,7 +265,7 @@ void adecOpen(u32 adec_id) // TODO: call from the constructor
 			case adecEndSeq:
 			{
 				// TODO: finalize
-				cellAdec.Warning("adecEndSeq:");
+				cellAdec.warning("adecEndSeq:");
 				adec.cbFunc(CPU, adec.id, CELL_ADEC_MSG_TYPE_SEQDONE, CELL_OK, adec.cbArg);
 
 				adec.just_finished = true;
@@ -361,7 +361,7 @@ void adecOpen(u32 adec_id) // TODO: call from the constructor
 				{
 					if (Emu.IsStopped() || adec.is_closed)
 					{
-						if (Emu.IsStopped()) cellAdec.Warning("adecDecodeAu: aborted");
+						if (Emu.IsStopped()) cellAdec.warning("adecDecodeAu: aborted");
 						break;
 					}
 
@@ -405,7 +405,7 @@ void adecOpen(u32 adec_id) // TODO: call from the constructor
 					{
 						if (decode < 0)
 						{
-							cellAdec.Error("adecDecodeAu: AU decoding error(0x%x)", decode);
+							cellAdec.error("adecDecodeAu: AU decoding error(0x%x)", decode);
 						}
 						if (!got_frame && adec.reader.size == 0) break;
 					}
@@ -475,11 +475,11 @@ bool adecCheckType(s32 type)
 {
 	switch (type)
 	{
-	case CELL_ADEC_TYPE_ATRACX: cellAdec.Notice("adecCheckType(): ATRAC3plus"); break;
+	case CELL_ADEC_TYPE_ATRACX: cellAdec.notice("adecCheckType(): ATRAC3plus"); break;
-	case CELL_ADEC_TYPE_ATRACX_2CH: cellAdec.Notice("adecCheckType(): ATRAC3plus 2ch"); break;
+	case CELL_ADEC_TYPE_ATRACX_2CH: cellAdec.notice("adecCheckType(): ATRAC3plus 2ch"); break;
-	case CELL_ADEC_TYPE_ATRACX_6CH: cellAdec.Notice("adecCheckType(): ATRAC3plus 6ch"); break;
+	case CELL_ADEC_TYPE_ATRACX_6CH: cellAdec.notice("adecCheckType(): ATRAC3plus 6ch"); break;
-	case CELL_ADEC_TYPE_ATRACX_8CH: cellAdec.Notice("adecCheckType(): ATRAC3plus 8ch"); break;
+	case CELL_ADEC_TYPE_ATRACX_8CH: cellAdec.notice("adecCheckType(): ATRAC3plus 8ch"); break;
-	case CELL_ADEC_TYPE_MP3: cellAdec.Notice("adecCheckType(): MP3"); break;
+	case CELL_ADEC_TYPE_MP3: cellAdec.notice("adecCheckType(): MP3"); break;
 
 	case CELL_ADEC_TYPE_LPCM_PAMF:
 	case CELL_ADEC_TYPE_AC3:
@@ -489,7 +489,7 @@ bool adecCheckType(s32 type)
 	case CELL_ADEC_TYPE_M4AAC:
 	case CELL_ADEC_TYPE_CELP8:
 	{
-		cellAdec.Todo("Unimplemented audio codec type (%d)", type);
+		cellAdec.todo("Unimplemented audio codec type (%d)", type);
 		Emu.Pause();
 		break;
 	}	
@@ -501,7 +501,7 @@ bool adecCheckType(s32 type)
 
 s32 cellAdecQueryAttr(vm::ptr<CellAdecType> type, vm::ptr<CellAdecAttr> attr)
 {
-	cellAdec.Warning("cellAdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
+	cellAdec.warning("cellAdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
 
 	if (!adecCheckType(type->audioCodecType))
 	{
@@ -518,7 +518,7 @@ s32 cellAdecQueryAttr(vm::ptr<CellAdecType> type, vm::ptr<CellAdecAttr> attr)
 
 s32 cellAdecOpen(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResource> res, vm::ptr<CellAdecCb> cb, vm::ptr<u32> handle)
 {
-	cellAdec.Warning("cellAdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellAdec.warning("cellAdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	if (!adecCheckType(type->audioCodecType))
 	{
@@ -532,7 +532,7 @@ s32 cellAdecOpen(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResource> res, vm::
 
 s32 cellAdecOpenEx(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res, vm::ptr<CellAdecCb> cb, vm::ptr<u32> handle)
 {
-	cellAdec.Warning("cellAdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellAdec.warning("cellAdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	if (!adecCheckType(type->audioCodecType))
 	{
@@ -546,14 +546,14 @@ s32 cellAdecOpenEx(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res,
 
 s32 cellAdecOpenExt(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res, vm::ptr<CellAdecCb> cb, vm::ptr<u32> handle)
 {
-	cellAdec.Warning("cellAdecOpenExt(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellAdec.warning("cellAdecOpenExt(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	return cellAdecOpenEx(type, res, cb, handle);
 }
 
 s32 cellAdecClose(u32 handle)
 {
-	cellAdec.Warning("cellAdecClose(handle=0x%x)", handle);
+	cellAdec.warning("cellAdecClose(handle=0x%x)", handle);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -579,7 +579,7 @@ s32 cellAdecClose(u32 handle)
 
 s32 cellAdecStartSeq(u32 handle, u32 param)
 {
-	cellAdec.Warning("cellAdecStartSeq(handle=0x%x, param=*0x%x)", handle, param);
+	cellAdec.warning("cellAdecStartSeq(handle=0x%x, param=*0x%x)", handle, param);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -607,7 +607,7 @@ s32 cellAdecStartSeq(u32 handle, u32 param)
 		task.at3p.output = atx->bw_pcm;
 		task.at3p.downmix = atx->downmix_flag;
 		task.at3p.ats_header = atx->au_includes_ats_hdr_flg;
-		cellAdec.Todo("*** CellAdecParamAtracX: sr=%d, ch_cfg=%d(%d), frame_size=0x%x, extra=0x%x, output=%d, downmix=%d, ats_header=%d",
+		cellAdec.todo("*** CellAdecParamAtracX: sr=%d, ch_cfg=%d(%d), frame_size=0x%x, extra=0x%x, output=%d, downmix=%d, ats_header=%d",
 			task.at3p.sample_rate, task.at3p.channel_config, task.at3p.channels, task.at3p.frame_size, (u32&)task.at3p.extra_config, task.at3p.output, task.at3p.downmix, task.at3p.ats_header);
 		break;
 	}
@@ -615,12 +615,12 @@ s32 cellAdecStartSeq(u32 handle, u32 param)
 	{
 		const auto mp3 = vm::cptr<CellAdecParamMP3>::make(param);
 
-		cellAdec.Todo("*** CellAdecParamMP3: bw_pcm=%d", mp3->bw_pcm);
+		cellAdec.todo("*** CellAdecParamMP3: bw_pcm=%d", mp3->bw_pcm);
 		break;
 	}
 	default:
 	{
-		cellAdec.Todo("cellAdecStartSeq(): Unimplemented audio codec type(%d)", adec->type);
+		cellAdec.todo("cellAdecStartSeq(): Unimplemented audio codec type(%d)", adec->type);
 		Emu.Pause();
 		return CELL_OK;
 	}
@@ -632,7 +632,7 @@ s32 cellAdecStartSeq(u32 handle, u32 param)
 
 s32 cellAdecEndSeq(u32 handle)
 {
-	cellAdec.Warning("cellAdecEndSeq(handle=0x%x)", handle);
+	cellAdec.warning("cellAdecEndSeq(handle=0x%x)", handle);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -647,7 +647,7 @@ s32 cellAdecEndSeq(u32 handle)
 
 s32 cellAdecDecodeAu(u32 handle, vm::ptr<CellAdecAuInfo> auInfo)
 {
-	cellAdec.Log("cellAdecDecodeAu(handle=0x%x, auInfo=*0x%x)", handle, auInfo);
+	cellAdec.trace("cellAdecDecodeAu(handle=0x%x, auInfo=*0x%x)", handle, auInfo);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -663,14 +663,14 @@ s32 cellAdecDecodeAu(u32 handle, vm::ptr<CellAdecAuInfo> auInfo)
 	task.au.pts = ((u64)auInfo->pts.upper << 32) | (u64)auInfo->pts.lower;
 	task.au.userdata = auInfo->userData;
 
-	//cellAdec.Notice("cellAdecDecodeAu(): addr=0x%x, size=0x%x, pts=0x%llx", task.au.addr, task.au.size, task.au.pts);
+	//cellAdec.notice("cellAdecDecodeAu(): addr=0x%x, size=0x%x, pts=0x%llx", task.au.addr, task.au.size, task.au.pts);
 	adec->job.push(task, &adec->is_closed);
 	return CELL_OK;
 }
 
 s32 cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
 {
-	cellAdec.Log("cellAdecGetPcm(handle=0x%x, outBuffer=*0x%x)", handle, outBuffer);
+	cellAdec.trace("cellAdecGetPcm(handle=0x%x, outBuffer=*0x%x)", handle, outBuffer);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -786,7 +786,7 @@ s32 cellAdecGetPcm(u32 handle, vm::ptr<float> outBuffer)
 
 s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
 {
-	cellAdec.Log("cellAdecGetPcmItem(handle=0x%x, pcmItem=**0x%x)", handle, pcmItem);
+	cellAdec.trace("cellAdecGetPcmItem(handle=0x%x, pcmItem=**0x%x)", handle, pcmItem);
 
 	const auto adec = idm::get<AudioDecoder>(handle);
 
@@ -847,7 +847,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
 		}
 		else
 		{
-			cellAdec.Error("cellAdecGetPcmItem(): unsupported channel count (%d)", frame->channels);
+			cellAdec.error("cellAdecGetPcmItem(): unsupported channel count (%d)", frame->channels);
 			Emu.Pause();
 		}
 	}

rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp

@@ -7,7 +7,7 @@
 
 s32 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
 {
-	cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte);
+	cellAtrac.warning("cellAtracSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte);
 
 	*puiWorkMemByte = 0x1000;
 	return CELL_OK;
@@ -15,7 +15,7 @@ s32 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8>
 
 s32 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
 {
-	cellAtrac.Warning("cellAtracCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
+	cellAtrac.warning("cellAtracCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
 
 	pHandle->pucWorkMem = pucWorkMem;
 	return CELL_OK;
@@ -23,7 +23,7 @@ s32 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucWork
 
 s32 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
 {
-	cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
+	cellAtrac.warning("cellAtracCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
 
 	pHandle->pucWorkMem = pucWorkMem;
 	return CELL_OK;
@@ -31,14 +31,14 @@ s32 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucW
 
 s32 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
 {
-	cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=*0x%x)", pHandle);
+	cellAtrac.warning("cellAtracDeleteDecoder(pHandle=*0x%x)", pHandle);
 
 	return CELL_OK;
 }
 
 s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, vm::ptr<float> pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<s32> piRemainFrame)
 {
-	cellAtrac.Warning("cellAtracDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
+	cellAtrac.warning("cellAtracDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
 
 	*puiSamples = 0;
 	*puiFinishflag = 1;
@@ -48,7 +48,7 @@ s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, vm::ptr<float> pfOutAddr,
 
 s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::pptr<u8> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
 {
-	cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
+	cellAtrac.warning("cellAtracGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
 
 	*ppucWritePointer = pHandle->pucWorkMem;
 	*puiWritableByte = 0x1000;
@@ -58,14 +58,14 @@ s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::pptr<u8> pp
 
 s32 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
 {
-	cellAtrac.Warning("cellAtracAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte);
+	cellAtrac.warning("cellAtracAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte);
 
 	return CELL_OK;
 }
 
 s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piRemainFrame)
 {
-	cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame);
+	cellAtrac.warning("cellAtracGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame);
 
 	*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
 	return CELL_OK;
@@ -73,7 +73,7 @@ s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piRem
 
 s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize)
 {
-	cellAtrac.Warning("cellAtracGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize);
+	cellAtrac.warning("cellAtracGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize);
 
 	*puiVacantSize = 0x1000;
 	return CELL_OK;
@@ -81,14 +81,14 @@ s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVac
 
 s32 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
 {
-	cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=*0x%x)", pHandle);
+	cellAtrac.warning("cellAtracIsSecondBufferNeeded(pHandle=*0x%x)", pHandle);
 
 	return 0;
 }
 
 s32 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
 {
-	cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
+	cellAtrac.warning("cellAtracGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
 
 	*puiReadPosition = 0;
 	*puiDataByte = 0; // write to null block will occur
@@ -97,14 +97,14 @@ s32 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32>
 
 s32 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucSecondBufferAddr, u32 uiSecondBufferByte)
 {
-	cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
+	cellAtrac.warning("cellAtracSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
 
 	return CELL_OK;
 }
 
 s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel)
 {
-	cellAtrac.Warning("cellAtracGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel);
+	cellAtrac.warning("cellAtracGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel);
 
 	*puiChannel = 2;
 	return CELL_OK;
@@ -112,7 +112,7 @@ s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChanne
 
 s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample)
 {
-	cellAtrac.Warning("cellAtracGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample);
+	cellAtrac.warning("cellAtracGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample);
 
 	*puiMaxSample = 512;
 	return CELL_OK;
@@ -120,7 +120,7 @@ s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxS
 
 s32 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample)
 {
-	cellAtrac.Warning("cellAtracGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample);
+	cellAtrac.warning("cellAtracGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample);
 
 	*puiNextSample = 0;
 	return CELL_OK;
@@ -128,7 +128,7 @@ s32 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNex
 
 s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piEndSample, vm::ptr<s32> piLoopStartSample, vm::ptr<s32> piLoopEndSample)
 {
-	cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
+	cellAtrac.warning("cellAtracGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
 
 	*piEndSample = 0;
 	*piLoopStartSample = 0;
@@ -138,7 +138,7 @@ s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piEndSa
 
 s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition)
 {
-	cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
+	cellAtrac.warning("cellAtracGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
 
 	*puiSamplePosition = 0;
 	return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
@@ -146,7 +146,7 @@ s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32
 
 s32 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate)
 {
-	cellAtrac.Warning("cellAtracGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
+	cellAtrac.warning("cellAtracGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
 
 	*puiBitrate = 128;
 	return CELL_OK;
@@ -154,7 +154,7 @@ s32 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrat
 
 s32 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piLoopNum, vm::ptr<u32> puiLoopStatus)
 {
-	cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
+	cellAtrac.warning("cellAtracGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
 
 	*piLoopNum = 0;
 	*puiLoopStatus = 0;
@@ -163,14 +163,14 @@ s32 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piLoopNu
 
 s32 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, s32 iLoopNum)
 {
-	cellAtrac.Warning("cellAtracSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum);
+	cellAtrac.warning("cellAtracSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum);
 
 	return CELL_OK;
 }
 
 s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
 {
-	cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
+	cellAtrac.warning("cellAtracGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
 
 	pBufferInfo->pucWriteAddr = pHandle->pucWorkMem;
 	pBufferInfo->uiWritableByte = 0x1000;
@@ -181,14 +181,14 @@ s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiS
 
 s32 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
 {
-	cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle, uiSample, uiWriteByte);
+	cellAtrac.warning("cellAtracResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle, uiSample, uiWriteByte);
 
 	return CELL_OK;
 }
 
 s32 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piResult)
 {
-	cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
+	cellAtrac.warning("cellAtracGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
 
 	*piResult = 0;
 	return CELL_OK;

rpcs3/Emu/SysCalls/Modules/cellAtracMulti.cpp

@@ -7,7 +7,7 @@
 
 s32 cellAtracMultiSetDataAndGetMemSize(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u8> pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, u32 uiOutputChNum, vm::ptr<s32> piTrackArray, vm::ptr<u32> puiWorkMemByte)
 {
-	cellAtracMulti.Warning("cellAtracMultiSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, uiOutputChNum=%d, piTrackArray=*0x%x, puiWorkMemByte=*0x%x)",
+	cellAtracMulti.warning("cellAtracMultiSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, uiOutputChNum=%d, piTrackArray=*0x%x, puiWorkMemByte=*0x%x)",
 		pHandle, pucBufferAddr, uiReadByte, uiBufferByte, uiOutputChNum, piTrackArray, puiWorkMemByte);
 
 	*puiWorkMemByte = 0x1000;
@@ -16,7 +16,7 @@ s32 cellAtracMultiSetDataAndGetMemSize(vm::ptr<CellAtracMultiHandle> pHandle, vm
 
 s32 cellAtracMultiCreateDecoder(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
 {
-	cellAtracMulti.Warning("cellAtracMultiCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
+	cellAtracMulti.warning("cellAtracMultiCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
 
 	pHandle->pucWorkMem = pucWorkMem;
 	return CELL_OK;
@@ -24,7 +24,7 @@ s32 cellAtracMultiCreateDecoder(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u
 
 s32 cellAtracMultiCreateDecoderExt(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, vm::ptr<CellAtracMultiExtRes> pExtRes)
 {
-	cellAtracMulti.Warning("cellAtracMultiCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
+	cellAtracMulti.warning("cellAtracMultiCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
 
 	pHandle->pucWorkMem = pucWorkMem;
 	return CELL_OK;
@@ -32,14 +32,14 @@ s32 cellAtracMultiCreateDecoderExt(vm::ptr<CellAtracMultiHandle> pHandle, vm::pt
 
 s32 cellAtracMultiDeleteDecoder(vm::ptr<CellAtracMultiHandle> pHandle)
 {
-	cellAtracMulti.Warning("cellAtracMultiDeleteDecoder(pHandle=*0x%x)", pHandle);
+	cellAtracMulti.warning("cellAtracMultiDeleteDecoder(pHandle=*0x%x)", pHandle);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiDecode(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<float> pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<s32> piRemainFrame)
 {
-	cellAtracMulti.Warning("cellAtracMultiDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
+	cellAtracMulti.warning("cellAtracMultiDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
 
 	*puiSamples = 0;
 	*puiFinishflag = 1;
@@ -49,7 +49,7 @@ s32 cellAtracMultiDecode(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<float> p
 
 s32 cellAtracMultiGetStreamDataInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::pptr<u8> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
+	cellAtracMulti.warning("cellAtracMultiGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
 
 	*ppucWritePointer = pHandle->pucWorkMem;
 	*puiWritableByte = 0x1000;
@@ -59,14 +59,14 @@ s32 cellAtracMultiGetStreamDataInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::p
 
 s32 cellAtracMultiAddStreamData(vm::ptr<CellAtracMultiHandle> pHandle, u32 uiAddByte)
 {
-	cellAtracMulti.Warning("cellAtracMultiAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte);
+	cellAtracMulti.warning("cellAtracMultiAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiGetRemainFrame(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32> piRemainFrame)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame);
+	cellAtracMulti.warning("cellAtracMultiGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame);
 
 	*piRemainFrame = CELL_ATRACMULTI_ALLDATA_IS_ON_MEMORY;
 	return CELL_OK;
@@ -74,7 +74,7 @@ s32 cellAtracMultiGetRemainFrame(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<
 
 s32 cellAtracMultiGetVacantSize(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiVacantSize)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize);
+	cellAtracMulti.warning("cellAtracMultiGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize);
 
 	*puiVacantSize = 0x1000;
 	return CELL_OK;
@@ -82,14 +82,14 @@ s32 cellAtracMultiGetVacantSize(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u
 
 s32 cellAtracMultiIsSecondBufferNeeded(vm::ptr<CellAtracMultiHandle> pHandle)
 {
-	cellAtracMulti.Warning("cellAtracMultiIsSecondBufferNeeded(pHandle=*0x%x)", pHandle);
+	cellAtracMulti.warning("cellAtracMultiIsSecondBufferNeeded(pHandle=*0x%x)", pHandle);
 
 	return 0;
 }
 
 s32 cellAtracMultiGetSecondBufferInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
+	cellAtracMulti.warning("cellAtracMultiGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
 
 	*puiReadPosition = 0;
 	*puiDataByte = 0; // write to null block will occur
@@ -98,14 +98,14 @@ s32 cellAtracMultiGetSecondBufferInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm:
 
 s32 cellAtracMultiSetSecondBuffer(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u8> pucSecondBufferAddr, u32 uiSecondBufferByte)
 {
-	cellAtracMulti.Warning("cellAtracMultiSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
+	cellAtracMulti.warning("cellAtracMultiSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiGetChannel(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiChannel)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel);
+	cellAtracMulti.warning("cellAtracMultiGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel);
 
 	*puiChannel = 2;
 	return CELL_OK;
@@ -113,7 +113,7 @@ s32 cellAtracMultiGetChannel(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32>
 
 s32 cellAtracMultiGetMaxSample(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiMaxSample)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample);
+	cellAtracMulti.warning("cellAtracMultiGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample);
 
 	*puiMaxSample = 512;
 	return CELL_OK;
@@ -121,7 +121,7 @@ s32 cellAtracMultiGetMaxSample(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u3
 
 s32 cellAtracMultiGetNextSample(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiNextSample)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample);
+	cellAtracMulti.warning("cellAtracMultiGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample);
 
 	*puiNextSample = 0;
 	return CELL_OK;
@@ -129,7 +129,7 @@ s32 cellAtracMultiGetNextSample(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u
 
 s32 cellAtracMultiGetSoundInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32> piEndSample, vm::ptr<s32> piLoopStartSample, vm::ptr<s32> piLoopEndSample)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
+	cellAtracMulti.warning("cellAtracMultiGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
 
 	*piEndSample = 0;
 	*piLoopStartSample = 0;
@@ -139,7 +139,7 @@ s32 cellAtracMultiGetSoundInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s3
 
 s32 cellAtracMultiGetNextDecodePosition(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiSamplePosition)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
+	cellAtracMulti.warning("cellAtracMultiGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
 
 	*puiSamplePosition = 0;
 	return CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED;
@@ -147,7 +147,7 @@ s32 cellAtracMultiGetNextDecodePosition(vm::ptr<CellAtracMultiHandle> pHandle, v
 
 s32 cellAtracMultiGetBitrate(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32> puiBitrate)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
+	cellAtracMulti.warning("cellAtracMultiGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
 
 	*puiBitrate = 128;
 	return CELL_OK;
@@ -155,14 +155,14 @@ s32 cellAtracMultiGetBitrate(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<u32>
 
 s32 cellAtracMultiGetTrackArray(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32> piTrackArray)
 {
-	cellAtracMulti.Error("cellAtracMultiGetTrackArray(pHandle=*0x%x, piTrackArray=*0x%x)", pHandle, piTrackArray);
+	cellAtracMulti.error("cellAtracMultiGetTrackArray(pHandle=*0x%x, piTrackArray=*0x%x)", pHandle, piTrackArray);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiGetLoopInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32> piLoopNum, vm::ptr<u32> puiLoopStatus)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
+	cellAtracMulti.warning("cellAtracMultiGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
 
 	*piLoopNum = 0;
 	*puiLoopStatus = 0;
@@ -171,14 +171,14 @@ s32 cellAtracMultiGetLoopInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32
 
 s32 cellAtracMultiSetLoopNum(vm::ptr<CellAtracMultiHandle> pHandle, s32 iLoopNum)
 {
-	cellAtracMulti.Warning("cellAtracMultiSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum);
+	cellAtracMulti.warning("cellAtracMultiSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiGetBufferInfoForResetting(vm::ptr<CellAtracMultiHandle> pHandle, u32 uiSample, vm::ptr<CellAtracMultiBufferInfo> pBufferInfo)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
+	cellAtracMulti.warning("cellAtracMultiGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
 
 	pBufferInfo->pucWriteAddr = pHandle->pucWorkMem;
 	pBufferInfo->uiWritableByte = 0x1000;
@@ -189,14 +189,14 @@ s32 cellAtracMultiGetBufferInfoForResetting(vm::ptr<CellAtracMultiHandle> pHandl
 
 s32 cellAtracMultiResetPlayPosition(vm::ptr<CellAtracMultiHandle> pHandle, u32 uiSample, u32 uiWriteByte, vm::ptr<s32> piTrackArray)
 {
-	cellAtracMulti.Warning("cellAtracMultiResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x, piTrackArray=*0x%x)", pHandle, uiSample, uiWriteByte, piTrackArray);
+	cellAtracMulti.warning("cellAtracMultiResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x, piTrackArray=*0x%x)", pHandle, uiSample, uiWriteByte, piTrackArray);
 
 	return CELL_OK;
 }
 
 s32 cellAtracMultiGetInternalErrorInfo(vm::ptr<CellAtracMultiHandle> pHandle, vm::ptr<s32> piResult)
 {
-	cellAtracMulti.Warning("cellAtracMultiGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
+	cellAtracMulti.warning("cellAtracMultiGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
 
 	*piResult = 0;
 	return CELL_OK;

rpcs3/Emu/SysCalls/Modules/cellAudio.cpp

@@ -24,7 +24,7 @@ std::shared_ptr<thread_ctrl> g_audio_thread;
 
 s32 cellAudioInit()
 {
-	cellAudio.Warning("cellAudioInit()");
+	cellAudio.warning("cellAudioInit()");
 
 	if (!g_audio.state.compare_and_swap_test(AUDIO_STATE_NOT_INITIALIZED, AUDIO_STATE_INITIALIZED))
 	{
@@ -157,7 +157,7 @@ s32 cellAudioInit()
 			//const u64 missed_time = time_pos - expected_time;
 			//if (missed_time > AUDIO_SAMPLES * MHZ / 48000)
 			//{
-			//	cellAudio.Notice("%f ms adjusted", (float)missed_time / 1000);
+			//	cellAudio.notice("%f ms adjusted", (float)missed_time / 1000);
 			//	g_audio.start_time += missed_time;
 			//}
 
@@ -408,7 +408,7 @@ s32 cellAudioInit()
 
 s32 cellAudioQuit()
 {
-	cellAudio.Warning("cellAudioQuit()");
+	cellAudio.warning("cellAudioQuit()");
 
 	if (!g_audio.state.compare_and_swap_test(AUDIO_STATE_INITIALIZED, AUDIO_STATE_FINALIZED))
 	{
@@ -424,7 +424,7 @@ s32 cellAudioQuit()
 
 s32 cellAudioPortOpen(vm::ptr<CellAudioPortParam> audioParam, vm::ptr<u32> portNum)
 {
-	cellAudio.Warning("cellAudioPortOpen(audioParam=*0x%x, portNum=*0x%x)", audioParam, portNum);
+	cellAudio.warning("cellAudioPortOpen(audioParam=*0x%x, portNum=*0x%x)", audioParam, portNum);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -460,35 +460,35 @@ s32 cellAudioPortOpen(vm::ptr<CellAudioPortParam> audioParam, vm::ptr<u32> portN
 	// list unsupported flags
 	if (attr & CELL_AUDIO_PORTATTR_BGM)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_BGM");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_BGM");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_SECONDARY)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_SECONDARY");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_SECONDARY");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_PERSONAL_0)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_0");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_0");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_PERSONAL_1)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_1");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_1");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_PERSONAL_2)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_2");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_2");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_PERSONAL_3)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_3");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_PERSONAL_3");
 	}
 	if (attr & CELL_AUDIO_PORTATTR_OUT_NO_ROUTE)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_NO_ROUTE");
+		cellAudio.todo("cellAudioPortOpen(): CELL_AUDIO_PORTATTR_OUT_NO_ROUTE");
 	}
 	if (attr & 0xFFFFFFFFF0EFEFEEULL)
 	{
-		cellAudio.Todo("cellAudioPortOpen(): unknown attributes (0x%llx)", attr);
+		cellAudio.todo("cellAudioPortOpen(): unknown attributes (0x%llx)", attr);
 	}
 
 	// open audio port
@@ -521,14 +521,14 @@ s32 cellAudioPortOpen(vm::ptr<CellAudioPortParam> audioParam, vm::ptr<u32> portN
 	port.level_set.store({ port.level, 0.0f });
 
 	*portNum = port_index;
-	cellAudio.Warning("*** audio port opened(nChannel=%d, nBlock=%d, attr=0x%llx, level=%f): port = %d", channel, block, attr, port.level, port_index);
+	cellAudio.warning("*** audio port opened(nChannel=%d, nBlock=%d, attr=0x%llx, level=%f): port = %d", channel, block, attr, port.level, port_index);
 
 	return CELL_OK;
 }
 
 s32 cellAudioGetPortConfig(u32 portNum, vm::ptr<CellAudioPortConfig> portConfig)
 {
-	cellAudio.Warning("cellAudioGetPortConfig(portNum=%d, portConfig=*0x%x)", portNum, portConfig);
+	cellAudio.warning("cellAudioGetPortConfig(portNum=%d, portConfig=*0x%x)", portNum, portConfig);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -561,7 +561,7 @@ s32 cellAudioGetPortConfig(u32 portNum, vm::ptr<CellAudioPortConfig> portConfig)
 
 s32 cellAudioPortStart(u32 portNum)
 {
-	cellAudio.Warning("cellAudioPortStart(portNum=%d)", portNum);
+	cellAudio.warning("cellAudioPortStart(portNum=%d)", portNum);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -584,7 +584,7 @@ s32 cellAudioPortStart(u32 portNum)
 
 s32 cellAudioPortClose(u32 portNum)
 {
-	cellAudio.Warning("cellAudioPortClose(portNum=%d)", portNum);
+	cellAudio.warning("cellAudioPortClose(portNum=%d)", portNum);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -607,7 +607,7 @@ s32 cellAudioPortClose(u32 portNum)
 
 s32 cellAudioPortStop(u32 portNum)
 {
-	cellAudio.Warning("cellAudioPortStop(portNum=%d)", portNum);
+	cellAudio.warning("cellAudioPortStop(portNum=%d)", portNum);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -630,7 +630,7 @@ s32 cellAudioPortStop(u32 portNum)
 
 s32 cellAudioGetPortTimestamp(u32 portNum, u64 tag, vm::ptr<u64> stamp)
 {
-	cellAudio.Log("cellAudioGetPortTimestamp(portNum=%d, tag=0x%llx, stamp=*0x%x)", portNum, tag, stamp);
+	cellAudio.trace("cellAudioGetPortTimestamp(portNum=%d, tag=0x%llx, stamp=*0x%x)", portNum, tag, stamp);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -658,7 +658,7 @@ s32 cellAudioGetPortTimestamp(u32 portNum, u64 tag, vm::ptr<u64> stamp)
 
 s32 cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, vm::ptr<u64> tag)
 {
-	cellAudio.Log("cellAudioGetPortBlockTag(portNum=%d, blockNo=0x%llx, tag=*0x%x)", portNum, blockNo, tag);
+	cellAudio.trace("cellAudioGetPortBlockTag(portNum=%d, blockNo=0x%llx, tag=*0x%x)", portNum, blockNo, tag);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -699,7 +699,7 @@ s32 cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, vm::ptr<u64> tag)
 
 s32 cellAudioSetPortLevel(u32 portNum, float level)
 {
-	cellAudio.Log("cellAudioSetPortLevel(portNum=%d, level=%f)", portNum, level);
+	cellAudio.trace("cellAudioSetPortLevel(portNum=%d, level=%f)", portNum, level);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -724,7 +724,7 @@ s32 cellAudioSetPortLevel(u32 portNum, float level)
 	}
 	else
 	{
-		cellAudio.Todo("cellAudioSetPortLevel(%d): negative level value (%f)", portNum, level);
+		cellAudio.todo("cellAudioSetPortLevel(%d): negative level value (%f)", portNum, level);
 	}
 
 	return CELL_OK;
@@ -732,7 +732,7 @@ s32 cellAudioSetPortLevel(u32 portNum, float level)
 
 s32 cellAudioCreateNotifyEventQueue(vm::ptr<u32> id, vm::ptr<u64> key)
 {
-	cellAudio.Warning("cellAudioCreateNotifyEventQueue(id=*0x%x, key=*0x%x)", id, key);
+	cellAudio.warning("cellAudioCreateNotifyEventQueue(id=*0x%x, key=*0x%x)", id, key);
 
 	for (u64 k = 0; k < 100; k++)
 	{
@@ -753,7 +753,7 @@ s32 cellAudioCreateNotifyEventQueue(vm::ptr<u32> id, vm::ptr<u64> key)
 
 s32 cellAudioCreateNotifyEventQueueEx(vm::ptr<u32> id, vm::ptr<u64> key, u32 iFlags)
 {
-	cellAudio.Todo("cellAudioCreateNotifyEventQueueEx(id=*0x%x, key=*0x%x, iFlags=0x%x)", id, key, iFlags);
+	cellAudio.todo("cellAudioCreateNotifyEventQueueEx(id=*0x%x, key=*0x%x, iFlags=0x%x)", id, key, iFlags);
 
 	if (iFlags & ~CELL_AUDIO_CREATEEVENTFLAG_SPU)
 	{
@@ -767,7 +767,7 @@ s32 cellAudioCreateNotifyEventQueueEx(vm::ptr<u32> id, vm::ptr<u64> key, u32 iFl
 
 s32 cellAudioSetNotifyEventQueue(u64 key)
 {
-	cellAudio.Warning("cellAudioSetNotifyEventQueue(key=0x%llx)", key);
+	cellAudio.warning("cellAudioSetNotifyEventQueue(key=0x%llx)", key);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -791,7 +791,7 @@ s32 cellAudioSetNotifyEventQueue(u64 key)
 
 s32 cellAudioSetNotifyEventQueueEx(u64 key, u32 iFlags)
 {
-	cellAudio.Todo("cellAudioSetNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
+	cellAudio.todo("cellAudioSetNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
 
 	// TODO
 
@@ -800,7 +800,7 @@ s32 cellAudioSetNotifyEventQueueEx(u64 key, u32 iFlags)
 
 s32 cellAudioRemoveNotifyEventQueue(u64 key)
 {
-	cellAudio.Warning("cellAudioRemoveNotifyEventQueue(key=0x%llx)", key);
+	cellAudio.warning("cellAudioRemoveNotifyEventQueue(key=0x%llx)", key);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -824,7 +824,7 @@ s32 cellAudioRemoveNotifyEventQueue(u64 key)
 
 s32 cellAudioRemoveNotifyEventQueueEx(u64 key, u32 iFlags)
 {
-	cellAudio.Todo("cellAudioRemoveNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
+	cellAudio.todo("cellAudioRemoveNotifyEventQueueEx(key=0x%llx, iFlags=0x%x)", key, iFlags);
 
 	// TODO
 
@@ -833,7 +833,7 @@ s32 cellAudioRemoveNotifyEventQueueEx(u64 key, u32 iFlags)
 
 s32 cellAudioAddData(u32 portNum, vm::ptr<float> src, u32 samples, float volume)
 {
-	cellAudio.Log("cellAudioAddData(portNum=%d, src=*0x%x, samples=%d, volume=%f)", portNum, src, samples, volume);
+	cellAudio.trace("cellAudioAddData(portNum=%d, src=*0x%x, samples=%d, volume=%f)", portNum, src, samples, volume);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -848,7 +848,7 @@ s32 cellAudioAddData(u32 portNum, vm::ptr<float> src, u32 samples, float volume)
 	if (samples != 256)
 	{
 		// despite the docs, seems that only fixed value is supported
-		cellAudio.Error("cellAudioAddData(): invalid samples value (%d)", samples);
+		cellAudio.error("cellAudioAddData(): invalid samples value (%d)", samples);
 		return CELL_AUDIO_ERROR_PARAM;
 	}
 
@@ -866,7 +866,7 @@ s32 cellAudioAddData(u32 portNum, vm::ptr<float> src, u32 samples, float volume)
 
 s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volume)
 {
-	cellAudio.Log("cellAudioAdd2chData(portNum=%d, src=*0x%x, samples=%d, volume=%f)", portNum, src, samples, volume);
+	cellAudio.trace("cellAudioAdd2chData(portNum=%d, src=*0x%x, samples=%d, volume=%f)", portNum, src, samples, volume);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -881,7 +881,7 @@ s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volu
 	if (samples != 256)
 	{
 		// despite the docs, seems that only fixed value is supported
-		cellAudio.Error("cellAudioAdd2chData(): invalid samples value (%d)", samples);
+		cellAudio.error("cellAudioAdd2chData(): invalid samples value (%d)", samples);
 		return CELL_AUDIO_ERROR_PARAM;
 	}
 
@@ -891,7 +891,7 @@ s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volu
 
 	if (port.channel == 2)
 	{
-		cellAudio.Error("cellAudioAdd2chData(portNum=%d): port.channel = 2", portNum);
+		cellAudio.error("cellAudioAdd2chData(portNum=%d): port.channel = 2", portNum);
 	}
 	else if (port.channel == 6)
 	{
@@ -921,7 +921,7 @@ s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volu
 	}
 	else
 	{
-		cellAudio.Error("cellAudioAdd2chData(portNum=%d): invalid port.channel value (%d)", portNum, port.channel);
+		cellAudio.error("cellAudioAdd2chData(portNum=%d): invalid port.channel value (%d)", portNum, port.channel);
 	}
 
 	return CELL_OK;
@@ -929,7 +929,7 @@ s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volu
 
 s32 cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
 {
-	cellAudio.Log("cellAudioAdd6chData(portNum=%d, src=*0x%x, volume=%f)", portNum, src, volume);
+	cellAudio.trace("cellAudioAdd6chData(portNum=%d, src=*0x%x, volume=%f)", portNum, src, volume);
 
 	if (g_audio.state != AUDIO_STATE_INITIALIZED)
 	{
@@ -947,7 +947,7 @@ s32 cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
 
 	if (port.channel == 2 || port.channel == 6)
 	{
-		cellAudio.Error("cellAudioAdd2chData(portNum=%d): port.channel = %d", portNum, port.channel);
+		cellAudio.error("cellAudioAdd2chData(portNum=%d): port.channel = %d", portNum, port.channel);
 	}
 	else if (port.channel == 8)
 	{
@@ -965,7 +965,7 @@ s32 cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
 	}
 	else
 	{
-		cellAudio.Error("cellAudioAdd6chData(portNum=%d): invalid port.channel value (%d)", portNum, port.channel);
+		cellAudio.error("cellAudioAdd6chData(portNum=%d): invalid port.channel value (%d)", portNum, port.channel);
 	}
 
 	return CELL_OK;
@@ -973,25 +973,25 @@ s32 cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
 
 s32 cellAudioMiscSetAccessoryVolume(u32 devNum, float volume)
 {
-	cellAudio.Todo("cellAudioMiscSetAccessoryVolume(devNum=%d, volume=%f)", devNum, volume);
+	cellAudio.todo("cellAudioMiscSetAccessoryVolume(devNum=%d, volume=%f)", devNum, volume);
 	return CELL_OK;
 }
 
 s32 cellAudioSendAck(u64 data3)
 {
-	cellAudio.Todo("cellAudioSendAck(data3=0x%llx)", data3);
+	cellAudio.todo("cellAudioSendAck(data3=0x%llx)", data3);
 	return CELL_OK;
 }
 
 s32 cellAudioSetPersonalDevice(s32 iPersonalStream, s32 iDevice)
 {
-	cellAudio.Todo("cellAudioSetPersonalDevice(iPersonalStream=%d, iDevice=%d)", iPersonalStream, iDevice);
+	cellAudio.todo("cellAudioSetPersonalDevice(iPersonalStream=%d, iDevice=%d)", iPersonalStream, iDevice);
 	return CELL_OK;
 }
 
 s32 cellAudioUnsetPersonalDevice(s32 iPersonalStream)
 {
-	cellAudio.Todo("cellAudioUnsetPersonalDevice(iPersonalStream=%d)", iPersonalStream);
+	cellAudio.todo("cellAudioUnsetPersonalDevice(iPersonalStream=%d)", iPersonalStream);
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/cellAudioOut.cpp

@@ -8,7 +8,7 @@ extern Module<> cellSysutil;
 
 s32 cellAudioOutGetSoundAvailability(u32 audioOut, u32 type, u32 fs, u32 option)
 {
-	cellSysutil.Warning("cellAudioOutGetSoundAvailability(audioOut=%d, type=%d, fs=0x%x, option=%d)", audioOut, type, fs, option);
+	cellSysutil.warning("cellAudioOutGetSoundAvailability(audioOut=%d, type=%d, fs=0x%x, option=%d)", audioOut, type, fs, option);
 
 	option = 0;
 
@@ -48,7 +48,7 @@ s32 cellAudioOutGetSoundAvailability(u32 audioOut, u32 type, u32 fs, u32 option)
 
 s32 cellAudioOutGetSoundAvailability2(u32 audioOut, u32 type, u32 fs, u32 ch, u32 option)
 {
-	cellSysutil.Warning("cellAudioOutGetSoundAvailability2(audioOut=%d, type=%d, fs=0x%x, ch=%d, option=%d)", audioOut, type, fs, ch, option);
+	cellSysutil.warning("cellAudioOutGetSoundAvailability2(audioOut=%d, type=%d, fs=0x%x, ch=%d, option=%d)", audioOut, type, fs, ch, option);
 
 	option = 0;
 
@@ -97,7 +97,7 @@ s32 cellAudioOutGetSoundAvailability2(u32 audioOut, u32 type, u32 fs, u32 ch, u3
 
 s32 cellAudioOutGetState(u32 audioOut, u32 deviceIndex, vm::ptr<CellAudioOutState> state)
 {
-	cellSysutil.Warning("cellAudioOutGetState(audioOut=0x%x, deviceIndex=0x%x, state=*0x%x)", audioOut, deviceIndex, state);
+	cellSysutil.warning("cellAudioOutGetState(audioOut=0x%x, deviceIndex=0x%x, state=*0x%x)", audioOut, deviceIndex, state);
 
 	*state = {};
 
@@ -126,7 +126,7 @@ s32 cellAudioOutGetState(u32 audioOut, u32 deviceIndex, vm::ptr<CellAudioOutStat
 
 s32 cellAudioOutConfigure(u32 audioOut, vm::ptr<CellAudioOutConfiguration> config, vm::ptr<CellAudioOutOption> option, u32 waitForEvent)
 {
-	cellSysutil.Warning("cellAudioOutConfigure(audioOut=%d, config=*0x%x, option=*0x%x, waitForEvent=%d)", audioOut, config, option, waitForEvent);
+	cellSysutil.warning("cellAudioOutConfigure(audioOut=%d, config=*0x%x, option=*0x%x, waitForEvent=%d)", audioOut, config, option, waitForEvent);
 
 	switch (audioOut)
 	{
@@ -154,7 +154,7 @@ s32 cellAudioOutConfigure(u32 audioOut, vm::ptr<CellAudioOutConfiguration> confi
 
 s32 cellAudioOutGetConfiguration(u32 audioOut, vm::ptr<CellAudioOutConfiguration> config, vm::ptr<CellAudioOutOption> option)
 {
-	cellSysutil.Warning("cellAudioOutGetConfiguration(audioOut=%d, config=*0x%x, option=*0x%x)", audioOut, config, option);
+	cellSysutil.warning("cellAudioOutGetConfiguration(audioOut=%d, config=*0x%x, option=*0x%x)", audioOut, config, option);
 
 	if (option) *option = {};
 	*config = {};
@@ -178,7 +178,7 @@ s32 cellAudioOutGetConfiguration(u32 audioOut, vm::ptr<CellAudioOutConfiguration
 
 s32 cellAudioOutGetNumberOfDevice(u32 audioOut)
 {
-	cellSysutil.Warning("cellAudioOutGetNumberOfDevice(audioOut=%d)", audioOut);
+	cellSysutil.warning("cellAudioOutGetNumberOfDevice(audioOut=%d)", audioOut);
 
 	switch (audioOut)
 	{
@@ -191,7 +191,7 @@ s32 cellAudioOutGetNumberOfDevice(u32 audioOut)
 
 s32 cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, vm::ptr<CellAudioOutDeviceInfo> info)
 {
-	cellSysutil.Todo("cellAudioOutGetDeviceInfo(audioOut=%d, deviceIndex=%d, info=*0x%x)", audioOut, deviceIndex, info);
+	cellSysutil.todo("cellAudioOutGetDeviceInfo(audioOut=%d, deviceIndex=%d, info=*0x%x)", audioOut, deviceIndex, info);
 
 	if (deviceIndex) return CELL_AUDIO_OUT_ERROR_DEVICE_NOT_FOUND;
 
@@ -209,7 +209,7 @@ s32 cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, vm::ptr<CellAudioOu
 
 s32 cellAudioOutSetCopyControl(u32 audioOut, u32 control)
 {
-	cellSysutil.Warning("cellAudioOutSetCopyControl(audioOut=%d, control=%d)", audioOut, control);
+	cellSysutil.warning("cellAudioOutSetCopyControl(audioOut=%d, control=%d)", audioOut, control);
 
 	switch (audioOut)
 	{

rpcs3/Emu/SysCalls/Modules/cellAvconfExt.cpp

@@ -43,7 +43,7 @@ s32 cellVideoOutConvertCursorColor()
 
 s32 cellVideoOutGetGamma(u32 videoOut, vm::ptr<f32> gamma)
 {
-	cellAvconfExt.Warning("cellVideoOutGetGamma(videoOut=%d, gamma=*0x%x)", videoOut, gamma);
+	cellAvconfExt.warning("cellVideoOutGetGamma(videoOut=%d, gamma=*0x%x)", videoOut, gamma);
 
 	if (videoOut != CELL_VIDEO_OUT_PRIMARY)
 	{
@@ -67,7 +67,7 @@ s32 cellAudioOutGetAvailableDeviceInfo()
 
 s32 cellVideoOutSetGamma(u32 videoOut, f32 gamma)
 {
-	cellAvconfExt.Warning("cellVideoOutSetGamma(videoOut=%d, gamma=%f)", videoOut, gamma);
+	cellAvconfExt.warning("cellVideoOutSetGamma(videoOut=%d, gamma=%f)", videoOut, gamma);
 
 	if (videoOut != CELL_VIDEO_OUT_PRIMARY)
 	{
@@ -111,7 +111,7 @@ s32 cellAudioInUnregisterDevice()
 
 s32 cellVideoOutGetScreenSize(u32 videoOut, vm::ptr<float> screenSize)
 {
-	cellAvconfExt.Warning("cellVideoOutGetScreenSize(videoOut=%d, screenSize=*0x%x)", videoOut, screenSize);
+	cellAvconfExt.warning("cellVideoOutGetScreenSize(videoOut=%d, screenSize=*0x%x)", videoOut, screenSize);
 
 	if (videoOut != CELL_VIDEO_OUT_PRIMARY)
 	{

rpcs3/Emu/SysCalls/Modules/cellCamera.cpp

@@ -80,7 +80,7 @@ struct camera_t
 
 s32 cellCameraInit()
 {
-	cellCamera.Warning("cellCameraInit()");
+	cellCamera.warning("cellCameraInit()");
 
 	if (rpcs3::config.io.camera.value() == io_camera_state::null)
 	{
@@ -146,7 +146,7 @@ s32 cellCameraInit()
 
 s32 cellCameraEnd()
 {
-	cellCamera.Warning("cellCameraEnd()");
+	cellCamera.warning("cellCameraEnd()");
 
 	if (!fxm::remove<camera_t>())
 	{
@@ -182,7 +182,7 @@ s32 cellCameraGetDeviceGUID(s32 dev_num, vm::ptr<u32> guid)
 
 s32 cellCameraGetType(s32 dev_num, vm::ptr<s32> type)
 {
-	cellCamera.Warning("cellCameraGetType(dev_num=%d, type=*0x%x)", dev_num, type);
+	cellCamera.warning("cellCameraGetType(dev_num=%d, type=*0x%x)", dev_num, type);
 
 	const auto camera = fxm::get<camera_t>();
 
@@ -204,13 +204,13 @@ s32 cellCameraGetType(s32 dev_num, vm::ptr<s32> type)
 
 s32 cellCameraIsAvailable(s32 dev_num)
 {
-	cellCamera.Todo("cellCameraIsAvailable(dev_num=%d)", dev_num);
+	cellCamera.todo("cellCameraIsAvailable(dev_num=%d)", dev_num);
 	return CELL_OK;
 }
 
 s32 cellCameraIsAttached(s32 dev_num)
 {
-	cellCamera.Warning("cellCameraIsAttached(dev_num=%d)", dev_num);
+	cellCamera.warning("cellCameraIsAttached(dev_num=%d)", dev_num);
 
 	if (rpcs3::config.io.camera.value() == io_camera_state::connected)
 	{
@@ -222,19 +222,19 @@ s32 cellCameraIsAttached(s32 dev_num)
 
 s32 cellCameraIsOpen(s32 dev_num)
 {
-	cellCamera.Todo("cellCameraIsOpen(dev_num=%d)", dev_num);
+	cellCamera.todo("cellCameraIsOpen(dev_num=%d)", dev_num);
 	return CELL_OK;
 }
 
 s32 cellCameraIsStarted(s32 dev_num)
 {
-	cellCamera.Todo("cellCameraIsStarted(dev_num=%d)", dev_num);
+	cellCamera.todo("cellCameraIsStarted(dev_num=%d)", dev_num);
 	return CELL_OK;
 }
 
 s32 cellCameraGetAttribute(s32 dev_num, s32 attrib, vm::ptr<u32> arg1, vm::ptr<u32> arg2)
 {
-	cellCamera.Warning("cellCameraGetAttribute(dev_num=%d, attrib=%d, arg1=*0x%x, arg2=*0x%x)", dev_num, attrib, arg1, arg2);
+	cellCamera.warning("cellCameraGetAttribute(dev_num=%d, attrib=%d, arg1=*0x%x, arg2=*0x%x)", dev_num, attrib, arg1, arg2);
 
 	const auto attr_name = get_camera_attr_name(attrib);
 
@@ -258,7 +258,7 @@ s32 cellCameraGetAttribute(s32 dev_num, s32 attrib, vm::ptr<u32> arg1, vm::ptr<u
 
 s32 cellCameraSetAttribute(s32 dev_num, s32 attrib, u32 arg1, u32 arg2)
 {
-	cellCamera.Warning("cellCameraSetAttribute(dev_num=%d, attrib=%d, arg1=%d, arg2=%d)", dev_num, attrib, arg1, arg2);
+	cellCamera.warning("cellCameraSetAttribute(dev_num=%d, attrib=%d, arg1=%d, arg2=%d)", dev_num, attrib, arg1, arg2);
 
 	const auto attr_name = get_camera_attr_name(attrib);
 

rpcs3/Emu/SysCalls/Modules/cellDmux.cpp

@@ -59,7 +59,7 @@ PesHeader::PesHeader(DemuxerStream& stream)
 
 			if ((v & 0xf0) != 0x10)
 			{
-				cellDmux.Error("PesHeader(): dts not found (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
+				cellDmux.error("PesHeader(): dts not found (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
 				stream.skip(size - pos);
 				return;
 			}
@@ -68,7 +68,7 @@ PesHeader::PesHeader(DemuxerStream& stream)
 		}
 		else
 		{
-			cellDmux.Warning("PesHeader(): unknown code (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
+			cellDmux.warning("PesHeader(): unknown code (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
 			stream.skip(size - pos);
 			pos = size;
 			break;
@@ -207,13 +207,13 @@ bool ElementaryStream::release()
 	std::lock_guard<std::mutex> lock(m_mutex);
 	if (released >= put_count)
 	{
-		cellDmux.Error("es::release() error: buffer is empty");
+		cellDmux.error("es::release() error: buffer is empty");
 		Emu.Pause();
 		return false;
 	}
 	if (released >= got_count)
 	{
-		cellDmux.Error("es::release() error: buffer has not been seen yet");
+		cellDmux.error("es::release() error: buffer has not been seen yet");
 		Emu.Pause();
 		return false;
 	}
@@ -221,7 +221,7 @@ bool ElementaryStream::release()
 	u32 addr = 0;
 	if (!entries.pop(addr, &dmux->is_closed) || !addr)
 	{
-		cellDmux.Error("es::release() error: entries.Pop() failed");
+		cellDmux.error("es::release() error: entries.Pop() failed");
 		Emu.Pause();
 		return false;
 	}
@@ -235,7 +235,7 @@ bool ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool updat
 	std::lock_guard<std::mutex> lock(m_mutex);
 	if (got_count < released)
 	{
-		cellDmux.Error("es::peek() error: got_count(%d) < released(%d) (put_count=%d)", got_count, released, put_count);
+		cellDmux.error("es::peek() error: got_count(%d) < released(%d) (put_count=%d)", got_count, released, put_count);
 		Emu.Pause();
 		return false;
 	}
@@ -247,7 +247,7 @@ bool ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool updat
 	u32 addr = 0;
 	if (!entries.peek(addr, got_count - released, &dmux->is_closed) || !addr)
 	{
-		cellDmux.Error("es::peek() error: entries.Peek() failed");
+		cellDmux.error("es::peek() error: entries.Peek() failed");
 		Emu.Pause();
 		return false;
 	}
@@ -292,7 +292,7 @@ void dmuxQueryEsAttr(u32 info /* may be 0 */, vm::cptr<CellCodecEsFilterId> esFi
 		attr->memSize = 0x7000; // 0x73d9 from ps3
 	}
 
-	cellDmux.Warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2);
+	cellDmux.warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2);
 }
 
 void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
@@ -400,7 +400,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 					stream.skip(4);
 					stream.get(len);
 
-					cellDmux.Notice("PRIVATE_STREAM_2 (%d)", len);
+					cellDmux.notice("PRIVATE_STREAM_2 (%d)", len);
 
 					if (!stream.check(len))
 					{
@@ -491,7 +491,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 							
 							es.push_au(frame_size + 8, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
 
-							//cellDmux.Notice("ATX AU pushed (ats=0x%llx, frame_size=%d)", *(be_t<u64>*)data, frame_size);
+							//cellDmux.notice("ATX AU pushed (ats=0x%llx, frame_size=%d)", *(be_t<u64>*)data, frame_size);
 
 							auto esMsg = vm::ptr<CellDmuxEsMsg>::make(dmux.memAddr + (cb_add ^= 16));
 							esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
@@ -501,7 +501,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 					}
 					else
 					{
-						cellDmux.Notice("PRIVATE_STREAM_1 (len=%d, fid_minor=0x%x)", len, fid_minor);
+						cellDmux.notice("PRIVATE_STREAM_1 (len=%d, fid_minor=0x%x)", len, fid_minor);
 						stream.skip(len);
 					}
 					break;
@@ -578,7 +578,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 					}
 					else
 					{
-						cellDmux.Notice("Video stream (code=0x%x, len=%d)", code, len);
+						cellDmux.notice("Video stream (code=0x%x, len=%d)", code, len);
 						stream.skip(len);
 					}
 					break;
@@ -611,7 +611,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 			{
 				if (task.stream.discontinuity)
 				{
-					cellDmux.Warning("dmuxSetStream (beginning)");
+					cellDmux.warning("dmuxSetStream (beginning)");
 					for (u32 i = 0; i < sizeof(esALL) / sizeof(esALL[0]); i++)
 					{
 						if (esALL[i])
@@ -730,7 +730,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 				
 				if (es.raw_data.size())
 				{
-					cellDmux.Error("dmuxFlushEs: 0x%x bytes lost (es_id=%d)", (u32)es.raw_data.size(), es.id);
+					cellDmux.error("dmuxFlushEs: 0x%x bytes lost (es_id=%d)", (u32)es.raw_data.size(), es.id);
 				}
 
 				// callback
@@ -768,7 +768,7 @@ void dmuxOpen(u32 dmux_id) // TODO: call from the constructor
 
 s32 cellDmuxQueryAttr(vm::cptr<CellDmuxType> type, vm::ptr<CellDmuxAttr> attr)
 {
-	cellDmux.Warning("cellDmuxQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
+	cellDmux.warning("cellDmuxQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
 
 	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -781,7 +781,7 @@ s32 cellDmuxQueryAttr(vm::cptr<CellDmuxType> type, vm::ptr<CellDmuxAttr> attr)
 
 s32 cellDmuxQueryAttr2(vm::cptr<CellDmuxType2> type2, vm::ptr<CellDmuxAttr> attr)
 {
-	cellDmux.Warning("cellDmuxQueryAttr2(demuxerType2=*0x%x, demuxerAttr=*0x%x)", type2, attr);
+	cellDmux.warning("cellDmuxQueryAttr2(demuxerType2=*0x%x, demuxerAttr=*0x%x)", type2, attr);
 
 	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -794,7 +794,7 @@ s32 cellDmuxQueryAttr2(vm::cptr<CellDmuxType2> type2, vm::ptr<CellDmuxAttr> attr
 
 s32 cellDmuxOpen(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResource> res, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
-	cellDmux.Warning("cellDmuxOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellDmux.warning("cellDmuxOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -810,7 +810,7 @@ s32 cellDmuxOpen(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResource> res, vm
 
 s32 cellDmuxOpenEx(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
-	cellDmux.Warning("cellDmuxOpenEx(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
+	cellDmux.warning("cellDmuxOpenEx(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
 
 	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -826,14 +826,14 @@ s32 cellDmuxOpenEx(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> res
 
 s32 cellDmuxOpenExt(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
-	cellDmux.Warning("cellDmuxOpenExt(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
+	cellDmux.warning("cellDmuxOpenExt(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
 
 	return cellDmuxOpenEx(type, resEx, cb, handle);
 }
 
 s32 cellDmuxOpen2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellDmuxResource2> res2, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
 {
-	cellDmux.Warning("cellDmuxOpen2(type2=*0x%x, res2=*0x%x, cb=*0x%x, handle=*0x%x)", type2, res2, cb, handle);
+	cellDmux.warning("cellDmuxOpen2(type2=*0x%x, res2=*0x%x, cb=*0x%x, handle=*0x%x)", type2, res2, cb, handle);
 
 	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -849,7 +849,7 @@ s32 cellDmuxOpen2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellDmuxResource2> res
 
 s32 cellDmuxClose(u32 handle)
 {
-	cellDmux.Warning("cellDmuxClose(handle=0x%x)", handle);
+	cellDmux.warning("cellDmuxClose(handle=0x%x)", handle);
 
 	const auto dmux = idm::get<Demuxer>(handle);
 
@@ -865,7 +865,7 @@ s32 cellDmuxClose(u32 handle)
 	{
 		if (Emu.IsStopped())
 		{
-			cellDmux.Warning("cellDmuxClose(%d) aborted", handle);
+			cellDmux.warning("cellDmuxClose(%d) aborted", handle);
 			return CELL_OK;
 		}
 
@@ -879,7 +879,7 @@ s32 cellDmuxClose(u32 handle)
 
 s32 cellDmuxSetStream(u32 handle, u32 streamAddress, u32 streamSize, b8 discontinuity, u64 userData)
 {
-	cellDmux.Log("cellDmuxSetStream(handle=0x%x, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx)", handle, streamAddress, streamSize, discontinuity, userData);
+	cellDmux.trace("cellDmuxSetStream(handle=0x%x, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx)", handle, streamAddress, streamSize, discontinuity, userData);
 
 	const auto dmux = idm::get<Demuxer>(handle);
 
@@ -907,7 +907,7 @@ s32 cellDmuxSetStream(u32 handle, u32 streamAddress, u32 streamSize, b8 disconti
 
 s32 cellDmuxResetStream(u32 handle)
 {
-	cellDmux.Warning("cellDmuxResetStream(handle=0x%x)", handle);
+	cellDmux.warning("cellDmuxResetStream(handle=0x%x)", handle);
 
 	const auto dmux = idm::get<Demuxer>(handle);
 
@@ -922,7 +922,7 @@ s32 cellDmuxResetStream(u32 handle)
 
 s32 cellDmuxResetStreamAndWaitDone(u32 handle)
 {
-	cellDmux.Warning("cellDmuxResetStreamAndWaitDone(handle=0x%x)", handle);
+	cellDmux.warning("cellDmuxResetStreamAndWaitDone(handle=0x%x)", handle);
 
 	const auto dmux = idm::get<Demuxer>(handle);
 
@@ -944,7 +944,7 @@ s32 cellDmuxResetStreamAndWaitDone(u32 handle)
 	{
 		if (Emu.IsStopped())
 		{
-			cellDmux.Warning("cellDmuxResetStreamAndWaitDone(%d) aborted", handle);
+			cellDmux.warning("cellDmuxResetStreamAndWaitDone(%d) aborted", handle);
 			return CELL_OK;
 		}
 		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
@@ -955,7 +955,7 @@ s32 cellDmuxResetStreamAndWaitDone(u32 handle)
 
 s32 cellDmuxQueryEsAttr(vm::cptr<CellDmuxType> type, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
 {
-	cellDmux.Warning("cellDmuxQueryEsAttr(demuxerType=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type, esFilterId, esSpecificInfo, esAttr);
+	cellDmux.warning("cellDmuxQueryEsAttr(demuxerType=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type, esFilterId, esSpecificInfo, esAttr);
 
 	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -969,7 +969,7 @@ s32 cellDmuxQueryEsAttr(vm::cptr<CellDmuxType> type, vm::cptr<CellCodecEsFilterI
 
 s32 cellDmuxQueryEsAttr2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
 {
-	cellDmux.Warning("cellDmuxQueryEsAttr2(type2=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type2, esFilterId, esSpecificInfo, esAttr);
+	cellDmux.warning("cellDmuxQueryEsAttr2(type2=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type2, esFilterId, esSpecificInfo, esAttr);
 
 	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -983,7 +983,7 @@ s32 cellDmuxQueryEsAttr2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellCodecEsFilt
 
 s32 cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<CellDmuxEsResource> esResourceInfo, vm::cptr<CellDmuxEsCb> esCb, u32 esSpecificInfo, vm::ptr<u32> esHandle)
 {
-	cellDmux.Warning("cellDmuxEnableEs(handle=0x%x, esFilterId=*0x%x, esResourceInfo=*0x%x, esCb=*0x%x, esSpecificInfo=*0x%x, esHandle=*0x%x)", handle, esFilterId, esResourceInfo, esCb, esSpecificInfo, esHandle);
+	cellDmux.warning("cellDmuxEnableEs(handle=0x%x, esFilterId=*0x%x, esResourceInfo=*0x%x, esCb=*0x%x, esSpecificInfo=*0x%x, esHandle=*0x%x)", handle, esFilterId, esResourceInfo, esCb, esSpecificInfo, esHandle);
 
 	const auto dmux = idm::get<Demuxer>(handle);
 
@@ -1000,7 +1000,7 @@ s32 cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::c
 
 	*esHandle = es->id;
 
-	cellDmux.Warning("*** New ES(dmux=0x%x, addr=0x%x, size=0x%x, filter={0x%x, 0x%x, 0x%x, 0x%x}, cb=0x%x, arg=0x%x, spec=0x%x): id = 0x%x",
+	cellDmux.warning("*** New ES(dmux=0x%x, addr=0x%x, size=0x%x, filter={0x%x, 0x%x, 0x%x, 0x%x}, cb=0x%x, arg=0x%x, spec=0x%x): id = 0x%x",
 		handle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, es->cbFunc, es->cbArg, es->spec, es->id);
 
 	DemuxerTask task(dmuxEnableEs);
@@ -1013,7 +1013,7 @@ s32 cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::c
 
 s32 cellDmuxDisableEs(u32 esHandle)
 {
-	cellDmux.Warning("cellDmuxDisableEs(esHandle=0x%x)", esHandle);
+	cellDmux.warning("cellDmuxDisableEs(esHandle=0x%x)", esHandle);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1032,7 +1032,7 @@ s32 cellDmuxDisableEs(u32 esHandle)
 
 s32 cellDmuxResetEs(u32 esHandle)
 {
-	cellDmux.Log("cellDmuxResetEs(esHandle=0x%x)", esHandle);
+	cellDmux.trace("cellDmuxResetEs(esHandle=0x%x)", esHandle);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1051,7 +1051,7 @@ s32 cellDmuxResetEs(u32 esHandle)
 
 s32 cellDmuxGetAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInfo)
 {
-	cellDmux.Log("cellDmuxGetAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+	cellDmux.trace("cellDmuxGetAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1074,7 +1074,7 @@ s32 cellDmuxGetAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInfo
 
 s32 cellDmuxPeekAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInfo)
 {
-	cellDmux.Log("cellDmuxPeekAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+	cellDmux.trace("cellDmuxPeekAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1097,7 +1097,7 @@ s32 cellDmuxPeekAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInf
 
 s32 cellDmuxGetAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecificInfo)
 {
-	cellDmux.Log("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
+	cellDmux.trace("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1120,7 +1120,7 @@ s32 cellDmuxGetAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecific
 
 s32 cellDmuxPeekAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecificInfo)
 {
-	cellDmux.Log("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
+	cellDmux.trace("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1143,7 +1143,7 @@ s32 cellDmuxPeekAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecifi
 
 s32 cellDmuxReleaseAu(u32 esHandle)
 {
-	cellDmux.Log("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
+	cellDmux.trace("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 
@@ -1161,7 +1161,7 @@ s32 cellDmuxReleaseAu(u32 esHandle)
 
 s32 cellDmuxFlushEs(u32 esHandle)
 {
-	cellDmux.Warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
+	cellDmux.warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
 
 	const auto es = idm::get<ElementaryStream>(esHandle);
 

rpcs3/Emu/SysCalls/Modules/cellFiber.cpp

@@ -81,7 +81,7 @@ s32 cellFiberPpuJoinFiber()
 
 vm::ptr<void> cellFiberPpuSelf()
 {
-	cellFiber.Log("cellFiberPpuSelf() -> nullptr"); // TODO
+	cellFiber.trace("cellFiberPpuSelf() -> nullptr"); // TODO
 
 	// returns fiber structure (zero for simple PPU thread)
 	return vm::null;

rpcs3/Emu/SysCalls/Modules/cellFont.cpp

@@ -11,7 +11,7 @@ extern Module<> cellFont;
 // Functions
 s32 cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> config)
 {
-	cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=*0x%x)", revisionFlags, config);
+	cellFont.warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=*0x%x)", revisionFlags, config);
 	
 	if (config->fc_size < 24)
 	{
@@ -20,7 +20,7 @@ s32 cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> co
 
 	if (config->flags != 0)
 	{
-		cellFont.Error("cellFontInitializeWithRevision: Unknown flags (0x%x)", config->flags);
+		cellFont.error("cellFontInitializeWithRevision: Unknown flags (0x%x)", config->flags);
 	}
 
 	return CELL_OK;
@@ -34,20 +34,20 @@ s32 cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags)
 
 s32 cellFontEnd()
 {
-	cellFont.Warning("cellFontEnd()");
+	cellFont.warning("cellFontEnd()");
 
 	return CELL_OK;
 }
 
 s32 cellFontSetFontsetOpenMode(u32 openMode)
 {
-	cellFont.Todo("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
+	cellFont.todo("cellFontSetFontsetOpenMode(openMode=0x%x)", openMode);
 	return CELL_OK;
 }
 
 s32 cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontMemory(library=*0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontAddr, fontSize, subNum, uniqueId, font);
+	cellFont.warning("cellFontOpenFontMemory(library=*0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontAddr, fontSize, subNum, uniqueId, font);
 
 	font->stbfont = (stbtt_fontinfo*)((u8*)&(font->stbfont) + sizeof(void*)); // hack: use next bytes of the struct
 
@@ -63,7 +63,7 @@ s32 cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 f
 
 s32 cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontFile(library=*0x%x, fontPath=*0x%x, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontPath, subNum, uniqueId, font);
+	cellFont.warning("cellFontOpenFontFile(library=*0x%x, fontPath=*0x%x, subNum=%d, uniqueId=%d, font=*0x%x)", library, fontPath, subNum, uniqueId, font);
 
 	vfsFile f(fontPath.get_ptr());
 	if (!f.IsOpened())
@@ -82,11 +82,11 @@ s32 cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPa
 
 s32 cellFontOpenFontset(PPUThread& ppu, vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontset(library=*0x%x, fontType=*0x%x, font=*0x%x)", library, fontType, font);
+	cellFont.warning("cellFontOpenFontset(library=*0x%x, fontType=*0x%x, font=*0x%x)", library, fontType, font);
 
 	if (fontType->map != CELL_FONT_MAP_UNICODE)
 	{
-		cellFont.Warning("cellFontOpenFontset: Only Unicode is supported");
+		cellFont.warning("cellFontOpenFontset: Only Unicode is supported");
 	}
 	
 	std::string file;
@@ -146,12 +146,12 @@ s32 cellFontOpenFontset(PPUThread& ppu, vm::ptr<CellFontLibrary> library, vm::pt
 	case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET:
 	case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_VAGR2_SET:
 	case CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_VAGR2_SET:
-		cellFont.Warning("cellFontOpenFontset: fontType->type = %d not supported yet. RD-R-LATIN.TTF will be used instead.", fontType->type);
+		cellFont.warning("cellFontOpenFontset: fontType->type = %d not supported yet. RD-R-LATIN.TTF will be used instead.", fontType->type);
 		file = "/dev_flash/data/font/SCE-PS3-RD-R-LATIN.TTF";
 		break;
 
 	default:
-		cellFont.Warning("cellFontOpenFontset: fontType->type = %d not supported.", fontType->type);
+		cellFont.warning("cellFontOpenFontset: fontType->type = %d not supported.", fontType->type);
 		return CELL_FONT_ERROR_NO_SUPPORT_FONTSET;
 	}
 
@@ -163,7 +163,7 @@ s32 cellFontOpenFontset(PPUThread& ppu, vm::ptr<CellFontLibrary> library, vm::pt
 
 s32 cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontOpenFontInstance(openedFont=*0x%x, font=*0x%x)", openedFont, font);
+	cellFont.warning("cellFontOpenFontInstance(openedFont=*0x%x, font=*0x%x)", openedFont, font);
 
 	font->renderer_addr = openedFont->renderer_addr;
 	font->scale_x = openedFont->scale_x;
@@ -177,13 +177,13 @@ s32 cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> fon
 
 s32 cellFontSetFontOpenMode(u32 openMode)
 {
-	cellFont.Todo("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
+	cellFont.todo("cellFontSetFontOpenMode(openMode=0x%x)", openMode);
 	return CELL_OK;
 }
 
 s32 cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer)
 {
-	cellFont.Todo("cellFontCreateRenderer(library=*0x%x, config=*0x%x, Renderer=*0x%x)", library, config, Renderer);
+	cellFont.todo("cellFontCreateRenderer(library=*0x%x, config=*0x%x, Renderer=*0x%x)", library, config, Renderer);
 	
 	//Write data in Renderer
 
@@ -192,7 +192,7 @@ s32 cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRen
 
 void cellFontRenderSurfaceInit(vm::ptr<CellFontRenderSurface> surface, vm::ptr<void> buffer, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
 {
-	cellFont.Warning("cellFontRenderSurfaceInit(surface=*0x%x, buffer=*0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)", surface, buffer, bufferWidthByte, pixelSizeByte, w, h);
+	cellFont.warning("cellFontRenderSurfaceInit(surface=*0x%x, buffer=*0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)", surface, buffer, bufferWidthByte, pixelSizeByte, w, h);
 
 	surface->buffer         = buffer;
 	surface->widthByte      = bufferWidthByte;
@@ -203,7 +203,7 @@ void cellFontRenderSurfaceInit(vm::ptr<CellFontRenderSurface> surface, vm::ptr<v
 
 void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
 {
-	cellFont.Warning("cellFontRenderSurfaceSetScissor(surface=*0x%x, x0=%d, y0=%d, w=%d, h=%d)", surface, x0, y0, w, h);
+	cellFont.warning("cellFontRenderSurfaceSetScissor(surface=*0x%x, x0=%d, y0=%d, w=%d, h=%d)", surface, x0, y0, w, h);
 
 	surface->sc_x0 = x0;
 	surface->sc_y0 = y0;
@@ -213,7 +213,7 @@ void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32
 
 s32 cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont.Log("cellFontSetScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
+	cellFont.trace("cellFontSetScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
 
 	font->scale_x = w;
 	font->scale_y = h;
@@ -223,7 +223,7 @@ s32 cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
 
 s32 cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizontalLayout> layout)
 {
-	cellFont.Log("cellFontGetHorizontalLayout(font=*0x%x, layout=*0x%x)", font, layout);
+	cellFont.trace("cellFontGetHorizontalLayout(font=*0x%x, layout=*0x%x)", font, layout);
 
 	s32 ascent, descent, lineGap;
 	float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
@@ -238,7 +238,7 @@ s32 cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizont
 
 s32 cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> renderer)
 {
-	cellFont.Warning("cellFontBindRenderer(font=*0x%x, renderer=*0x%x)", font, renderer);
+	cellFont.warning("cellFontBindRenderer(font=*0x%x, renderer=*0x%x)", font, renderer);
 
 	if (font->renderer_addr)
 	{
@@ -252,7 +252,7 @@ s32 cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> rende
 
 s32 cellFontUnbindRenderer(vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontBindRenderer(font=*0x%x)", font);
+	cellFont.warning("cellFontBindRenderer(font=*0x%x)", font);
 	
 	if (!font->renderer_addr)
 	{
@@ -272,7 +272,7 @@ s32 cellFontDestroyRenderer()
 
 s32 cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont.Todo("cellFontSetupRenderScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
+	cellFont.todo("cellFontSetupRenderScalePixel(font=*0x%x, w=%f, h=%f)", font, w, h);
 
 	if (!font->renderer_addr)
 	{
@@ -285,7 +285,7 @@ s32 cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
 
 s32 cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
-	cellFont.Todo("cellFontGetRenderCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
+	cellFont.todo("cellFontGetRenderCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
 
 	if (!font->renderer_addr)
 	{
@@ -298,7 +298,7 @@ s32 cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<
 
 s32 cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontRenderSurface> surface, float x, float y, vm::ptr<CellFontGlyphMetrics> metrics, vm::ptr<CellFontImageTransInfo> transInfo)
 {
-	cellFont.Notice("cellFontRenderCharGlyphImage(font=*0x%x, code=0x%x, surface=*0x%x, x=%f, y=%f, metrics=*0x%x, trans=*0x%x)", font, code, surface, x, y, metrics, transInfo);
+	cellFont.notice("cellFontRenderCharGlyphImage(font=*0x%x, code=0x%x, surface=*0x%x, x=%f, y=%f, metrics=*0x%x, trans=*0x%x)", font, code, surface, x, y, metrics, transInfo);
 
 	if (!font->renderer_addr)
 	{
@@ -349,7 +349,7 @@ s32 cellFontEndLibrary()
 
 s32 cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
 {
-	cellFont.Log("cellFontSetEffectSlant(font=*0x%x, slantParam=%f)", font, slantParam);
+	cellFont.trace("cellFontSetEffectSlant(font=*0x%x, slantParam=%f)", font, slantParam);
 
 	if (slantParam < -1.0 || slantParam > 1.0)
 	{
@@ -363,7 +363,7 @@ s32 cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
 
 s32 cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
 {
-	cellFont.Warning("cellFontSetEffectSlant(font=*0x%x, slantParam=*0x%x)", font, slantParam);
+	cellFont.warning("cellFontSetEffectSlant(font=*0x%x, slantParam=*0x%x)", font, slantParam);
 
 	*slantParam = font->slant;
 
@@ -372,7 +372,7 @@ s32 cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
 
 s32 cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId, vm::ptr<u32> fontCode)
 {
-	cellFont.Todo("cellFontGetFontIdCode(font=*0x%x, code=%d, fontId=*0x%x, fontCode=*0x%x)", font, code, fontId, fontCode);
+	cellFont.todo("cellFontGetFontIdCode(font=*0x%x, code=%d, fontId=*0x%x, fontCode=*0x%x)", font, code, fontId, fontCode);
 
 	// TODO: ?
 	return CELL_OK;
@@ -380,7 +380,7 @@ s32 cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId,
 
 s32 cellFontCloseFont(vm::ptr<CellFont> font)
 {
-	cellFont.Warning("cellFontCloseFont(font=*0x%x)", font);
+	cellFont.warning("cellFontCloseFont(font=*0x%x)", font);
 
 	if (font->origin == CELL_FONT_OPEN_FONTSET ||
 		font->origin == CELL_FONT_OPEN_FONT_FILE ||
@@ -394,7 +394,7 @@ s32 cellFontCloseFont(vm::ptr<CellFont> font)
 
 s32 cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
-	cellFont.Warning("cellFontGetCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
+	cellFont.warning("cellFontGetCharGlyphMetrics(font=*0x%x, code=0x%x, metrics=*0x%x)", font, code, metrics);
 
 	s32 x0, y0, x1, y1;
 	s32 advanceWidth, leftSideBearing;
@@ -423,11 +423,11 @@ s32 cellFontGraphicsSetFontRGBA()
 
 s32 cellFontOpenFontsetOnMemory(PPUThread& ppu, vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font)
 {
-	cellFont.Todo("cellFontOpenFontsetOnMemory(library=*0x%x, fontType=*0x%x, font=*0x%x)", library, fontType, font);
+	cellFont.todo("cellFontOpenFontsetOnMemory(library=*0x%x, fontType=*0x%x, font=*0x%x)", library, fontType, font);
 
 	if (fontType->map != CELL_FONT_MAP_UNICODE)
 	{
-		cellFont.Warning("cellFontOpenFontsetOnMemory: Only Unicode is supported");
+		cellFont.warning("cellFontOpenFontsetOnMemory: Only Unicode is supported");
 	}
 
 	return CELL_OK;
@@ -537,7 +537,7 @@ s32 cellFontDeleteGlyph()
 
 s32 cellFontExtend(u32 a1, u32 a2, u32 a3)
 {
-	cellFont.Todo("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3);
+	cellFont.todo("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3);
 	//In a test I did: a1=0xcfe00000, a2=0x0, a3=(pointer to something)
 	if (a1 == 0xcfe00000)
 		{

rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp

@@ -8,7 +8,7 @@ extern Module<> cellFontFT;
 
 s32 cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, vm::pptr<CellFontLibrary> lib)
 {
-	cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config=*0x%x, lib=**0x%x)", revisionFlags, config, lib);
+	cellFontFT.warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config=*0x%x, lib=**0x%x)", revisionFlags, config, lib);
 
 	lib->set(vm::alloc(sizeof(CellFontLibrary), vm::main));
 

rpcs3/Emu/SysCalls/Modules/cellFs.cpp

@@ -16,7 +16,7 @@ extern Module<> cellFs;
 
 s32 cellFsOpen(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> arg, u64 size)
 {
-	cellFs.Warning("cellFsOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx) -> sys_fs_open()", path, flags, fd, arg, size);
+	cellFs.warning("cellFsOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx) -> sys_fs_open()", path, flags, fd, arg, size);
 
 	// TODO
 
@@ -26,7 +26,7 @@ s32 cellFsOpen(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> a
 
 s32 cellFsRead(u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<u64> nread)
 {
-	cellFs.Log("cellFsRead(fd=0x%x, buf=0x%x, nbytes=0x%llx, nread=0x%x)", fd, buf, nbytes, nread);
+	cellFs.trace("cellFsRead(fd=0x%x, buf=0x%x, nbytes=0x%llx, nread=0x%x)", fd, buf, nbytes, nread);
 
 	// call the syscall
 	return sys_fs_read(fd, buf, nbytes, nread ? nread : vm::var<u64>{});
@@ -34,7 +34,7 @@ s32 cellFsRead(u32 fd, vm::ptr<void> buf, u64 nbytes, vm::ptr<u64> nread)
 
 s32 cellFsWrite(u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite)
 {
-	cellFs.Log("cellFsWrite(fd=0x%x, buf=*0x%x, nbytes=0x%llx, nwrite=*0x%x)", fd, buf, nbytes, nwrite);
+	cellFs.trace("cellFsWrite(fd=0x%x, buf=*0x%x, nbytes=0x%llx, nwrite=*0x%x)", fd, buf, nbytes, nwrite);
 
 	// call the syscall
 	return sys_fs_write(fd, buf, nbytes, nwrite ? nwrite : vm::var<u64>{});
@@ -42,7 +42,7 @@ s32 cellFsWrite(u32 fd, vm::cptr<void> buf, u64 nbytes, vm::ptr<u64> nwrite)
 
 s32 cellFsClose(u32 fd)
 {
-	cellFs.Log("cellFsClose(fd=0x%x)", fd);
+	cellFs.trace("cellFsClose(fd=0x%x)", fd);
 
 	// call the syscall
 	return sys_fs_close(fd);
@@ -50,7 +50,7 @@ s32 cellFsClose(u32 fd)
 
 s32 cellFsOpendir(vm::cptr<char> path, vm::ptr<u32> fd)
 {
-	cellFs.Warning("cellFsOpendir(path=*0x%x, fd=*0x%x) -> sys_fs_opendir()", path, fd);
+	cellFs.warning("cellFsOpendir(path=*0x%x, fd=*0x%x) -> sys_fs_opendir()", path, fd);
 
 	// TODO
 
@@ -60,7 +60,7 @@ s32 cellFsOpendir(vm::cptr<char> path, vm::ptr<u32> fd)
 
 s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<u64> nread)
 {
-	cellFs.Log("cellFsReaddir(fd=0x%x, dir=*0x%x, nread=*0x%x)", fd, dir, nread);
+	cellFs.trace("cellFsReaddir(fd=0x%x, dir=*0x%x, nread=*0x%x)", fd, dir, nread);
 
 	// call the syscall
 	return dir && nread ? sys_fs_readdir(fd, dir, nread) : CELL_FS_EFAULT;
@@ -68,7 +68,7 @@ s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<u64> nread)
 
 s32 cellFsClosedir(u32 fd)
 {
-	cellFs.Log("cellFsClosedir(fd=0x%x)", fd);
+	cellFs.trace("cellFsClosedir(fd=0x%x)", fd);
 
 	// call the syscall
 	return sys_fs_closedir(fd);
@@ -76,7 +76,7 @@ s32 cellFsClosedir(u32 fd)
 
 s32 cellFsStat(vm::cptr<char> path, vm::ptr<CellFsStat> sb)
 {
-	cellFs.Warning("cellFsStat(path=*0x%x, sb=*0x%x) -> sys_fs_stat()", path, sb);
+	cellFs.warning("cellFsStat(path=*0x%x, sb=*0x%x) -> sys_fs_stat()", path, sb);
 
 	// TODO
 
@@ -86,7 +86,7 @@ s32 cellFsStat(vm::cptr<char> path, vm::ptr<CellFsStat> sb)
 
 s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
 {
-	cellFs.Log("cellFsFstat(fd=0x%x, sb=*0x%x)", fd, sb);
+	cellFs.trace("cellFsFstat(fd=0x%x, sb=*0x%x)", fd, sb);
 
 	// call the syscall
 	return sys_fs_fstat(fd, sb);
@@ -94,7 +94,7 @@ s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
 
 s32 cellFsMkdir(vm::cptr<char> path, s32 mode)
 {
-	cellFs.Warning("cellFsMkdir(path=*0x%x, mode=%#o) -> sys_fs_mkdir()", path, mode);
+	cellFs.warning("cellFsMkdir(path=*0x%x, mode=%#o) -> sys_fs_mkdir()", path, mode);
 
 	// TODO
 
@@ -104,7 +104,7 @@ s32 cellFsMkdir(vm::cptr<char> path, s32 mode)
 
 s32 cellFsRename(vm::cptr<char> from, vm::cptr<char> to)
 {
-	cellFs.Warning("cellFsRename(from=*0x%x, to=*0x%x) -> sys_fs_rename()", from, to);
+	cellFs.warning("cellFsRename(from=*0x%x, to=*0x%x) -> sys_fs_rename()", from, to);
 
 	// TODO
 
@@ -114,7 +114,7 @@ s32 cellFsRename(vm::cptr<char> from, vm::cptr<char> to)
 
 s32 cellFsRmdir(vm::cptr<char> path)
 {
-	cellFs.Warning("cellFsRmdir(path=*0x%x) -> sys_fs_rmdir()", path);
+	cellFs.warning("cellFsRmdir(path=*0x%x) -> sys_fs_rmdir()", path);
 
 	// TODO
 
@@ -124,7 +124,7 @@ s32 cellFsRmdir(vm::cptr<char> path)
 
 s32 cellFsUnlink(vm::cptr<char> path)
 {
-	cellFs.Warning("cellFsUnlink(path=*0x%x) -> sys_fs_unlink()", path);
+	cellFs.warning("cellFsUnlink(path=*0x%x) -> sys_fs_unlink()", path);
 
 	// TODO
 
@@ -134,7 +134,7 @@ s32 cellFsUnlink(vm::cptr<char> path)
 
 s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<u64> pos)
 {
-	cellFs.Log("cellFsLseek(fd=0x%x, offset=0x%llx, whence=0x%x, pos=*0x%x)", fd, offset, whence, pos);
+	cellFs.trace("cellFsLseek(fd=0x%x, offset=0x%llx, whence=0x%x, pos=*0x%x)", fd, offset, whence, pos);
 
 	// call the syscall
 	return pos ? sys_fs_lseek(fd, offset, whence, pos) : CELL_FS_EFAULT;
@@ -142,14 +142,14 @@ s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<u64> pos)
 
 s32 cellFsFsync(u32 fd)
 {
-	cellFs.Todo("cellFsFsync(fd=0x%x)", fd);
+	cellFs.todo("cellFsFsync(fd=0x%x)", fd);
 
 	return CELL_OK;
 }
 
 s32 cellFsFGetBlockSize(u32 fd, vm::ptr<u64> sector_size, vm::ptr<u64> block_size)
 {
-	cellFs.Log("cellFsFGetBlockSize(fd=0x%x, sector_size=*0x%x, block_size=*0x%x)", fd, sector_size, block_size);
+	cellFs.trace("cellFsFGetBlockSize(fd=0x%x, sector_size=*0x%x, block_size=*0x%x)", fd, sector_size, block_size);
 
 	// call the syscall
 	return sector_size && block_size ? sys_fs_fget_block_size(fd, sector_size, block_size, vm::var<u64>{}, vm::var<u64>{}) : CELL_FS_EFAULT;
@@ -157,7 +157,7 @@ s32 cellFsFGetBlockSize(u32 fd, vm::ptr<u64> sector_size, vm::ptr<u64> block_siz
 
 s32 cellFsGetBlockSize(vm::cptr<char> path, vm::ptr<u64> sector_size, vm::ptr<u64> block_size)
 {
-	cellFs.Warning("cellFsGetBlockSize(path=*0x%x, sector_size=*0x%x, block_size=*0x%x) -> sys_fs_get_block_size()", path, sector_size, block_size);
+	cellFs.warning("cellFsGetBlockSize(path=*0x%x, sector_size=*0x%x, block_size=*0x%x) -> sys_fs_get_block_size()", path, sector_size, block_size);
 
 	// TODO
 
@@ -167,7 +167,7 @@ s32 cellFsGetBlockSize(vm::cptr<char> path, vm::ptr<u64> sector_size, vm::ptr<u6
 
 s32 cellFsTruncate(vm::cptr<char> path, u64 size)
 {
-	cellFs.Warning("cellFsTruncate(path=*0x%x, size=0x%llx) -> sys_fs_truncate()", path, size);
+	cellFs.warning("cellFsTruncate(path=*0x%x, size=0x%llx) -> sys_fs_truncate()", path, size);
 
 	// TODO
 
@@ -177,7 +177,7 @@ s32 cellFsTruncate(vm::cptr<char> path, u64 size)
 
 s32 cellFsFtruncate(u32 fd, u64 size)
 {
-	cellFs.Log("cellFsFtruncate(fd=0x%x, size=0x%llx)", fd, size);
+	cellFs.trace("cellFsFtruncate(fd=0x%x, size=0x%llx)", fd, size);
 
 	// call the syscall
 	return sys_fs_ftruncate(fd, size);
@@ -185,7 +185,7 @@ s32 cellFsFtruncate(u32 fd, u64 size)
 
 s32 cellFsChmod(vm::cptr<char> path, s32 mode)
 {
-	cellFs.Warning("cellFsChmod(path=*0x%x, mode=%#o) -> sys_fs_chmod()", path, mode);
+	cellFs.warning("cellFsChmod(path=*0x%x, mode=%#o) -> sys_fs_chmod()", path, mode);
 
 	// TODO
 
@@ -195,8 +195,8 @@ s32 cellFsChmod(vm::cptr<char> path, s32 mode)
 
 s32 cellFsGetFreeSize(vm::cptr<char> path, vm::ptr<u32> block_size, vm::ptr<u64> block_count)
 {
-	cellFs.Warning("cellFsGetFreeSize(path=*0x%x, block_size=*0x%x, block_count=*0x%x)", path, block_size, block_count);
+	cellFs.warning("cellFsGetFreeSize(path=*0x%x, block_size=*0x%x, block_count=*0x%x)", path, block_size, block_count);
-	cellFs.Warning("*** path = '%s'", path.get_ptr());
+	cellFs.warning("*** path = '%s'", path.get_ptr());
 
 	// TODO: Get real values. Currently, it always returns 40 GB of free space divided in 4 KB blocks
 	*block_size = 4096; // ?
@@ -207,7 +207,7 @@ s32 cellFsGetFreeSize(vm::cptr<char> path, vm::ptr<u32> block_size, vm::ptr<u64>
 
 s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<u32> data_count)
 {
-	cellFs.Warning("cellFsGetDirectoryEntries(fd=%d, entries=*0x%x, entries_size=0x%x, data_count=*0x%x)", fd, entries, entries_size, data_count);
+	cellFs.warning("cellFsGetDirectoryEntries(fd=%d, entries=*0x%x, entries_size=0x%x, data_count=*0x%x)", fd, entries, entries_size, data_count);
 
 	const auto directory = idm::get<lv2_dir_t>(fd);
 
@@ -250,7 +250,7 @@ s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32
 
 s32 cellFsReadWithOffset(u32 fd, u64 offset, vm::ptr<void> buf, u64 buffer_size, vm::ptr<u64> nread)
 {
-	cellFs.Log("cellFsReadWithOffset(fd=%d, offset=0x%llx, buf=*0x%x, buffer_size=0x%llx, nread=*0x%x)", fd, offset, buf, buffer_size, nread);
+	cellFs.trace("cellFsReadWithOffset(fd=%d, offset=0x%llx, buf=*0x%x, buffer_size=0x%llx, nread=*0x%x)", fd, offset, buf, buffer_size, nread);
 
 	// TODO: use single sys_fs_fcntl syscall
 
@@ -281,7 +281,7 @@ s32 cellFsReadWithOffset(u32 fd, u64 offset, vm::ptr<void> buf, u64 buffer_size,
 
 s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::cptr<void> buf, u64 data_size, vm::ptr<u64> nwrite)
 {
-	cellFs.Log("cellFsWriteWithOffset(fd=%d, offset=0x%llx, buf=*0x%x, data_size=0x%llx, nwrite=*0x%x)", fd, offset, buf, data_size, nwrite);
+	cellFs.trace("cellFsWriteWithOffset(fd=%d, offset=0x%llx, buf=*0x%x, data_size=0x%llx, nwrite=*0x%x)", fd, offset, buf, data_size, nwrite);
 
 	// TODO: use single sys_fs_fcntl syscall
 
@@ -312,7 +312,7 @@ s32 cellFsWriteWithOffset(u32 fd, u64 offset, vm::cptr<void> buf, u64 data_size,
 
 s32 cellFsStReadInit(u32 fd, vm::cptr<CellFsRingBuffer> ringbuf)
 {
-	cellFs.Warning("cellFsStReadInit(fd=%d, ringbuf=*0x%x)", fd, ringbuf);
+	cellFs.warning("cellFsStReadInit(fd=%d, ringbuf=*0x%x)", fd, ringbuf);
 
 	if (ringbuf->copy & ~CELL_FS_ST_COPYLESS)
 	{
@@ -365,7 +365,7 @@ s32 cellFsStReadInit(u32 fd, vm::cptr<CellFsRingBuffer> ringbuf)
 
 s32 cellFsStReadFinish(u32 fd)
 {
-	cellFs.Warning("cellFsStReadFinish(fd=%d)", fd);
+	cellFs.warning("cellFsStReadFinish(fd=%d)", fd);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -388,7 +388,7 @@ s32 cellFsStReadFinish(u32 fd)
 
 s32 cellFsStReadGetRingBuf(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
 {
-	cellFs.Warning("cellFsStReadGetRingBuf(fd=%d, ringbuf=*0x%x)", fd, ringbuf);
+	cellFs.warning("cellFsStReadGetRingBuf(fd=%d, ringbuf=*0x%x)", fd, ringbuf);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -412,7 +412,7 @@ s32 cellFsStReadGetRingBuf(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
 
 s32 cellFsStReadGetStatus(u32 fd, vm::ptr<u64> status)
 {
-	cellFs.Warning("cellFsStReadGetRingBuf(fd=%d, status=*0x%x)", fd, status);
+	cellFs.warning("cellFsStReadGetRingBuf(fd=%d, status=*0x%x)", fd, status);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -446,7 +446,7 @@ s32 cellFsStReadGetStatus(u32 fd, vm::ptr<u64> status)
 
 s32 cellFsStReadGetRegid(u32 fd, vm::ptr<u64> regid)
 {
-	cellFs.Warning("cellFsStReadGetRingBuf(fd=%d, regid=*0x%x)", fd, regid);
+	cellFs.warning("cellFsStReadGetRingBuf(fd=%d, regid=*0x%x)", fd, regid);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -467,7 +467,7 @@ s32 cellFsStReadGetRegid(u32 fd, vm::ptr<u64> regid)
 
 s32 cellFsStReadStart(u32 fd, u64 offset, u64 size)
 {
-	cellFs.Warning("cellFsStReadStart(fd=%d, offset=0x%llx, size=0x%llx)", fd, offset, size);
+	cellFs.warning("cellFsStReadStart(fd=%d, offset=0x%llx, size=0x%llx)", fd, offset, size);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -548,7 +548,7 @@ s32 cellFsStReadStart(u32 fd, u64 offset, u64 size)
 
 s32 cellFsStReadStop(u32 fd)
 {
-	cellFs.Warning("cellFsStReadStop(fd=%d)", fd);
+	cellFs.warning("cellFsStReadStop(fd=%d)", fd);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -579,7 +579,7 @@ s32 cellFsStReadStop(u32 fd)
 
 s32 cellFsStRead(u32 fd, vm::ptr<u8> buf, u64 size, vm::ptr<u64> rsize)
 {
-	cellFs.Warning("cellFsStRead(fd=%d, buf=*0x%x, size=0x%llx, rsize=*0x%x)", fd, buf, size, rsize);
+	cellFs.warning("cellFsStRead(fd=%d, buf=*0x%x, size=0x%llx, rsize=*0x%x)", fd, buf, size, rsize);
 	
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -613,7 +613,7 @@ s32 cellFsStRead(u32 fd, vm::ptr<u8> buf, u64 size, vm::ptr<u64> rsize)
 
 s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<u32> addr, vm::ptr<u64> size)
 {
-	cellFs.Warning("cellFsStReadGetCurrentAddr(fd=%d, addr=*0x%x, size=*0x%x)", fd, addr, size);
+	cellFs.warning("cellFsStReadGetCurrentAddr(fd=%d, addr=*0x%x, size=*0x%x)", fd, addr, size);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -646,7 +646,7 @@ s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<u32> addr, vm::ptr<u64> size)
 
 s32 cellFsStReadPutCurrentAddr(u32 fd, vm::ptr<u8> addr, u64 size)
 {
-	cellFs.Warning("cellFsStReadPutCurrentAddr(fd=%d, addr=*0x%x, size=0x%llx)", fd, addr, size);
+	cellFs.warning("cellFsStReadPutCurrentAddr(fd=%d, addr=*0x%x, size=0x%llx)", fd, addr, size);
 	
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -673,7 +673,7 @@ s32 cellFsStReadPutCurrentAddr(u32 fd, vm::ptr<u8> addr, u64 size)
 
 s32 cellFsStReadWait(u32 fd, u64 size)
 {
-	cellFs.Warning("cellFsStReadWait(fd=%d, size=0x%llx)", fd, size);
+	cellFs.warning("cellFsStReadWait(fd=%d, size=0x%llx)", fd, size);
 	
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -702,7 +702,7 @@ s32 cellFsStReadWait(u32 fd, u64 size)
 
 s32 cellFsStReadWaitCallback(u32 fd, u64 size, fs_st_cb_t func)
 {
-	cellFs.Warning("cellFsStReadWaitCallback(fd=%d, size=0x%llx, func=*0x%x)", fd, size, func);
+	cellFs.warning("cellFsStReadWaitCallback(fd=%d, size=0x%llx, func=*0x%x)", fd, size, func);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 
@@ -757,13 +757,13 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 
 	if (!packed_stream || !packed_stream->IsOpened())
 	{
-		cellFs.Error("File '%s' not found!", packed_file.c_str());
+		cellFs.error("File '%s' not found!", packed_file.c_str());
 		return CELL_ENOENT;
 	}
 
 	if (!unpacked_stream || !unpacked_stream->IsOpened())
 	{
-		cellFs.Error("File '%s' couldn't be created!", unpacked_file.c_str());
+		cellFs.error("File '%s' couldn't be created!", unpacked_file.c_str());
 		return CELL_ENOENT;
 	}
 
@@ -772,7 +772,7 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 	u32 format = *(be_t<u32>*)&buffer[0];
 	if (format != 0x4E504400) // "NPD\x00"
 	{
-		cellFs.Error("Illegal format. Expected 0x4E504400, but got 0x%08x", format);
+		cellFs.error("Illegal format. Expected 0x4E504400, but got 0x%08x", format);
 		return CELL_EFSSPECIFIC;
 	}
 
@@ -786,7 +786,7 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 	// SDATA file is compressed
 	if (flags & 0x1)
 	{
-		cellFs.Warning("cellFsSdataOpen: Compressed SDATA files are not supported yet.");
+		cellFs.warning("cellFsSdataOpen: Compressed SDATA files are not supported yet.");
 		return CELL_EFSSPECIFIC;
 	}
 	// SDATA file is NOT compressed
@@ -798,7 +798,7 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 
 		if (!sdata_check(version, flags, filesizeInput, filesizeTmp))
 		{
-			cellFs.Error("cellFsSdataOpen: Wrong header information.");
+			cellFs.error("cellFsSdataOpen: Wrong header information.");
 			return CELL_EFSSPECIFIC;
 		}
 
@@ -835,7 +835,7 @@ s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 
 s32 cellFsSdataOpen(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<void> arg, u64 size)
 {
-	cellFs.Notice("cellFsSdataOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx)", path, flags, fd, arg, size);
+	cellFs.notice("cellFsSdataOpen(path=*0x%x, flags=%#o, fd=*0x%x, arg=*0x%x, size=0x%llx)", path, flags, fd, arg, size);
 
 	if (flags != CELL_FS_O_RDONLY)
 	{
@@ -865,7 +865,7 @@ s32 cellFsSdataOpen(vm::cptr<char> path, s32 flags, vm::ptr<u32> fd, vm::cptr<vo
 
 s32 cellFsSdataOpenByFd(u32 mself_fd, s32 flags, vm::ptr<u32> sdata_fd, u64 offset, vm::cptr<void> arg, u64 size)
 {
-	cellFs.Todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=%#o, sdata_fd=*0x%x, offset=0x%llx, arg=*0x%x, size=0x%llx)", mself_fd, flags, sdata_fd, offset, arg, size);
+	cellFs.todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=%#o, sdata_fd=*0x%x, offset=0x%llx, arg=*0x%x, size=0x%llx)", mself_fd, flags, sdata_fd, offset, arg, size);
 
 	// TODO:
 
@@ -876,7 +876,7 @@ using fs_aio_cb_t = vm::ptr<void(vm::ptr<CellFsAio> xaio, s32 error, s32 xid, u6
 
 void fsAio(vm::ptr<CellFsAio> aio, bool write, s32 xid, fs_aio_cb_t func)
 {
-	cellFs.Notice("FS AIO Request(%d): fd=%d, offset=0x%llx, buf=*0x%x, size=0x%llx, user_data=0x%llx", xid, aio->fd, aio->offset, aio->buf, aio->size, aio->user_data);
+	cellFs.notice("FS AIO Request(%d): fd=%d, offset=0x%llx, buf=*0x%x, size=0x%llx, user_data=0x%llx", xid, aio->fd, aio->offset, aio->buf, aio->size, aio->user_data);
 
 	s32 error = CELL_OK;
 	u64 result = 0;
@@ -909,8 +909,8 @@ void fsAio(vm::ptr<CellFsAio> aio, bool write, s32 xid, fs_aio_cb_t func)
 
 s32 cellFsAioInit(vm::cptr<char> mount_point)
 {
-	cellFs.Warning("cellFsAioInit(mount_point=*0x%x)", mount_point);
+	cellFs.warning("cellFsAioInit(mount_point=*0x%x)", mount_point);
-	cellFs.Warning("*** mount_point = '%s'", mount_point.get_ptr());
+	cellFs.warning("*** mount_point = '%s'", mount_point.get_ptr());
 
 	// TODO: create AIO thread (if not exists) for specified mount point
 
@@ -919,8 +919,8 @@ s32 cellFsAioInit(vm::cptr<char> mount_point)
 
 s32 cellFsAioFinish(vm::cptr<char> mount_point)
 {
-	cellFs.Warning("cellFsAioFinish(mount_point=*0x%x)", mount_point);
+	cellFs.warning("cellFsAioFinish(mount_point=*0x%x)", mount_point);
-	cellFs.Warning("*** mount_point = '%s'", mount_point.get_ptr());
+	cellFs.warning("*** mount_point = '%s'", mount_point.get_ptr());
 
 	// TODO: delete existing AIO thread for specified mount point
 
@@ -931,7 +931,7 @@ std::atomic<s32> g_fs_aio_id;
 
 s32 cellFsAioRead(vm::ptr<CellFsAio> aio, vm::ptr<s32> id, fs_aio_cb_t func)
 {
-	cellFs.Warning("cellFsAioRead(aio=*0x%x, id=*0x%x, func=*0x%x)", aio, id, func);
+	cellFs.warning("cellFsAioRead(aio=*0x%x, id=*0x%x, func=*0x%x)", aio, id, func);
 
 	// TODO: detect mount point and send AIO request to the AIO thread of this mount point
 
@@ -944,7 +944,7 @@ s32 cellFsAioRead(vm::ptr<CellFsAio> aio, vm::ptr<s32> id, fs_aio_cb_t func)
 
 s32 cellFsAioWrite(vm::ptr<CellFsAio> aio, vm::ptr<s32> id, fs_aio_cb_t func)
 {
-	cellFs.Warning("cellFsAioWrite(aio=*0x%x, id=*0x%x, func=*0x%x)", aio, id, func);
+	cellFs.warning("cellFsAioWrite(aio=*0x%x, id=*0x%x, func=*0x%x)", aio, id, func);
 
 	// TODO: detect mount point and send AIO request to the AIO thread of this mount point
 
@@ -957,7 +957,7 @@ s32 cellFsAioWrite(vm::ptr<CellFsAio> aio, vm::ptr<s32> id, fs_aio_cb_t func)
 
 s32 cellFsAioCancel(s32 id)
 {
-	cellFs.Warning("cellFsAioCancel(id=%d) -> CELL_FS_EINVAL", id);
+	cellFs.warning("cellFsAioCancel(id=%d) -> CELL_FS_EINVAL", id);
 
 	// TODO: cancelled requests return CELL_FS_ECANCELED through their own callbacks
 
@@ -966,14 +966,14 @@ s32 cellFsAioCancel(s32 id)
 
 s32 cellFsSetDefaultContainer(u32 id, u32 total_limit)
 {
-	cellFs.Todo("cellFsSetDefaultContainer(id=0x%x, total_limit=%d)", id, total_limit);
+	cellFs.todo("cellFsSetDefaultContainer(id=0x%x, total_limit=%d)", id, total_limit);
 
 	return CELL_OK;
 }
 
 s32 cellFsSetIoBufferFromDefaultContainer(u32 fd, u32 buffer_size, u32 page_type)
 {
-	cellFs.Todo("cellFsSetIoBufferFromDefaultContainer(fd=%d, buffer_size=%d, page_type=%d)", fd, buffer_size, page_type);
+	cellFs.todo("cellFsSetIoBufferFromDefaultContainer(fd=%d, buffer_size=%d, page_type=%d)", fd, buffer_size, page_type);
 
 	const auto file = idm::get<lv2_file_t>(fd);
 

rpcs3/Emu/SysCalls/Modules/cellGame.cpp

@@ -47,7 +47,7 @@ struct content_permission_t final
 
 s32 cellHddGameCheck(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
 {
-	cellGame.Warning("cellHddGameCheck(version=%d, dirName=*0x%x, errDialog=%d, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
+	cellGame.warning("cellHddGameCheck(version=%d, dirName=*0x%x, errDialog=%d, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
 	std::string dir = dirName.get_ptr();
 
@@ -155,7 +155,7 @@ s32 cellGameDataExitBroken()
 
 s32 cellGameBootCheck(vm::ptr<u32> type, vm::ptr<u32> attributes, vm::ptr<CellGameContentSize> size, vm::ptr<char[CELL_GAME_DIRNAME_SIZE]> dirName)
 {
-	cellGame.Warning("cellGameBootCheck(type=*0x%x, attributes=*0x%x, size=*0x%x, dirName=*0x%x)", type, attributes, size, dirName);
+	cellGame.warning("cellGameBootCheck(type=*0x%x, attributes=*0x%x, size=*0x%x, dirName=*0x%x)", type, attributes, size, dirName);
 
 	if (size)
 	{
@@ -173,7 +173,7 @@ s32 cellGameBootCheck(vm::ptr<u32> type, vm::ptr<u32> attributes, vm::ptr<CellGa
 	if (!psf)
 	{
 		// According to testing (in debug mode) cellGameBootCheck doesn't return an error code, when PARAM.SFO doesn't exist.
-		cellGame.Error("cellGameBootCheck(): Cannot read PARAM.SFO.");
+		cellGame.error("cellGameBootCheck(): Cannot read PARAM.SFO.");
 	}
 
 	std::string category = psf.GetString("CATEGORY");
@@ -214,7 +214,7 @@ s32 cellGameBootCheck(vm::ptr<u32> type, vm::ptr<u32> attributes, vm::ptr<CellGa
 	}
 	else if (psf)
 	{
-		cellGame.Error("cellGameBootCheck(): Unknown CATEGORY.");
+		cellGame.error("cellGameBootCheck(): Unknown CATEGORY.");
 	}
 
 	return CELL_GAME_RET_OK;
@@ -222,7 +222,7 @@ s32 cellGameBootCheck(vm::ptr<u32> type, vm::ptr<u32> attributes, vm::ptr<CellGa
 
 s32 cellGamePatchCheck(vm::ptr<CellGameContentSize> size, vm::ptr<void> reserved)
 {
-	cellGame.Warning("cellGamePatchCheck(size=*0x%x, reserved=*0x%x)", size, reserved);
+	cellGame.warning("cellGamePatchCheck(size=*0x%x, reserved=*0x%x)", size, reserved);
 
 	if (size)
 	{
@@ -238,14 +238,14 @@ s32 cellGamePatchCheck(vm::ptr<CellGameContentSize> size, vm::ptr<void> reserved
 	const PSFLoader psf(f);
 	if (!psf)
 	{
-		cellGame.Error("cellGamePatchCheck(): CELL_GAME_ERROR_ACCESS_ERROR (cannot read PARAM.SFO)");
+		cellGame.error("cellGamePatchCheck(): CELL_GAME_ERROR_ACCESS_ERROR (cannot read PARAM.SFO)");
 		return CELL_GAME_ERROR_ACCESS_ERROR;
 	}
 
 	std::string category = psf.GetString("CATEGORY");
 	if (category.substr(0, 2) != "GD")
 	{
-		cellGame.Error("cellGamePatchCheck(): CELL_GAME_ERROR_NOTPATCH");
+		cellGame.error("cellGamePatchCheck(): CELL_GAME_ERROR_NOTPATCH");
 		return CELL_GAME_ERROR_NOTPATCH;
 	}
 
@@ -259,11 +259,11 @@ s32 cellGamePatchCheck(vm::ptr<CellGameContentSize> size, vm::ptr<void> reserved
 
 s32 cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameContentSize> size)
 {
-	cellGame.Warning("cellGameDataCheck(type=%d, dirName=*0x%x, size=*0x%x)", type, dirName, size);
+	cellGame.warning("cellGameDataCheck(type=%d, dirName=*0x%x, size=*0x%x)", type, dirName, size);
 
 	if ((type - 1) >= 3)
 	{
-		cellGame.Error("cellGameDataCheck(): CELL_GAME_ERROR_PARAM");
+		cellGame.error("cellGameDataCheck(): CELL_GAME_ERROR_PARAM");
 		return CELL_GAME_ERROR_PARAM;
 	}
 
@@ -283,7 +283,7 @@ s32 cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameContentS
 
 		if (!Emu.GetVFS().ExistsDir("/dev_bdvd/PS3_GAME"))
 		{
-			cellGame.Warning("cellGameDataCheck(): /dev_bdvd/PS3_GAME not found");
+			cellGame.warning("cellGameDataCheck(): /dev_bdvd/PS3_GAME not found");
 			return CELL_GAME_RET_NONE;
 		}
 
@@ -298,7 +298,7 @@ s32 cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameContentS
 
 		if (!Emu.GetVFS().ExistsDir(dir))
 		{
-			cellGame.Warning("cellGameDataCheck(): '%s' directory not found", dir.c_str());
+			cellGame.warning("cellGameDataCheck(): '%s' directory not found", dir.c_str());
 			return CELL_GAME_RET_NONE;
 		}
 
@@ -313,7 +313,7 @@ s32 cellGameDataCheck(u32 type, vm::cptr<char> dirName, vm::ptr<CellGameContentS
 
 s32 cellGameContentPermit(vm::ptr<char[CELL_GAME_PATH_MAX]> contentInfoPath, vm::ptr<char[CELL_GAME_PATH_MAX]> usrdirPath)
 {
-	cellGame.Warning("cellGameContentPermit(contentInfoPath=*0x%x, usrdirPath=*0x%x)", contentInfoPath, usrdirPath);
+	cellGame.warning("cellGameContentPermit(contentInfoPath=*0x%x, usrdirPath=*0x%x)", contentInfoPath, usrdirPath);
 
 	if (!contentInfoPath && !usrdirPath)
 	{
@@ -334,7 +334,7 @@ s32 cellGameContentPermit(vm::ptr<char[CELL_GAME_PATH_MAX]> contentInfoPath, vm:
 		// make temporary directory persistent
 		if (Emu.GetVFS().Rename("/dev_hdd1/game/" + path_set->dir, dir))
 		{
-			cellGame.Success("cellGameContentPermit(): '%s' directory created", dir);
+			cellGame.success("cellGameContentPermit(): '%s' directory created", dir);
 		}
 		else
 		{
@@ -358,11 +358,11 @@ s32 cellGameContentPermit(vm::ptr<char[CELL_GAME_PATH_MAX]> contentInfoPath, vm:
 
 s32 cellGameDataCheckCreate2(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
 {
-	cellGame.Warning("cellGameDataCheckCreate2(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
+	cellGame.warning("cellGameDataCheckCreate2(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
 	if (version != CELL_GAMEDATA_VERSION_CURRENT || errDialog > 1)
 	{
-		cellGame.Error("cellGameDataCheckCreate2(): CELL_GAMEDATA_ERROR_PARAM");
+		cellGame.error("cellGameDataCheckCreate2(): CELL_GAMEDATA_ERROR_PARAM");
 		return CELL_GAMEDATA_ERROR_PARAM;
 	}
 
@@ -372,7 +372,7 @@ s32 cellGameDataCheckCreate2(PPUThread& ppu, u32 version, vm::cptr<char> dirName
 
 	if (!Emu.GetVFS().ExistsDir(dir))
 	{
-		cellGame.Todo("cellGameDataCheckCreate2(): creating directory '%s'", dir.c_str());
+		cellGame.todo("cellGameDataCheckCreate2(): creating directory '%s'", dir.c_str());
 		// TODO: create data
 		return CELL_GAMEDATA_RET_OK;
 	}
@@ -381,7 +381,7 @@ s32 cellGameDataCheckCreate2(PPUThread& ppu, u32 version, vm::cptr<char> dirName
 	const PSFLoader psf(f);
 	if (!psf)
 	{
-		cellGame.Error("cellGameDataCheckCreate2(): CELL_GAMEDATA_ERROR_BROKEN (cannot read PARAM.SFO)");
+		cellGame.error("cellGameDataCheckCreate2(): CELL_GAMEDATA_ERROR_BROKEN (cannot read PARAM.SFO)");
 		return CELL_GAMEDATA_ERROR_BROKEN;
 	}
 
@@ -417,43 +417,43 @@ s32 cellGameDataCheckCreate2(PPUThread& ppu, u32 version, vm::cptr<char> dirName
 	if (cbSet->setParam)
 	{
 		// TODO: write PARAM.SFO from cbSet
-		cellGame.Todo("cellGameDataCheckCreate2(): writing PARAM.SFO parameters (addr=0x%x)", cbSet->setParam);
+		cellGame.todo("cellGameDataCheckCreate2(): writing PARAM.SFO parameters (addr=0x%x)", cbSet->setParam);
 	}
 
 	switch ((s32)cbResult->result)
 	{
 	case CELL_GAMEDATA_CBRESULT_OK_CANCEL:
 		// TODO: do not process game data
-		cellGame.Warning("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_OK_CANCEL");
+		cellGame.warning("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_OK_CANCEL");
 
 	case CELL_GAMEDATA_CBRESULT_OK:
 		return CELL_GAMEDATA_RET_OK;
 
 	case CELL_GAMEDATA_CBRESULT_ERR_NOSPACE: // TODO: process errors, error message and needSizeKB result
-		cellGame.Error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_NOSPACE");
+		cellGame.error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_NOSPACE");
 		return CELL_GAMEDATA_ERROR_CBRESULT;
 
 	case CELL_GAMEDATA_CBRESULT_ERR_BROKEN:
-		cellGame.Error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_BROKEN");
+		cellGame.error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_BROKEN");
 		return CELL_GAMEDATA_ERROR_CBRESULT;
 
 	case CELL_GAMEDATA_CBRESULT_ERR_NODATA:
-		cellGame.Error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_NODATA");
+		cellGame.error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_NODATA");
 		return CELL_GAMEDATA_ERROR_CBRESULT;
 
 	case CELL_GAMEDATA_CBRESULT_ERR_INVALID:
-		cellGame.Error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_INVALID");
+		cellGame.error("cellGameDataCheckCreate2(): callback returned CELL_GAMEDATA_CBRESULT_ERR_INVALID");
 		return CELL_GAMEDATA_ERROR_CBRESULT;
 
 	default:
-		cellGame.Error("cellGameDataCheckCreate2(): callback returned unknown error (code=0x%x)");
+		cellGame.error("cellGameDataCheckCreate2(): callback returned unknown error (code=0x%x)");
 		return CELL_GAMEDATA_ERROR_CBRESULT;
 	}
 }
 
 s32 cellGameDataCheckCreate(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, vm::ptr<CellGameDataStatCallback> funcStat, u32 container)
 {
-	cellGame.Warning("cellGameDataCheckCreate(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
+	cellGame.warning("cellGameDataCheckCreate(version=0x%x, dirName=*0x%x, errDialog=0x%x, funcStat=*0x%x, container=%d)", version, dirName, errDialog, funcStat, container);
 
 	// TODO: almost identical, the only difference is that this function will always calculate the size of game data
 	return cellGameDataCheckCreate2(ppu, version, dirName, errDialog, funcStat, container);
@@ -461,7 +461,7 @@ s32 cellGameDataCheckCreate(PPUThread& ppu, u32 version, vm::cptr<char> dirName,
 
 s32 cellGameCreateGameData(vm::ptr<CellGameSetInitParams> init, vm::ptr<char[CELL_GAME_PATH_MAX]> tmp_contentInfoPath, vm::ptr<char[CELL_GAME_PATH_MAX]> tmp_usrdirPath)
 {
-	cellGame.Error("cellGameCreateGameData(init=*0x%x, tmp_contentInfoPath=*0x%x, tmp_usrdirPath=*0x%x)", init, tmp_contentInfoPath, tmp_usrdirPath);
+	cellGame.error("cellGameCreateGameData(init=*0x%x, tmp_contentInfoPath=*0x%x, tmp_usrdirPath=*0x%x)", init, tmp_contentInfoPath, tmp_usrdirPath);
 
 	std::string dir = init->titleId;
 	std::string tmp_contentInfo = "/dev_hdd1/game/" + dir;
@@ -469,13 +469,13 @@ s32 cellGameCreateGameData(vm::ptr<CellGameSetInitParams> init, vm::ptr<char[CEL
 
 	if (!Emu.GetVFS().CreateDir(tmp_contentInfo))
 	{
-		cellGame.Error("cellGameCreateGameData(): failed to create content directory ('%s')", tmp_contentInfo);
+		cellGame.error("cellGameCreateGameData(): failed to create content directory ('%s')", tmp_contentInfo);
 		return CELL_GAME_ERROR_ACCESS_ERROR; // ???
 	}
 
 	if (!Emu.GetVFS().CreateDir(tmp_usrdir))
 	{
-		cellGame.Error("cellGameCreateGameData(): failed to create USRDIR directory ('%s')", tmp_usrdir);
+		cellGame.error("cellGameCreateGameData(): failed to create USRDIR directory ('%s')", tmp_usrdir);
 		return CELL_GAME_ERROR_ACCESS_ERROR; // ???
 	}
 
@@ -488,7 +488,7 @@ s32 cellGameCreateGameData(vm::ptr<CellGameSetInitParams> init, vm::ptr<char[CEL
 	strcpy_trunc(*tmp_contentInfoPath, tmp_contentInfo);
 	strcpy_trunc(*tmp_usrdirPath, tmp_usrdir);
 
-	cellGame.Success("cellGameCreateGameData(): temporary gamedata directory created ('%s')", tmp_contentInfo);
+	cellGame.success("cellGameCreateGameData(): temporary gamedata directory created ('%s')", tmp_contentInfo);
 
 	// TODO: set initial PARAM.SFO parameters
 	
@@ -503,7 +503,7 @@ s32 cellGameDeleteGameData()
 
 s32 cellGameGetParamInt(u32 id, vm::ptr<u32> value)
 {
-	cellGame.Warning("cellGameGetParamInt(id=%d, value=*0x%x)", id, value);
+	cellGame.warning("cellGameGetParamInt(id=%d, value=*0x%x)", id, value);
 
 	// TODO: Access through cellGame***Check functions
 	vfsFile f("/app_home/../PARAM.SFO");
@@ -521,7 +521,7 @@ s32 cellGameGetParamInt(u32 id, vm::ptr<u32> value)
 	case CELL_GAME_PARAMID_SOUND_FORMAT:   *value = psf.GetInteger("SOUND_FORMAT");   break;
 
 	default:
-		cellGame.Error("cellGameGetParamInt(): Unimplemented parameter (%d)", id);
+		cellGame.error("cellGameGetParamInt(): Unimplemented parameter (%d)", id);
 		return CELL_GAME_ERROR_INVALID_ID;
 	}
 
@@ -530,7 +530,7 @@ s32 cellGameGetParamInt(u32 id, vm::ptr<u32> value)
 
 s32 cellGameGetParamString(u32 id, vm::ptr<char> buf, u32 bufsize)
 {
-	cellGame.Warning("cellGameGetParamString(id=%d, buf=*0x%x, bufsize=%d)", id, buf, bufsize);
+	cellGame.warning("cellGameGetParamString(id=%d, buf=*0x%x, bufsize=%d)", id, buf, bufsize);
 
 	// TODO: Access through cellGame***Check functions
 	vfsFile f("/app_home/../PARAM.SFO");
@@ -570,7 +570,7 @@ s32 cellGameGetParamString(u32 id, vm::ptr<char> buf, u32 bufsize)
 	case CELL_GAME_PARAMID_APP_VER:                  data = psf.GetString("APP_VER");        break;
 
 	default:
-		cellGame.Error("cellGameGetParamString(): Unimplemented parameter (%d)", id);
+		cellGame.error("cellGameGetParamString(): Unimplemented parameter (%d)", id);
 		return CELL_GAME_ERROR_INVALID_ID;
 	}
 
@@ -605,7 +605,7 @@ s32 cellGameGetLocalWebContentPath()
 
 s32 cellGameContentErrorDialog(s32 type, s32 errNeedSizeKB, vm::cptr<char> dirName)
 {
-	cellGame.Warning("cellGameContentErrorDialog(type=%d, errNeedSizeKB=%d, dirName=*0x%x)", type, errNeedSizeKB, dirName);
+	cellGame.warning("cellGameContentErrorDialog(type=%d, errNeedSizeKB=%d, dirName=*0x%x)", type, errNeedSizeKB, dirName);
 
 	std::string errorName;
 	switch (type)

rpcs3/Emu/SysCalls/Modules/cellGameExec.cpp

@@ -13,7 +13,7 @@ s32 cellGameSetExitParam()
 
 s32 cellGameGetHomeDataExportPath(vm::ptr<char> exportPath)
 {
-	cellGameExec.Warning("cellGameGetHomeDataExportPath(exportPath=0x%x)", exportPath);
+	cellGameExec.warning("cellGameGetHomeDataExportPath(exportPath=0x%x)", exportPath);
 
 	// TODO: PlayStation home is defunct.
 
@@ -37,7 +37,7 @@ s32 cellGameGetHomeLaunchOptionPath()
 
 s32 cellGameGetBootGameInfo(vm::ptr<u32> type, vm::ptr<char> dirName, vm::ptr<u32> execData)
 {
-	cellGameExec.Todo("cellGameGetBootGameInfo(type=*0x%x, dirName=*0x%x, execData=*0x%x)", type, dirName, execData);
+	cellGameExec.todo("cellGameGetBootGameInfo(type=*0x%x, dirName=*0x%x, execData=*0x%x)", type, dirName, execData);
 
 	// TODO: Support more boot types
 	*type = CELL_GAME_GAMETYPE_SYS;

rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp

@@ -80,17 +80,17 @@ void InitOffsetTable()
 
 u32 cellGcmGetLabelAddress(u8 index)
 {
-	cellGcmSys.Log("cellGcmGetLabelAddress(index=%d)", index);
+	cellGcmSys.trace("cellGcmGetLabelAddress(index=%d)", index);
 	return gcm_info.label_addr + 0x10 * index;
 }
 
 vm::ptr<CellGcmReportData> cellGcmGetReportDataAddressLocation(u32 index, u32 location)
 {
-	cellGcmSys.Warning("cellGcmGetReportDataAddressLocation(index=%d, location=%d)", index, location);
+	cellGcmSys.warning("cellGcmGetReportDataAddressLocation(index=%d, location=%d)", index, location);
 
 	if (location == CELL_GCM_LOCATION_LOCAL) {
 		if (index >= 2048) {
-			cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
+			cellGcmSys.error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
 			return vm::null;
 		}
 		return vm::ptr<CellGcmReportData>::make(0xC0000000 + index * 0x10);
@@ -98,23 +98,23 @@ vm::ptr<CellGcmReportData> cellGcmGetReportDataAddressLocation(u32 index, u32 lo
 
 	if (location == CELL_GCM_LOCATION_MAIN) {
 		if (index >= 1024 * 1024) {
-			cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong main index (%d)", index);
+			cellGcmSys.error("cellGcmGetReportDataAddressLocation: Wrong main index (%d)", index);
 			return vm::null;
 		}
 		// TODO: It seems m_report_main_addr is not initialized
 		return vm::ptr<CellGcmReportData>::make(Emu.GetGSManager().GetRender().report_main_addr + index * 0x10);
 	}
 
-	cellGcmSys.Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
+	cellGcmSys.error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
 	return vm::null;
 }
 
 u64 cellGcmGetTimeStamp(u32 index)
 {
-	cellGcmSys.Log("cellGcmGetTimeStamp(index=%d)", index);
+	cellGcmSys.trace("cellGcmGetTimeStamp(index=%d)", index);
 
 	if (index >= 2048) {
-		cellGcmSys.Error("cellGcmGetTimeStamp: Wrong local index (%d)", index);
+		cellGcmSys.error("cellGcmGetTimeStamp: Wrong local index (%d)", index);
 		return 0;
 	}
 	return vm::read64(0xC0000000 + index * 0x10);
@@ -128,7 +128,7 @@ s32 cellGcmGetCurrentField()
 
 u32 cellGcmGetNotifyDataAddress(u32 index)
 {
-	cellGcmSys.Warning("cellGcmGetNotifyDataAddress(index=%d)", index);
+	cellGcmSys.warning("cellGcmGetNotifyDataAddress(index=%d)", index);
 
 	// If entry not in use, return NULL
 	u16 entry = offsetTable.eaAddress[241];
@@ -149,10 +149,10 @@ vm::ptr<CellGcmReportData> _cellGcmFunc12()
 
 u32 cellGcmGetReport(u32 type, u32 index)
 {
-	cellGcmSys.Warning("cellGcmGetReport(type=%d, index=%d)", type, index);
+	cellGcmSys.warning("cellGcmGetReport(type=%d, index=%d)", type, index);
 
 	if (index >= 2048) {
-		cellGcmSys.Error("cellGcmGetReport: Wrong local index (%d)", index);
+		cellGcmSys.error("cellGcmGetReport: Wrong local index (%d)", index);
 		return -1;
 	}
 
@@ -166,10 +166,10 @@ u32 cellGcmGetReport(u32 type, u32 index)
 
 u32 cellGcmGetReportDataAddress(u32 index)
 {
-	cellGcmSys.Warning("cellGcmGetReportDataAddress(index=%d)",  index);
+	cellGcmSys.warning("cellGcmGetReportDataAddress(index=%d)",  index);
 
 	if (index >= 2048) {
-		cellGcmSys.Error("cellGcmGetReportDataAddress: Wrong local index (%d)", index);
+		cellGcmSys.error("cellGcmGetReportDataAddress: Wrong local index (%d)", index);
 		return 0;
 	}
 	return 0xC0000000 + index * 0x10;
@@ -177,7 +177,7 @@ u32 cellGcmGetReportDataAddress(u32 index)
 
 u32 cellGcmGetReportDataLocation(u32 index, u32 location)
 {
-	cellGcmSys.Warning("cellGcmGetReportDataLocation(index=%d, location=%d)", index, location);
+	cellGcmSys.warning("cellGcmGetReportDataLocation(index=%d, location=%d)", index, location);
 
 	vm::ptr<CellGcmReportData> report = cellGcmGetReportDataAddressLocation(index, location);
 	return report->value;
@@ -185,11 +185,11 @@ u32 cellGcmGetReportDataLocation(u32 index, u32 location)
 
 u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
 {
-	cellGcmSys.Warning("cellGcmGetTimeStampLocation(index=%d, location=%d)", index, location);
+	cellGcmSys.warning("cellGcmGetTimeStampLocation(index=%d, location=%d)", index, location);
 
 	if (location == CELL_GCM_LOCATION_LOCAL) {
 		if (index >= 2048) {
-			cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong local index (%d)", index);
+			cellGcmSys.error("cellGcmGetTimeStampLocation: Wrong local index (%d)", index);
 			return 0;
 		}
 		return vm::read64(0xC0000000 + index * 0x10);
@@ -197,14 +197,14 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
 
 	if (location == CELL_GCM_LOCATION_MAIN) {
 		if (index >= 1024 * 1024) {
-			cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong main index (%d)", index);
+			cellGcmSys.error("cellGcmGetTimeStampLocation: Wrong main index (%d)", index);
 			return 0;
 		}
 		// TODO: It seems m_report_main_addr is not initialized
 		return vm::read64(Emu.GetGSManager().GetRender().report_main_addr + index * 0x10);
 	}
 
-	cellGcmSys.Error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
+	cellGcmSys.error("cellGcmGetTimeStampLocation: Wrong location (%d)", location);
 	return 0;
 }
 
@@ -214,32 +214,32 @@ u64 cellGcmGetTimeStampLocation(u32 index, u32 location)
 
 u32 cellGcmGetControlRegister()
 {
-	cellGcmSys.Log("cellGcmGetControlRegister()");
+	cellGcmSys.trace("cellGcmGetControlRegister()");
 
 	return gcm_info.control_addr;
 }
 
 u32 cellGcmGetDefaultCommandWordSize()
 {
-	cellGcmSys.Log("cellGcmGetDefaultCommandWordSize()");
+	cellGcmSys.trace("cellGcmGetDefaultCommandWordSize()");
 	return 0x400;
 }
 
 u32 cellGcmGetDefaultSegmentWordSize()
 {
-	cellGcmSys.Log("cellGcmGetDefaultSegmentWordSize()");
+	cellGcmSys.trace("cellGcmGetDefaultSegmentWordSize()");
 	return 0x100;
 }
 
 s32 cellGcmInitDefaultFifoMode(s32 mode)
 {
-	cellGcmSys.Warning("cellGcmInitDefaultFifoMode(mode=%d)", mode);
+	cellGcmSys.warning("cellGcmInitDefaultFifoMode(mode=%d)", mode);
 	return CELL_OK;
 }
 
 s32 cellGcmSetDefaultFifoSize(u32 bufferSize, u32 segmentSize)
 {
-	cellGcmSys.Warning("cellGcmSetDefaultFifoSize(bufferSize=0x%x, segmentSize=0x%x)", bufferSize, segmentSize);
+	cellGcmSys.warning("cellGcmSetDefaultFifoSize(bufferSize=0x%x, segmentSize=0x%x)", bufferSize, segmentSize);
 	return CELL_OK;
 }
 
@@ -249,11 +249,11 @@ s32 cellGcmSetDefaultFifoSize(u32 bufferSize, u32 segmentSize)
 
 s32 cellGcmBindTile(u8 index)
 {
-	cellGcmSys.Warning("cellGcmBindTile(index=%d)", index);
+	cellGcmSys.warning("cellGcmBindTile(index=%d)", index);
 
 	if (index >= rsx::limits::tiles_count)
 	{
-		cellGcmSys.Error("cellGcmBindTile: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmBindTile: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -265,11 +265,11 @@ s32 cellGcmBindTile(u8 index)
 
 s32 cellGcmBindZcull(u8 index)
 {
-	cellGcmSys.Warning("cellGcmBindZcull(index=%d)", index);
+	cellGcmSys.warning("cellGcmBindZcull(index=%d)", index);
 
 	if (index >= rsx::limits::zculls_count)
 	{
-		cellGcmSys.Error("cellGcmBindZcull: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmBindZcull: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -281,7 +281,7 @@ s32 cellGcmBindZcull(u8 index)
 
 s32 cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
 {
-	cellGcmSys.Log("cellGcmGetConfiguration(config=*0x%x)", config);
+	cellGcmSys.trace("cellGcmGetConfiguration(config=*0x%x)", config);
 
 	*config = current_config;
 
@@ -292,14 +292,14 @@ s32 cellGcmGetFlipStatus()
 {
 	s32 status = Emu.GetGSManager().GetRender().flip_status;
 
-	cellGcmSys.Log("cellGcmGetFlipStatus() -> %d", status);
+	cellGcmSys.trace("cellGcmGetFlipStatus() -> %d", status);
 
 	return status;
 }
 
 u32 cellGcmGetTiledPitchSize(u32 size)
 {
-	cellGcmSys.Log("cellGcmGetTiledPitchSize(size=%d)", size);
+	cellGcmSys.trace("cellGcmGetTiledPitchSize(size=%d)", size);
 
 	for (size_t i=0; i < sizeof(tiled_pitches) / sizeof(tiled_pitches[0]) - 1; i++) {
 		if (tiled_pitches[i] < size && size <= tiled_pitches[i+1]) {
@@ -311,13 +311,13 @@ u32 cellGcmGetTiledPitchSize(u32 size)
 
 void _cellGcmFunc1()
 {
-	cellGcmSys.Todo("_cellGcmFunc1()");
+	cellGcmSys.todo("_cellGcmFunc1()");
 	return;
 }
 
 void _cellGcmFunc15(vm::ptr<CellGcmContextData> context)
 {
-	cellGcmSys.Todo("_cellGcmFunc15(context=*0x%x)", context);
+	cellGcmSys.todo("_cellGcmFunc15(context=*0x%x)", context);
 	return;
 }
 
@@ -326,7 +326,7 @@ u32 g_defaultCommandBufferBegin, g_defaultCommandBufferFragmentCount;
 // Called by cellGcmInit
 s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSize, u32 ioAddress)
 {
-	cellGcmSys.Warning("_cellGcmInitBody(context=**0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context, cmdSize, ioSize, ioAddress);
+	cellGcmSys.warning("_cellGcmInitBody(context=**0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context, cmdSize, ioSize, ioAddress);
 
 	if (!local_size && !local_addr)
 	{
@@ -335,23 +335,23 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
 		vm::falloc(0xC0000000, local_size, vm::video);
 	}
 
-	cellGcmSys.Warning("*** local memory(addr=0x%x, size=0x%x)", local_addr, local_size);
+	cellGcmSys.warning("*** local memory(addr=0x%x, size=0x%x)", local_addr, local_size);
 
 	InitOffsetTable();
 	if (system_mode == CELL_GCM_SYSTEM_MODE_IOMAP_512MB)
 	{
-		cellGcmSys.Warning("cellGcmInit(): 512MB io address space used");
+		cellGcmSys.warning("cellGcmInit(): 512MB io address space used");
 		RSXIOMem.SetRange(0, 0x20000000 /*512MB*/);
 	}
 	else
 	{
-		cellGcmSys.Warning("cellGcmInit(): 256MB io address space used");
+		cellGcmSys.warning("cellGcmInit(): 256MB io address space used");
 		RSXIOMem.SetRange(0, 0x10000000 /*256MB*/);
 	}
 
 	if (gcmMapEaIoAddress(ioAddress, 0, ioSize, false) != CELL_OK)
 	{
-		cellGcmSys.Error("cellGcmInit: CELL_GCM_ERROR_FAILURE");
+		cellGcmSys.error("cellGcmInit: CELL_GCM_ERROR_FAILURE");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -403,7 +403,7 @@ s32 _cellGcmInitBody(vm::pptr<CellGcmContextData> context, u32 cmdSize, u32 ioSi
 
 s32 cellGcmResetFlipStatus()
 {
-	cellGcmSys.Log("cellGcmResetFlipStatus()");
+	cellGcmSys.trace("cellGcmResetFlipStatus()");
 
 	Emu.GetGSManager().GetRender().flip_status = CELL_GCM_DISPLAY_FLIP_STATUS_WAITING;
 
@@ -412,7 +412,7 @@ s32 cellGcmResetFlipStatus()
 
 s32 cellGcmSetDebugOutputLevel(s32 level)
 {
-	cellGcmSys.Warning("cellGcmSetDebugOutputLevel(level=%d)", level);
+	cellGcmSys.warning("cellGcmSetDebugOutputLevel(level=%d)", level);
 
 	switch (level)
 	{
@@ -430,11 +430,11 @@ s32 cellGcmSetDebugOutputLevel(s32 level)
 
 s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height)
 {
-	cellGcmSys.Log("cellGcmSetDisplayBuffer(id=0x%x,offset=0x%x,pitch=%d,width=%d,height=%d)", id, offset, width ? pitch / width : pitch, width, height);
+	cellGcmSys.trace("cellGcmSetDisplayBuffer(id=0x%x,offset=0x%x,pitch=%d,width=%d,height=%d)", id, offset, width ? pitch / width : pitch, width, height);
 
 	if (id > 7)
 	{
-		cellGcmSys.Error("cellGcmSetDisplayBuffer: CELL_EINVAL");
+		cellGcmSys.error("cellGcmSetDisplayBuffer: CELL_EINVAL");
 		return CELL_EINVAL;
 	}
 
@@ -455,14 +455,14 @@ s32 cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
 
 void cellGcmSetFlipHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetFlipHandler(handler=*0x%x)", handler);
+	cellGcmSys.warning("cellGcmSetFlipHandler(handler=*0x%x)", handler);
 
 	Emu.GetGSManager().GetRender().flip_handler = handler;
 }
 
 s32 cellGcmSetFlipMode(u32 mode)
 {
-	cellGcmSys.Warning("cellGcmSetFlipMode(mode=%d)", mode);
+	cellGcmSys.warning("cellGcmSetFlipMode(mode=%d)", mode);
 
 	switch (mode)
 	{
@@ -481,18 +481,18 @@ s32 cellGcmSetFlipMode(u32 mode)
 
 void cellGcmSetFlipStatus()
 {
-	cellGcmSys.Warning("cellGcmSetFlipStatus()");
+	cellGcmSys.warning("cellGcmSetFlipStatus()");
 
 	Emu.GetGSManager().GetRender().flip_status = 0;
 }
 
 s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
 {
-	cellGcmSys.Log("cellGcmSetPrepareFlip(ctx=*0x%x, id=0x%x)", ctxt, id);
+	cellGcmSys.trace("cellGcmSetPrepareFlip(ctx=*0x%x, id=0x%x)", ctxt, id);
 
 	if (id > 7)
 	{
-		cellGcmSys.Error("cellGcmSetPrepareFlip: CELL_GCM_ERROR_FAILURE");
+		cellGcmSys.error("cellGcmSetPrepareFlip: CELL_GCM_ERROR_FAILURE");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -500,7 +500,7 @@ s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32
 	{
 		if (s32 res = ctxt->callback(ppu, ctxt, 8 /* ??? */))
 		{
-			cellGcmSys.Error("cellGcmSetPrepareFlip: callback failed (0x%08x)", res);
+			cellGcmSys.error("cellGcmSetPrepareFlip: callback failed (0x%08x)", res);
 			return res;
 		}
 	}
@@ -527,7 +527,7 @@ s32 cellGcmSetPrepareFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32
 
 s32 cellGcmSetFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
 {
-	cellGcmSys.Log("cellGcmSetFlip(ctxt=*0x%x, id=0x%x)", ctxt, id);
+	cellGcmSys.trace("cellGcmSetFlip(ctxt=*0x%x, id=0x%x)", ctxt, id);
 
 	if (s32 res = cellGcmSetPrepareFlip(ppu, ctxt, id))
 	{
@@ -539,17 +539,17 @@ s32 cellGcmSetFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> ctxt, u32 id)
 
 s32 cellGcmSetSecondVFrequency(u32 freq)
 {
-	cellGcmSys.Warning("cellGcmSetSecondVFrequency(level=%d)", freq);
+	cellGcmSys.warning("cellGcmSetSecondVFrequency(level=%d)", freq);
 
 	switch (freq)
 	{
 	case CELL_GCM_DISPLAY_FREQUENCY_59_94HZ:
 		Emu.GetGSManager().GetRender().frequency_mode = freq; Emu.GetGSManager().GetRender().fps_limit = 59.94; break;
 	case CELL_GCM_DISPLAY_FREQUENCY_SCANOUT:
-		Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Scanout"); break;
+		Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.todo("Unimplemented display frequency: Scanout"); break;
 	case CELL_GCM_DISPLAY_FREQUENCY_DISABLE:
-		Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.Todo("Unimplemented display frequency: Disabled"); break;
+		Emu.GetGSManager().GetRender().frequency_mode = freq; cellGcmSys.todo("Unimplemented display frequency: Disabled"); break;
-	default: cellGcmSys.Error("Improper display frequency specified!"); return CELL_OK;
+	default: cellGcmSys.error("Improper display frequency specified!"); return CELL_OK;
 	}
 
 	return CELL_OK;
@@ -557,30 +557,30 @@ s32 cellGcmSetSecondVFrequency(u32 freq)
 
 s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 comp, u16 base, u8 bank)
 {
-	cellGcmSys.Warning("cellGcmSetTileInfo(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
+	cellGcmSys.warning("cellGcmSetTileInfo(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
 		index, location, offset, size, pitch, comp, base, bank);
 
 	if (index >= rsx::limits::tiles_count || base >= 2048 || bank >= 4)
 	{
-		cellGcmSys.Error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
 	if (offset & 0xffff || size & 0xffff || pitch & 0xf)
 	{
-		cellGcmSys.Error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_ALIGNMENT");
+		cellGcmSys.error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_ALIGNMENT");
 		return CELL_GCM_ERROR_INVALID_ALIGNMENT;
 	}
 
 	if (location >= 2 || (comp != 0 && (comp < 7 || comp > 12)))
 	{
-		cellGcmSys.Error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_ALIGNMENT");
+		cellGcmSys.error("cellGcmSetTileInfo: CELL_GCM_ERROR_INVALID_ALIGNMENT");
 		return CELL_GCM_ERROR_INVALID_ENUM;
 	}
 
 	if (comp)
 	{
-		cellGcmSys.Error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
+		cellGcmSys.error("cellGcmSetTileInfo: bad compression mode! (%d)", comp);
 	}
 
 	auto& tile = Emu.GetGSManager().GetRender().tiles[index];
@@ -598,7 +598,7 @@ s32 cellGcmSetTileInfo(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u
 
 void cellGcmSetUserHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
+	cellGcmSys.warning("cellGcmSetUserHandler(handler=*0x%x)", handler);
 
 	Emu.GetGSManager().GetRender().user_handler = handler;
 }
@@ -610,14 +610,14 @@ s32 cellGcmSetUserCommand()
 
 void cellGcmSetVBlankHandler(vm::ptr<void(u32)> handler)
 {
-	cellGcmSys.Warning("cellGcmSetVBlankHandler(handler=*0x%x)", handler);
+	cellGcmSys.warning("cellGcmSetVBlankHandler(handler=*0x%x)", handler);
 
 	Emu.GetGSManager().GetRender().vblank_handler = handler;
 }
 
 s32 cellGcmSetWaitFlip(vm::ptr<CellGcmContextData> ctxt)
 {
-	cellGcmSys.Warning("cellGcmSetWaitFlip(ctx=*0x%x)", ctxt);
+	cellGcmSys.warning("cellGcmSetWaitFlip(ctx=*0x%x)", ctxt);
 
 	// TODO: emit RSX command for "wait flip" operation
 
@@ -631,12 +631,12 @@ s32 cellGcmSetWaitFlipUnsafe()
 
 s32 cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart, u32 zFormat, u32 aaFormat, u32 zCullDir, u32 zCullFormat, u32 sFunc, u32 sRef, u32 sMask)
 {
-	cellGcmSys.Todo("cellGcmSetZcull(index=%d, offset=0x%x, width=%d, height=%d, cullStart=0x%x, zFormat=0x%x, aaFormat=0x%x, zCullDir=0x%x, zCullFormat=0x%x, sFunc=0x%x, sRef=0x%x, sMask=0x%x)",
+	cellGcmSys.todo("cellGcmSetZcull(index=%d, offset=0x%x, width=%d, height=%d, cullStart=0x%x, zFormat=0x%x, aaFormat=0x%x, zCullDir=0x%x, zCullFormat=0x%x, sFunc=0x%x, sRef=0x%x, sMask=0x%x)",
 		index, offset, width, height, cullStart, zFormat, aaFormat, zCullDir, zCullFormat, sFunc, sRef, sMask);
 
 	if (index >= rsx::limits::zculls_count)
 	{
-		cellGcmSys.Error("cellGcmSetZcull: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmSetZcull: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -659,11 +659,11 @@ s32 cellGcmSetZcull(u8 index, u32 offset, u32 width, u32 height, u32 cullStart,
 
 s32 cellGcmUnbindTile(u8 index)
 {
-	cellGcmSys.Warning("cellGcmUnbindTile(index=%d)", index);
+	cellGcmSys.warning("cellGcmUnbindTile(index=%d)", index);
 
 	if (index >= rsx::limits::tiles_count)
 	{
-		cellGcmSys.Error("cellGcmUnbindTile: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmUnbindTile: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -675,11 +675,11 @@ s32 cellGcmUnbindTile(u8 index)
 
 s32 cellGcmUnbindZcull(u8 index)
 {
-	cellGcmSys.Warning("cellGcmUnbindZcull(index=%d)", index);
+	cellGcmSys.warning("cellGcmUnbindZcull(index=%d)", index);
 
 	if (index >= 8)
 	{
-		cellGcmSys.Error("cellGcmUnbindZcull: CELL_EINVAL");
+		cellGcmSys.error("cellGcmUnbindZcull: CELL_EINVAL");
 		return CELL_EINVAL;
 	}
 
@@ -691,25 +691,25 @@ s32 cellGcmUnbindZcull(u8 index)
 
 u32 cellGcmGetTileInfo()
 {
-	cellGcmSys.Warning("cellGcmGetTileInfo()");
+	cellGcmSys.warning("cellGcmGetTileInfo()");
 	return Emu.GetGSManager().GetRender().tiles_addr;
 }
 
 u32 cellGcmGetZcullInfo()
 {
-	cellGcmSys.Warning("cellGcmGetZcullInfo()");
+	cellGcmSys.warning("cellGcmGetZcullInfo()");
 	return Emu.GetGSManager().GetRender().zculls_addr;
 }
 
 u32 cellGcmGetDisplayInfo()
 {
-	cellGcmSys.Warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().gcm_buffers.addr());
+	cellGcmSys.warning("cellGcmGetDisplayInfo() = 0x%x", Emu.GetGSManager().GetRender().gcm_buffers.addr());
 	return Emu.GetGSManager().GetRender().gcm_buffers.addr();
 }
 
 s32 cellGcmGetCurrentDisplayBufferId(vm::ptr<u8> id)
 {
-	cellGcmSys.Warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", id);
+	cellGcmSys.warning("cellGcmGetCurrentDisplayBufferId(id=*0x%x)", id);
 
 	if (Emu.GetGSManager().GetRender().gcm_current_buffer > UINT8_MAX)
 	{
@@ -746,20 +746,20 @@ s32 cellGcmGetDisplayBufferByFlipIndex()
 
 u64 cellGcmGetLastFlipTime()
 {
-	cellGcmSys.Log("cellGcmGetLastFlipTime()");
+	cellGcmSys.trace("cellGcmGetLastFlipTime()");
 
 	return Emu.GetGSManager().GetRender().last_flip_time;
 }
 
 u64 cellGcmGetLastSecondVTime()
 {
-	cellGcmSys.Todo("cellGcmGetLastSecondVTime()");
+	cellGcmSys.todo("cellGcmGetLastSecondVTime()");
 	return CELL_OK;
 }
 
 u64 cellGcmGetVBlankCount()
 {
-	cellGcmSys.Log("cellGcmGetVBlankCount()");
+	cellGcmSys.trace("cellGcmGetVBlankCount()");
 
 	return Emu.GetGSManager().GetRender().vblank_count;
 }
@@ -771,7 +771,7 @@ s32 cellGcmSysGetLastVBlankTime()
 
 s32 cellGcmInitSystemMode(u64 mode)
 {
-	cellGcmSys.Log("cellGcmInitSystemMode(mode=0x%x)", mode);
+	cellGcmSys.trace("cellGcmInitSystemMode(mode=0x%x)", mode);
 
 	system_mode = mode;
 
@@ -780,11 +780,11 @@ s32 cellGcmInitSystemMode(u64 mode)
 
 s32 cellGcmSetFlipImmediate(u8 id)
 {
-	cellGcmSys.Todo("cellGcmSetFlipImmediate(fid=0x%x)", id);
+	cellGcmSys.todo("cellGcmSetFlipImmediate(fid=0x%x)", id);
 
 	if (id > 7)
 	{
-		cellGcmSys.Error("cellGcmSetFlipImmediate: CELL_GCM_ERROR_FAILURE");
+		cellGcmSys.error("cellGcmSetFlipImmediate: CELL_GCM_ERROR_FAILURE");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -828,7 +828,7 @@ s32 cellGcmSortRemapEaIoAddress()
 //----------------------------------------------------------------------------
 s32 cellGcmAddressToOffset(u32 address, vm::ptr<u32> offset)
 {
-	cellGcmSys.Log("cellGcmAddressToOffset(address=0x%x, offset=*0x%x)", address, offset);
+	cellGcmSys.trace("cellGcmAddressToOffset(address=0x%x, offset=*0x%x)", address, offset);
 
 	// Address not on main memory or local memory
 	if (address >= 0xD0000000)
@@ -865,14 +865,14 @@ s32 cellGcmAddressToOffset(u32 address, vm::ptr<u32> offset)
 
 u32 cellGcmGetMaxIoMapSize()
 {
-	cellGcmSys.Log("cellGcmGetMaxIoMapSize()");
+	cellGcmSys.trace("cellGcmGetMaxIoMapSize()");
 
 	return RSXIOMem.GetSize() - RSXIOMem.GetReservedAmount();
 }
 
 void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table)
 {
-	cellGcmSys.Log("cellGcmGetOffsetTable(table=*0x%x)", table);
+	cellGcmSys.trace("cellGcmGetOffsetTable(table=*0x%x)", table);
 
 	table->ioAddress = offsetTable.ioAddress;
 	table->eaAddress = offsetTable.eaAddress;
@@ -880,7 +880,7 @@ void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table)
 
 s32 cellGcmIoOffsetToAddress(u32 ioOffset, vm::ptr<u32> address)
 {
-	cellGcmSys.Log("cellGcmIoOffsetToAddress(ioOffset=0x%x, address=*0x%x)", ioOffset, address);
+	cellGcmSys.trace("cellGcmIoOffsetToAddress(ioOffset=0x%x, address=*0x%x)", ioOffset, address);
 
 	u32 realAddr;
 
@@ -909,7 +909,7 @@ s32 gcmMapEaIoAddress(u32 ea, u32 io, u32 size, bool is_strict)
 	}
 	else
 	{
-		cellGcmSys.Error("cellGcmMapEaIoAddress: CELL_GCM_ERROR_FAILURE");
+		cellGcmSys.error("cellGcmMapEaIoAddress: CELL_GCM_ERROR_FAILURE");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -918,14 +918,14 @@ s32 gcmMapEaIoAddress(u32 ea, u32 io, u32 size, bool is_strict)
 
 s32 cellGcmMapEaIoAddress(u32 ea, u32 io, u32 size)
 {
-	cellGcmSys.Warning("cellGcmMapEaIoAddress(ea=0x%x, io=0x%x, size=0x%x)", ea, io, size);
+	cellGcmSys.warning("cellGcmMapEaIoAddress(ea=0x%x, io=0x%x, size=0x%x)", ea, io, size);
 
 	return gcmMapEaIoAddress(ea, io, size, false);
 }
 
 s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags)
 {
-	cellGcmSys.Warning("cellGcmMapEaIoAddressWithFlags(ea=0x%x, io=0x%x, size=0x%x, flags=0x%x)", ea, io, size, flags);
+	cellGcmSys.warning("cellGcmMapEaIoAddressWithFlags(ea=0x%x, io=0x%x, size=0x%x, flags=0x%x)", ea, io, size, flags);
 
 	assert(flags == 2 /*CELL_GCM_IOMAP_FLAG_STRICT_ORDERING*/);
 
@@ -934,7 +934,7 @@ s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags)
 
 s32 cellGcmMapLocalMemory(vm::ptr<u32> address, vm::ptr<u32> size)
 {
-	cellGcmSys.Warning("cellGcmMapLocalMemory(address=*0x%x, size=*0x%x)", address, size);
+	cellGcmSys.warning("cellGcmMapLocalMemory(address=*0x%x, size=*0x%x)", address, size);
 
 	if (!local_addr && !local_size && vm::falloc(local_addr = 0xC0000000, local_size = 0xf900000 /* TODO */, vm::video))
 	{
@@ -943,7 +943,7 @@ s32 cellGcmMapLocalMemory(vm::ptr<u32> address, vm::ptr<u32> size)
 	}
 	else
 	{
-		cellGcmSys.Error("RSX local memory already mapped");
+		cellGcmSys.error("RSX local memory already mapped");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -952,7 +952,7 @@ s32 cellGcmMapLocalMemory(vm::ptr<u32> address, vm::ptr<u32> size)
 
 s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
 {
-	cellGcmSys.Warning("cellGcmMapMainMemory(ea=0x%x, size=0x%x, offset=*0x%x)", ea, size, offset);
+	cellGcmSys.warning("cellGcmMapMainMemory(ea=0x%x, size=0x%x, offset=*0x%x)", ea, size, offset);
 
 	if ((ea & 0xFFFFF) || (size & 0xFFFFF)) return CELL_GCM_ERROR_FAILURE;
 
@@ -973,7 +973,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
 	}
 	else
 	{
-		cellGcmSys.Error("cellGcmMapMainMemory: CELL_GCM_ERROR_NO_IO_PAGE_TABLE");
+		cellGcmSys.error("cellGcmMapMainMemory: CELL_GCM_ERROR_NO_IO_PAGE_TABLE");
 		return CELL_GCM_ERROR_NO_IO_PAGE_TABLE;
 	}
 
@@ -984,17 +984,17 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<u32> offset)
 
 s32 cellGcmReserveIoMapSize(u32 size)
 {
-	cellGcmSys.Log("cellGcmReserveIoMapSize(size=0x%x)", size);
+	cellGcmSys.trace("cellGcmReserveIoMapSize(size=0x%x)", size);
 
 	if (size & 0xFFFFF)
 	{
-		cellGcmSys.Error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_ALIGNMENT");
+		cellGcmSys.error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_ALIGNMENT");
 		return CELL_GCM_ERROR_INVALID_ALIGNMENT;
 	}
 
 	if (size > cellGcmGetMaxIoMapSize())
 	{
-		cellGcmSys.Error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -1004,7 +1004,7 @@ s32 cellGcmReserveIoMapSize(u32 size)
 
 s32 cellGcmUnmapEaIoAddress(u32 ea)
 {
-	cellGcmSys.Log("cellGcmUnmapEaIoAddress(ea=0x%x)", ea);
+	cellGcmSys.trace("cellGcmUnmapEaIoAddress(ea=0x%x)", ea);
 
 	u32 size;
 	if (RSXIOMem.UnmapRealAddress(ea, size))
@@ -1019,7 +1019,7 @@ s32 cellGcmUnmapEaIoAddress(u32 ea)
 	}
 	else
 	{
-		cellGcmSys.Error("cellGcmUnmapEaIoAddress(ea=0x%x): UnmapRealAddress() failed");
+		cellGcmSys.error("cellGcmUnmapEaIoAddress(ea=0x%x): UnmapRealAddress() failed");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -1028,7 +1028,7 @@ s32 cellGcmUnmapEaIoAddress(u32 ea)
 
 s32 cellGcmUnmapIoAddress(u32 io)
 {
-	cellGcmSys.Log("cellGcmUnmapIoAddress(io=0x%x)", io);
+	cellGcmSys.trace("cellGcmUnmapIoAddress(io=0x%x)", io);
 
 	u32 size;
 	if (RSXIOMem.UnmapAddress(io, size))
@@ -1043,7 +1043,7 @@ s32 cellGcmUnmapIoAddress(u32 io)
 	}
 	else
 	{
-		cellGcmSys.Error("cellGcmUnmapIoAddress(io=0x%x): UnmapAddress() failed");
+		cellGcmSys.error("cellGcmUnmapIoAddress(io=0x%x): UnmapAddress() failed");
 		return CELL_GCM_ERROR_FAILURE;
 	}
 
@@ -1052,17 +1052,17 @@ s32 cellGcmUnmapIoAddress(u32 io)
 
 s32 cellGcmUnreserveIoMapSize(u32 size)
 {
-	cellGcmSys.Log("cellGcmUnreserveIoMapSize(size=0x%x)", size);
+	cellGcmSys.trace("cellGcmUnreserveIoMapSize(size=0x%x)", size);
 
 	if (size & 0xFFFFF)
 	{
-		cellGcmSys.Error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_ALIGNMENT");
+		cellGcmSys.error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_ALIGNMENT");
 		return CELL_GCM_ERROR_INVALID_ALIGNMENT;
 	}
 
 	if (size > RSXIOMem.GetReservedAmount())
 	{
-		cellGcmSys.Error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmReserveIoMapSize: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
@@ -1116,7 +1116,7 @@ s32 cellGcmSetCursorImageOffset(u32 offset)
 
 void cellGcmSetDefaultCommandBuffer()
 {
-	cellGcmSys.Warning("cellGcmSetDefaultCommandBuffer()");
+	cellGcmSys.warning("cellGcmSetDefaultCommandBuffer()");
 	vm::write32(Emu.GetGSManager().GetRender().ctxt_addr, gcm_info.context_addr);
 }
 
@@ -1131,14 +1131,14 @@ s32 cellGcmSetDefaultCommandBufferAndSegmentWordSize()
 
 s32 _cellGcmSetFlipCommand(PPUThread& ppu, vm::ptr<CellGcmContextData> ctx, u32 id)
 {
-	cellGcmSys.Log("cellGcmSetFlipCommand(ctx=*0x%x, id=0x%x)", ctx, id);
+	cellGcmSys.trace("cellGcmSetFlipCommand(ctx=*0x%x, id=0x%x)", ctx, id);
 
 	return cellGcmSetPrepareFlip(ppu, ctx, id);
 }
 
 s32 _cellGcmSetFlipCommandWithWaitLabel(PPUThread& ppu, vm::ptr<CellGcmContextData> ctx, u32 id, u32 label_index, u32 label_value)
 {
-	cellGcmSys.Log("cellGcmSetFlipCommandWithWaitLabel(ctx=*0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)", ctx, id, label_index, label_value);
+	cellGcmSys.trace("cellGcmSetFlipCommandWithWaitLabel(ctx=*0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)", ctx, id, label_index, label_value);
 
 	s32 res = cellGcmSetPrepareFlip(ppu, ctx, id);
 	vm::write32(gcm_info.label_addr + 0x10 * label_index, label_value);
@@ -1147,31 +1147,31 @@ s32 _cellGcmSetFlipCommandWithWaitLabel(PPUThread& ppu, vm::ptr<CellGcmContextDa
 
 s32 cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 comp, u16 base, u8 bank)
 {
-	cellGcmSys.Warning("cellGcmSetTile(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
+	cellGcmSys.warning("cellGcmSetTile(index=%d, location=%d, offset=%d, size=%d, pitch=%d, comp=%d, base=%d, bank=%d)",
 		index, location, offset, size, pitch, comp, base, bank);
 
 	// Copied form cellGcmSetTileInfo
 	if (index >= rsx::limits::tiles_count || base >= 2048 || bank >= 4)
 	{
-		cellGcmSys.Error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_VALUE");
+		cellGcmSys.error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_VALUE");
 		return CELL_GCM_ERROR_INVALID_VALUE;
 	}
 
 	if (offset & 0xffff || size & 0xffff || pitch & 0xf)
 	{
-		cellGcmSys.Error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_ALIGNMENT");
+		cellGcmSys.error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_ALIGNMENT");
 		return CELL_GCM_ERROR_INVALID_ALIGNMENT;
 	}
 
 	if (location >= 2 || (comp != 0 && (comp < 7 || comp > 12)))
 	{
-		cellGcmSys.Error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_ENUM");
+		cellGcmSys.error("cellGcmSetTile: CELL_GCM_ERROR_INVALID_ENUM");
 		return CELL_GCM_ERROR_INVALID_ENUM;
 	}
 
 	if (comp)
 	{
-		cellGcmSys.Error("cellGcmSetTile: bad compression mode! (%d)", comp);
+		cellGcmSys.error("cellGcmSetTile: bad compression mode! (%d)", comp);
 	}
 
 	auto& tile = Emu.GetGSManager().GetRender().tiles[index];
@@ -1272,7 +1272,7 @@ static bool isInCommandBufferExcept(u32 getPos, u32 bufferBegin, u32 bufferEnd)
 // TODO: Avoid using syscall 1023 for calling this function
 s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
 {
-	cellGcmSys.Log("cellGcmCallback(context=*0x%x, count=0x%x)", context, count);
+	cellGcmSys.trace("cellGcmCallback(context=*0x%x, count=0x%x)", context, count);
 
 	auto& ctrl = vm::_ref<CellGcmControl>(gcm_info.control_addr);
 	const std::chrono::time_point<std::chrono::system_clock> enterWait = std::chrono::system_clock::now();
@@ -1297,7 +1297,7 @@ s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
 		std::chrono::time_point<std::chrono::system_clock> waitPoint = std::chrono::system_clock::now();
 		long long elapsedTime = std::chrono::duration_cast<std::chrono::seconds>(waitPoint - enterWait).count();
 		if (elapsedTime > 0)
-			cellGcmSys.Error("Has wait for more than a second for command buffer to be released by RSX");
+			cellGcmSys.error("Has wait for more than a second for command buffer to be released by RSX");
 		std::this_thread::yield();
 	}
 

rpcs3/Emu/SysCalls/Modules/cellGem.cpp

@@ -50,7 +50,7 @@ s32 cellGemEnableMagnetometer()
 
 s32 cellGemEnd()
 {
-	cellGem.Warning("cellGemEnd()");
+	cellGem.warning("cellGemEnd()");
 
 	if (!fxm::remove<gem_t>())
 	{
@@ -116,7 +116,7 @@ s32 cellGemGetInertialState()
 
 s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
 {
-	cellGem.Todo("cellGemGetInfo(info=*0x%x)", info);
+	cellGem.todo("cellGemGetInfo(info=*0x%x)", info);
 
 	const auto gem = fxm::get<gem_t>();
 
@@ -139,7 +139,7 @@ s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
 
 s32 cellGemGetMemorySize(s32 max_connect)
 {
-	cellGem.Warning("cellGemGetMemorySize(max_connect=%d)", max_connect);
+	cellGem.warning("cellGemGetMemorySize(max_connect=%d)", max_connect);
 
 	if (max_connect > CELL_GEM_MAX_NUM || max_connect <= 0)
 	{
@@ -187,7 +187,7 @@ s32 cellGemHSVtoRGB()
 
 s32 cellGemInit(vm::cptr<CellGemAttribute> attribute)
 {
-	cellGem.Warning("cellGemInit(attribute=*0x%x)", attribute);
+	cellGem.warning("cellGemInit(attribute=*0x%x)", attribute);
 
 	const auto gem = fxm::make<gem_t>();
 

rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp

@@ -48,7 +48,7 @@ s32 cellGifDecExtCreate(PPMainHandle mainHandle, PThreadInParam threadInParam, P
 
 s32 cellGifDecOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, POpenInfo openInfo)
 {
-	cellGifDec.Warning("cellGifDecOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
+	cellGifDec.warning("cellGifDecOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
 
 	GifStream current_subHandle;
 	current_subHandle.fd = 0;
@@ -86,7 +86,7 @@ s32 cellGifDecExtOpen()
 
 s32 cellGifDecReadHeader(PMainHandle mainHandle, PSubHandle subHandle, PInfo info)
 {
-	cellGifDec.Warning("cellGifDecReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x)", mainHandle, subHandle, info);
+	cellGifDec.warning("cellGifDecReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x)", mainHandle, subHandle, info);
 
 	const u32& fd = subHandle->fd;
 	const u64& fileSize = subHandle->fileSize;
@@ -138,7 +138,7 @@ s32 cellGifDecExtReadHeader()
 
 s32 cellGifDecSetParameter(PMainHandle mainHandle, PSubHandle subHandle, PInParam inParam, POutParam outParam)
 {
-	cellGifDec.Warning("cellGifDecSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
+	cellGifDec.warning("cellGifDecSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
 
 	CellGifDecInfo& current_info = subHandle->info;
 	CellGifDecOutParam& current_outParam = subHandle->outParam;
@@ -168,7 +168,7 @@ s32 cellGifDecExtSetParameter()
 
 s32 cellGifDecDecodeData(PMainHandle mainHandle, PSubHandle subHandle, vm::ptr<u8> data, PDataCtrlParam dataCtrlParam, PDataOutInfo dataOutInfo)
 {
-	cellGifDec.Warning("cellGifDecDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
+	cellGifDec.warning("cellGifDecDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
 
 	dataOutInfo->status = CELL_GIFDEC_DEC_STATUS_STOP;
 
@@ -287,7 +287,7 @@ s32 cellGifDecExtDecodeData()
 
 s32 cellGifDecClose(PMainHandle mainHandle, PSubHandle subHandle)
 {
-	cellGifDec.Warning("cellGifDecClose(mainHandle=*0x%x, subHandle=*0x%x)", mainHandle, subHandle);
+	cellGifDec.warning("cellGifDecClose(mainHandle=*0x%x, subHandle=*0x%x)", mainHandle, subHandle);
 
 	idm::remove<lv2_file_t>(subHandle->fd);
 

rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp

@@ -37,7 +37,7 @@ s32 cellJpgDecDestroy(u32 mainHandle)
 
 s32 cellJpgDecOpen(u32 mainHandle, vm::ptr<u32> subHandle, vm::ptr<CellJpgDecSrc> src, vm::ptr<CellJpgDecOpnInfo> openInfo)
 {
-	cellJpgDec.Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=*0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
+	cellJpgDec.warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=*0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
 
 	CellJpgDecSubHandle current_subHandle;
 
@@ -75,7 +75,7 @@ s32 cellJpgDecExtOpen()
 
 s32 cellJpgDecClose(u32 mainHandle, u32 subHandle)
 {
-	cellJpgDec.Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=0x%x)", mainHandle, subHandle);
+	cellJpgDec.warning("cellJpgDecOpen(mainHandle=0x%x, subHandle=0x%x)", mainHandle, subHandle);
 
 	const auto subHandle_data = idm::get<CellJpgDecSubHandle>(subHandle);
 
@@ -92,7 +92,7 @@ s32 cellJpgDecClose(u32 mainHandle, u32 subHandle)
 
 s32 cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellJpgDecInfo> info)
 {
-	cellJpgDec.Log("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info=*0x%x)", mainHandle, subHandle, info);
+	cellJpgDec.trace("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info=*0x%x)", mainHandle, subHandle, info);
 
 	const auto subHandle_data = idm::get<CellJpgDecSubHandle>(subHandle);
 
@@ -169,7 +169,7 @@ s32 cellJpgDecExtReadHeader()
 
 s32 cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::cptr<CellJpgDecDataCtrlParam> dataCtrlParam, vm::ptr<CellJpgDecDataOutInfo> dataOutInfo)
 {
-	cellJpgDec.Log("cellJpgDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
+	cellJpgDec.trace("cellJpgDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)", mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
 
 	dataOutInfo->status = CELL_JPGDEC_DEC_STATUS_STOP;
 
@@ -288,7 +288,7 @@ s32 cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::cp
 	case CELL_JPG_UPSAMPLE_ONLY:
 	case CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA:
 	case CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB:
-		cellJpgDec.Error("cellJpgDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
+		cellJpgDec.error("cellJpgDecDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
 	break;
 
 	default:
@@ -310,7 +310,7 @@ s32 cellJpgDecExtDecodeData()
 
 s32 cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, vm::cptr<CellJpgDecInParam> inParam, vm::ptr<CellJpgDecOutParam> outParam)
 {
-	cellJpgDec.Log("cellJpgDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
+	cellJpgDec.trace("cellJpgDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
 
 	const auto subHandle_data = idm::get<CellJpgDecSubHandle>(subHandle);
 

rpcs3/Emu/SysCalls/Modules/cellKb.cpp

@@ -10,7 +10,7 @@ extern Module<> sys_io;
 
 s32 cellKbInit(u32 max_connect)
 {
-	sys_io.Warning("cellKbInit(max_connect=%d)", max_connect);
+	sys_io.warning("cellKbInit(max_connect=%d)", max_connect);
 
 	if (Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_ALREADY_INITIALIZED;
@@ -24,7 +24,7 @@ s32 cellKbInit(u32 max_connect)
 
 s32 cellKbEnd()
 {
-	sys_io.Log("cellKbEnd()");
+	sys_io.trace("cellKbEnd()");
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@@ -35,7 +35,7 @@ s32 cellKbEnd()
 
 s32 cellKbClearBuf(u32 port_no)
 {
-	sys_io.Log("cellKbClearBuf(port_no=%d)", port_no);
+	sys_io.trace("cellKbClearBuf(port_no=%d)", port_no);
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@@ -50,7 +50,7 @@ s32 cellKbClearBuf(u32 port_no)
 
 u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
 {
-	sys_io.Log("cellKbCnvRawCode(arrange=%d,mkey=%d,led=%d,rawcode=%d)", arrange, mkey, led, rawcode);
+	sys_io.trace("cellKbCnvRawCode(arrange=%d,mkey=%d,led=%d,rawcode=%d)", arrange, mkey, led, rawcode);
 
 	// CELL_KB_RAWDAT
 	if (rawcode <= 0x03 || rawcode == 0x29 || rawcode == 0x35 || (rawcode >= 0x39 && rawcode <= 0x53) || rawcode == 0x65 || rawcode == 0x88 || rawcode == 0x8A || rawcode == 0x8B)
@@ -96,7 +96,7 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
 
 s32 cellKbGetInfo(vm::ptr<CellKbInfo> info)
 {
-	sys_io.Log("cellKbGetInfo(info=*0x%x)", info);
+	sys_io.trace("cellKbGetInfo(info=*0x%x)", info);
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@@ -116,7 +116,7 @@ s32 cellKbGetInfo(vm::ptr<CellKbInfo> info)
 
 s32 cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
 {
-	sys_io.Log("cellKbRead(port_no=%d, data=*0x%x)", port_no, data);
+	sys_io.trace("cellKbRead(port_no=%d, data=*0x%x)", port_no, data);
 
 	const std::vector<Keyboard>& keyboards = Emu.GetKeyboardManager().GetKeyboards();
 	if (!Emu.GetKeyboardManager().IsInited())
@@ -142,7 +142,7 @@ s32 cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
 
 s32 cellKbSetCodeType(u32 port_no, u32 type)
 {
-	sys_io.Log("cellKbSetCodeType(port_no=%d,type=%d)", port_no, type);
+	sys_io.trace("cellKbSetCodeType(port_no=%d,type=%d)", port_no, type);
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@@ -160,7 +160,7 @@ s32 cellKbSetLEDStatus(u32 port_no, u8 led)
 
 s32 cellKbSetReadMode(u32 port_no, u32 rmode)
 {
-	sys_io.Log("cellKbSetReadMode(port_no=%d,rmode=%d)", port_no, rmode);
+	sys_io.trace("cellKbSetReadMode(port_no=%d,rmode=%d)", port_no, rmode);
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;
@@ -173,7 +173,7 @@ s32 cellKbSetReadMode(u32 port_no, u32 rmode)
 
 s32 cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config)
 {
-	sys_io.Log("cellKbGetConfiguration(port_no=%d, config=*0x%x)", port_no, config);
+	sys_io.trace("cellKbGetConfiguration(port_no=%d, config=*0x%x)", port_no, config);
 
 	if (!Emu.GetKeyboardManager().IsInited())
 		return CELL_KB_ERROR_UNINITIALIZED;

rpcs3/Emu/SysCalls/Modules/cellL10n.cpp

@@ -474,7 +474,7 @@ s32 ARIBstoUTF8s()
 
 s32 SJISstoUTF8s(vm::cptr<void> src, vm::cptr<s32> src_len, vm::ptr<void> dst, vm::ptr<s32> dst_len)
 {
-	cellL10n.Warning("SJISstoUTF8s(src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", src, src_len, dst, dst_len);
+	cellL10n.warning("SJISstoUTF8s(src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", src, src_len, dst, dst_len);
 	return _L10nConvertStr(L10N_CODEPAGE_932, src, src_len, L10N_UTF8, dst, dst_len);
 }
 
@@ -580,7 +580,7 @@ s32 EUCKRtoUHC()
 
 s32 UCS2toSJIS(u16 ch, vm::ptr<void> dst)
 {
-	cellL10n.Warning("UCS2toSJIS(ch=%d, dst=*0x%x)", ch, dst);
+	cellL10n.warning("UCS2toSJIS(ch=%d, dst=*0x%x)", ch, dst);
 	return _L10nConvertCharNoResult(L10N_UTF8, &ch, sizeof(ch), L10N_CODEPAGE_932, dst);
 }
 
@@ -721,7 +721,7 @@ s32 UTF8toUTF32()
 
 s32 jstrchk(vm::cptr<void> jstr)
 {
-	cellL10n.Warning("jstrchk(jstr=*0x%x) -> utf8", jstr);
+	cellL10n.warning("jstrchk(jstr=*0x%x) -> utf8", jstr);
 
 	return L10N_STR_UTF8;
 }
@@ -803,7 +803,7 @@ s32 UHCtoUCS2()
 
 s32 L10nConvertStr(s32 src_code, vm::cptr<void> src, vm::ptr<s32> src_len, s32 dst_code, vm::ptr<void> dst, vm::ptr<s32> dst_len)
 {
-	cellL10n.Error("L10nConvertStr(src_code=%d, src=*0x%x, src_len=*0x%x, dst_code=%d, dst=*0x%x, dst_len=*0x%x)", src_code, src, src_len, dst_code, dst, dst_len);
+	cellL10n.error("L10nConvertStr(src_code=%d, src=*0x%x, src_len=*0x%x, dst_code=%d, dst=*0x%x, dst_len=*0x%x)", src_code, src, src_len, dst_code, dst, dst_len);
 	return _L10nConvertStr(src_code, src, src_len, dst_code, dst, dst_len);
 }
 
@@ -889,7 +889,7 @@ s32 UTF16toUTF32()
 
 s32 l10n_convert_str(s32 cd, vm::cptr<void> src, vm::ptr<s32> src_len, vm::ptr<void> dst, vm::ptr<s32> dst_len)
 {
-	cellL10n.Warning("l10n_convert_str(cd=%d, src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", cd, src, src_len, dst, dst_len);
+	cellL10n.warning("l10n_convert_str(cd=%d, src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", cd, src, src_len, dst, dst_len);
 
 	s32 src_code = cd >> 16;
 	s32 dst_code = cd & 0xffff;
@@ -999,7 +999,7 @@ s32 MSJISstoUCS2s()
 
 s32 l10n_get_converter(u32 src_code, u32 dst_code)
 {
-	cellL10n.Warning("l10n_get_converter(src_code=%d, dst_code=%d)", src_code, dst_code);
+	cellL10n.warning("l10n_get_converter(src_code=%d, dst_code=%d)", src_code, dst_code);
 	return (src_code << 16) | dst_code;
 }
 
@@ -1060,7 +1060,7 @@ s32 UTF8toBIG5()
 
 s32 UTF16stoUTF8s(vm::cptr<u16> utf16, vm::ref<s32> utf16_len, vm::ptr<u8> utf8, vm::ref<s32> utf8_len)
 {
-	cellL10n.Error("UTF16stoUTF8s(utf16=*0x%x, utf16_len=*0x%x, utf8=*0x%x, utf8_len=*0x%x)", utf16, utf16_len, utf8, utf8_len);
+	cellL10n.error("UTF16stoUTF8s(utf16=*0x%x, utf16_len=*0x%x, utf8=*0x%x, utf8_len=*0x%x)", utf16, utf16_len, utf8, utf8_len);
 
 	const u32 max_len = utf8_len; utf8_len = 0;
 
@@ -1112,7 +1112,7 @@ s32 GB18030toUTF8()
 
 s32 UTF8toSJIS(u8 ch, vm::ptr<void> dst, vm::ptr<s32> dst_len)
 {
-	cellL10n.Warning("UTF8toSJIS(ch=%d, dst=*0x%x, dst_len=*0x%x)", ch, dst, dst_len);
+	cellL10n.warning("UTF8toSJIS(ch=%d, dst=*0x%x, dst_len=*0x%x)", ch, dst, dst_len);
 	return _L10nConvertChar(L10N_UTF8, &ch, sizeof(ch), L10N_CODEPAGE_932, dst, dst_len);
 }
 
@@ -1153,7 +1153,7 @@ s32 UTF8stoUTF16s()
 
 s32 SJISstoUCS2s(vm::cptr<void> src, vm::cptr<s32> src_len, vm::ptr<void> dst, vm::ptr<s32> dst_len)
 {
-	cellL10n.Warning("SJISstoUCS2s(src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", src, src_len, dst, dst_len);
+	cellL10n.warning("SJISstoUCS2s(src=*0x%x, src_len=*0x%x, dst=*0x%x, dst_len=*0x%x)", src, src_len, dst, dst_len);
 	return _L10nConvertStr(L10N_CODEPAGE_932, src, src_len, L10N_UCS2, dst, dst_len);
 }
 

rpcs3/Emu/SysCalls/Modules/cellMic.cpp

@@ -9,14 +9,14 @@ extern Module<> cellMic;
 
 s32 cellMicInit()
 {
-	cellMic.Warning("cellMicInit()");
+	cellMic.warning("cellMicInit()");
 
 	return CELL_OK;
 }
 
 s32 cellMicEnd()
 {
-	cellMic.Warning("cellMicEnd()");
+	cellMic.warning("cellMicEnd()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellMouse.cpp

@@ -10,7 +10,7 @@ extern Module<> sys_io;
 
 s32 cellMouseInit(u32 max_connect)
 {
-	sys_io.Warning("cellMouseInit(max_connect=%d)", max_connect);
+	sys_io.warning("cellMouseInit(max_connect=%d)", max_connect);
 
 	if (Emu.GetMouseManager().IsInited())
 	{
@@ -29,7 +29,7 @@ s32 cellMouseInit(u32 max_connect)
 
 s32 cellMouseClearBuf(u32 port_no)
 {
-	sys_io.Log("cellMouseClearBuf(port_no=%d)", port_no);
+	sys_io.trace("cellMouseClearBuf(port_no=%d)", port_no);
 
 	if (!Emu.GetMouseManager().IsInited())
 	{
@@ -48,7 +48,7 @@ s32 cellMouseClearBuf(u32 port_no)
 
 s32 cellMouseEnd()
 {
-	sys_io.Log("cellMouseEnd()");
+	sys_io.trace("cellMouseEnd()");
 
 	if (!Emu.GetMouseManager().IsInited())
 	{
@@ -61,7 +61,7 @@ s32 cellMouseEnd()
 
 s32 cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
 {
-	sys_io.Log("cellMouseGetInfo(info=*0x%x)", info);
+	sys_io.trace("cellMouseGetInfo(info=*0x%x)", info);
 
 	if (!Emu.GetMouseManager().IsInited())
 	{
@@ -81,7 +81,7 @@ s32 cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
 
 s32 cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
 {
-	sys_io.Log("cellMouseInfoTabletMode(port_no=%d, info=*0x%x)", port_no, info);
+	sys_io.trace("cellMouseInfoTabletMode(port_no=%d, info=*0x%x)", port_no, info);
 	if (!Emu.GetMouseManager().IsInited())
 	{
 		return CELL_MOUSE_ERROR_UNINITIALIZED;
@@ -100,7 +100,7 @@ s32 cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
 
 s32 cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data)
 {
-	sys_io.Log("cellMouseGetData(port_no=%d, data=*0x%x)", port_no, data);
+	sys_io.trace("cellMouseGetData(port_no=%d, data=*0x%x)", port_no, data);
 	if (!Emu.GetMouseManager().IsInited())
 	{
 		return CELL_MOUSE_ERROR_UNINITIALIZED;
@@ -149,7 +149,7 @@ s32 cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
 
 s32 cellMouseGetRawData(u32 port_no, vm::ptr<struct CellMouseRawData> data)
 {
-	sys_io.Todo("cellMouseGetRawData(port_no=%d, data=*0x%x)", port_no, data);
+	sys_io.todo("cellMouseGetRawData(port_no=%d, data=*0x%x)", port_no, data);
 	/*if (!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if (port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_NO_DEVICE;
 

rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp

@@ -17,7 +17,7 @@ s32 cellMsgDialogOpen()
 
 s32 cellMsgDialogOpen2(u32 type, vm::cptr<char> msgString, vm::ptr<CellMsgDialogCallback> callback, vm::ptr<void> userData, vm::ptr<void> extParam)
 {
-	cellSysutil.Warning("cellMsgDialogOpen2(type=0x%x, msgString=*0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", type, msgString, callback, userData, extParam);
+	cellSysutil.warning("cellMsgDialogOpen2(type=0x%x, msgString=*0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", type, msgString, callback, userData, extParam);
 
 	if (!msgString || std::strlen(msgString.get_ptr()) >= 0x200 || type & -0x33f8)
 	{
@@ -75,11 +75,11 @@ s32 cellMsgDialogOpen2(u32 type, vm::cptr<char> msgString, vm::ptr<CellMsgDialog
 
 	if (_type.se_normal)
 	{
-		cellSysutil.Warning(msgString.get_ptr());
+		cellSysutil.warning(msgString.get_ptr());
 	}
 	else
 	{
-		cellSysutil.Error(msgString.get_ptr());
+		cellSysutil.error(msgString.get_ptr());
 	}
 
 	dlg->type = _type;
@@ -111,7 +111,7 @@ s32 cellMsgDialogOpen2(u32 type, vm::cptr<char> msgString, vm::ptr<CellMsgDialog
 
 s32 cellMsgDialogOpenErrorCode(PPUThread& ppu, u32 errorCode, vm::ptr<CellMsgDialogCallback> callback, vm::ptr<void> userData, vm::ptr<void> extParam)
 {
-	cellSysutil.Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", errorCode, callback, userData, extParam);
+	cellSysutil.warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback=*0x%x, userData=*0x%x, extParam=*0x%x)", errorCode, callback, userData, extParam);
 
 	std::string error;
 
@@ -193,7 +193,7 @@ s32 cellMsgDialogOpenSimulViewWarning()
 
 s32 cellMsgDialogClose(f32 delay)
 {
-	cellSysutil.Warning("cellMsgDialogClose(delay=%f)", delay);
+	cellSysutil.warning("cellMsgDialogClose(delay=%f)", delay);
 
 	const auto dlg = fxm::get<MsgDialogBase>();
 
@@ -223,7 +223,7 @@ s32 cellMsgDialogClose(f32 delay)
 
 s32 cellMsgDialogAbort()
 {
-	cellSysutil.Warning("cellMsgDialogAbort()");
+	cellSysutil.warning("cellMsgDialogAbort()");
 
 	const auto dlg = fxm::get<MsgDialogBase>();
 
@@ -247,7 +247,7 @@ s32 cellMsgDialogAbort()
 
 s32 cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::cptr<char> msgString)
 {
-	cellSysutil.Warning("cellMsgDialogProgressBarSetMsg(progressBarIndex=%d, msgString=*0x%x)", progressBarIndex, msgString);
+	cellSysutil.warning("cellMsgDialogProgressBarSetMsg(progressBarIndex=%d, msgString=*0x%x)", progressBarIndex, msgString);
 
 	const auto dlg = fxm::get<MsgDialogBase>();
 
@@ -271,7 +271,7 @@ s32 cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::cptr<char> msgStrin
 
 s32 cellMsgDialogProgressBarReset(u32 progressBarIndex)
 {
-	cellSysutil.Warning("cellMsgDialogProgressBarReset(progressBarIndex=%d)", progressBarIndex);
+	cellSysutil.warning("cellMsgDialogProgressBarReset(progressBarIndex=%d)", progressBarIndex);
 
 	const auto dlg = fxm::get<MsgDialogBase>();
 
@@ -292,7 +292,7 @@ s32 cellMsgDialogProgressBarReset(u32 progressBarIndex)
 
 s32 cellMsgDialogProgressBarInc(u32 progressBarIndex, u32 delta)
 {
-	cellSysutil.Warning("cellMsgDialogProgressBarInc(progressBarIndex=%d, delta=%d)", progressBarIndex, delta);
+	cellSysutil.warning("cellMsgDialogProgressBarInc(progressBarIndex=%d, delta=%d)", progressBarIndex, delta);
 
 	const auto dlg = fxm::get<MsgDialogBase>();
 

rpcs3/Emu/SysCalls/Modules/cellMusic.cpp

@@ -112,11 +112,11 @@ s32 cellMusicSelectContents()
 
 s32 cellMusicInitialize2(s32 mode, s32 spuPriority, vm::ptr<CellMusic2Callback> func, vm::ptr<void> userData)
 {
-	cellMusic.Todo("cellMusicInitialize2(mode=%d, spuPriority=%d, func=*0x%x, userData=*0x%x)", mode, spuPriority, func, userData);
+	cellMusic.todo("cellMusicInitialize2(mode=%d, spuPriority=%d, func=*0x%x, userData=*0x%x)", mode, spuPriority, func, userData);
 
 	if (mode != CELL_MUSIC2_PLAYER_MODE_NORMAL)
 	{
-		cellMusic.Todo("Unknown player mode: 0x%x", mode);
+		cellMusic.todo("Unknown player mode: 0x%x", mode);
 		return CELL_MUSIC2_ERROR_PARAM;
 	}
 

rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp

@@ -31,21 +31,21 @@ extern Module<> cellNetCtl;
 
 s32 cellNetCtlInit()
 {
-	cellNetCtl.Warning("cellNetCtlInit()");
+	cellNetCtl.warning("cellNetCtlInit()");
 
 	return CELL_OK;
 }
 
 s32 cellNetCtlTerm()
 {
-	cellNetCtl.Warning("cellNetCtlTerm()");
+	cellNetCtl.warning("cellNetCtlTerm()");
 
 	return CELL_OK;
 }
 
 s32 cellNetCtlGetState(vm::ptr<u32> state)
 {
-	cellNetCtl.Log("cellNetCtlGetState(state=*0x%x)", state);
+	cellNetCtl.trace("cellNetCtlGetState(state=*0x%x)", state);
 
 	switch (rpcs3::config.misc.net.status.value())
 	{
@@ -62,21 +62,21 @@ s32 cellNetCtlGetState(vm::ptr<u32> state)
 
 s32 cellNetCtlAddHandler(vm::ptr<cellNetCtlHandler> handler, vm::ptr<void> arg, vm::ptr<s32> hid)
 {
-	cellNetCtl.Todo("cellNetCtlAddHandler(handler=*0x%x, arg=*0x%x, hid=*0x%x)", handler, arg, hid);
+	cellNetCtl.todo("cellNetCtlAddHandler(handler=*0x%x, arg=*0x%x, hid=*0x%x)", handler, arg, hid);
 
 	return CELL_OK;
 }
 
 s32 cellNetCtlDelHandler(s32 hid)
 {
-	cellNetCtl.Todo("cellNetCtlDelHandler(hid=0x%x)", hid);
+	cellNetCtl.todo("cellNetCtlDelHandler(hid=0x%x)", hid);
 
 	return CELL_OK;
 }
 
 s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 {
-	cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x (%s), info=*0x%x)", code, InfoCodeToName(code), info);
+	cellNetCtl.todo("cellNetCtlGetInfo(code=0x%x (%s), info=*0x%x)", code, InfoCodeToName(code), info);
 
 	if (code == CELL_NET_CTL_INFO_MTU)
 	{
@@ -89,13 +89,13 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 		if (ret == ERROR_BUFFER_OVERFLOW)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): GetAdaptersAddresses buffer overflow.");
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_MTU): GetAdaptersAddresses buffer overflow.");
 			free(pAddresses);
 			pAddresses = (PIP_ADAPTER_ADDRESSES)malloc(bufLen);
 
 			if (pAddresses == nullptr)
 			{
-				cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Unable to allocate memory for pAddresses.");
+				cellNetCtl.error("cellNetCtlGetInfo(INFO_MTU): Unable to allocate memory for pAddresses.");
 				return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
 			}
 		}
@@ -115,7 +115,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 		}
 		else
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to GetAdaptersAddresses failed. (%d)", ret);
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_MTU): Call to GetAdaptersAddresses failed. (%d)", ret);
 			info->mtu = 1500; // Seems to be the default value on Windows 10.
 		}
 
@@ -126,7 +126,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 		if (getifaddrs(&ifaddr) == -1)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to getifaddrs returned negative.");
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_MTU): Call to getifaddrs returned negative.");
 		}
 
 		for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
@@ -150,7 +150,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 				if (ioctl(fd, SIOCGIFMTU, &freq) == -1)
 				{
-					cellNetCtl.Error("cellNetCtlGetInfo(INFO_MTU): Call to ioctl failed.");
+					cellNetCtl.error("cellNetCtlGetInfo(INFO_MTU): Call to ioctl failed.");
 				}
 				else
 				{
@@ -189,13 +189,13 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 		
 		if (ret == ERROR_BUFFER_OVERFLOW)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): GetAdaptersInfo buffer overflow.");
+			cellNetCtl.error("cellNetCtlGetInfo(IP_ADDRESS): GetAdaptersInfo buffer overflow.");
 			free(pAdapterInfo);
 			pAdapterInfo = (IP_ADAPTER_INFO*)malloc(bufLen);
 
 			if (pAdapterInfo == nullptr)
 			{
-				cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Unable to allocate memory for pAddresses.");
+				cellNetCtl.error("cellNetCtlGetInfo(IP_ADDRESS): Unable to allocate memory for pAddresses.");
 				return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
 			}
 		}
@@ -215,7 +215,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 		}
 		else
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Call to GetAdaptersInfo failed. (%d)", ret);
+			cellNetCtl.error("cellNetCtlGetInfo(IP_ADDRESS): Call to GetAdaptersInfo failed. (%d)", ret);
 		}
 
 		free(pAdapterInfo);
@@ -225,7 +225,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 		if (getifaddrs(&ifaddr) == -1)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(IP_ADDRESS): Call to getifaddrs returned negative.");
+			cellNetCtl.error("cellNetCtlGetInfo(IP_ADDRESS): Call to getifaddrs returned negative.");
 		}
 
 		for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
@@ -262,13 +262,13 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 		if (ret == ERROR_BUFFER_OVERFLOW)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): GetAdaptersInfo buffer overflow.");
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_NETMASK): GetAdaptersInfo buffer overflow.");
 			free(pAdapterInfo);
 			pAdapterInfo = (IP_ADAPTER_INFO*)malloc(bufLen);
 
 			if (pAdapterInfo == nullptr)
 			{
-				cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Unable to allocate memory for pAddresses.");
+				cellNetCtl.error("cellNetCtlGetInfo(INFO_NETMASK): Unable to allocate memory for pAddresses.");
 				return CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED;
 			}
 		}
@@ -291,7 +291,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 		}
 		else
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Call to GetAdaptersInfo failed. (%d)", ret);
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_NETMASK): Call to GetAdaptersInfo failed. (%d)", ret);
 			// TODO: Is this the default netmask?
 			info->netmask[0] = 255;
 			info->netmask[1] = 255;
@@ -306,7 +306,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 		if (getifaddrs(&ifaddr) == -1)
 		{
-			cellNetCtl.Error("cellNetCtlGetInfo(INFO_NETMASK): Call to getifaddrs returned negative.");
+			cellNetCtl.error("cellNetCtlGetInfo(INFO_NETMASK): Call to getifaddrs returned negative.");
 		}
 
 		for (ifa = ifaddr, n = 0; ifa != nullptr; ifa = ifa->ifa_next, n++)
@@ -338,7 +338,7 @@ s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 
 s32 cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
 {
-	cellNetCtl.Error("cellNetCtlNetStartDialogLoadAsync(param=*0x%x)", param);
+	cellNetCtl.error("cellNetCtlNetStartDialogLoadAsync(param=*0x%x)", param);
 
 	// TODO: Actually sign into PSN or an emulated network similar to PSN (ESN)
 	// TODO: Properly open the dialog prompt for sign in
@@ -350,14 +350,14 @@ s32 cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> par
 
 s32 cellNetCtlNetStartDialogAbortAsync()
 {
-	cellNetCtl.Error("cellNetCtlNetStartDialogAbortAsync()");
+	cellNetCtl.error("cellNetCtlNetStartDialogAbortAsync()");
 
 	return CELL_OK;
 }
 
 s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
 {
-	cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result=*0x%x)", result);
+	cellNetCtl.warning("cellNetCtlNetStartDialogUnloadAsync(result=*0x%x)", result);
 
 	result->result = CELL_NET_CTL_ERROR_DIALOG_CANCELED;
 	sysutilSendSystemCommand(CELL_SYSUTIL_NET_CTL_NETSTART_UNLOADED, 0);
@@ -367,11 +367,11 @@ s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult>
 
 s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
 {
-	cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo=*0x%x)", natInfo);
+	cellNetCtl.todo("cellNetCtlGetNatInfo(natInfo=*0x%x)", natInfo);
 
 	if (natInfo->size == 0)
 	{
-		cellNetCtl.Error("cellNetCtlGetNatInfo : CELL_NET_CTL_ERROR_INVALID_SIZE");
+		cellNetCtl.error("cellNetCtlGetNatInfo : CELL_NET_CTL_ERROR_INVALID_SIZE");
 		return CELL_NET_CTL_ERROR_INVALID_SIZE;
 	}
 	

rpcs3/Emu/SysCalls/Modules/cellOvis.cpp

@@ -16,7 +16,7 @@ enum
 
 s32 cellOvisGetOverlayTableSize(vm::cptr<char> elf)
 {
-	cellOvis.Todo("cellOvisGetOverlayTableSize(elf=*0x%x)", elf);
+	cellOvis.todo("cellOvisGetOverlayTableSize(elf=*0x%x)", elf);
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/cellPad.cpp

@@ -10,7 +10,7 @@ extern Module<> sys_io;
 
 s32 cellPadInit(u32 max_connect)
 {
-	sys_io.Warning("cellPadInit(max_connect=%d)", max_connect);
+	sys_io.warning("cellPadInit(max_connect=%d)", max_connect);
 
 	if (Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_ALREADY_INITIALIZED;
@@ -25,7 +25,7 @@ s32 cellPadInit(u32 max_connect)
 
 s32 cellPadEnd()
 {
-	sys_io.Log("cellPadEnd()");
+	sys_io.trace("cellPadEnd()");
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -37,7 +37,7 @@ s32 cellPadEnd()
 
 s32 cellPadClearBuf(u32 port_no)
 {
-	sys_io.Log("cellPadClearBuf(port_no=%d)", port_no);
+	sys_io.trace("cellPadClearBuf(port_no=%d)", port_no);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -72,7 +72,7 @@ s32 cellPadClearBuf(u32 port_no)
 
 s32 cellPadPeriphGetInfo(vm::ptr<CellPadPeriphInfo> info)
 {
-	sys_io.Todo("cellPadPeriphGetInfo(info=*0x%x)", info);
+	sys_io.todo("cellPadPeriphGetInfo(info=*0x%x)", info);
 
 	if (!Emu.GetPadManager().IsInited())
 	{
@@ -111,7 +111,7 @@ s32 cellPadPeriphGetData()
 
 s32 cellPadGetData(u32 port_no, vm::ptr<CellPadData> data)
 {
-	sys_io.Log("cellPadGetData(port_no=%d, data=*0x%x)", port_no, data);
+	sys_io.trace("cellPadGetData(port_no=%d, data=*0x%x)", port_no, data);
 
 	std::vector<Pad>& pads = Emu.GetPadManager().GetPads();
 
@@ -295,7 +295,7 @@ s32 cellPadGetRawData(u32 port_no, vm::ptr<CellPadData> data)
 
 s32 cellPadGetDataExtra(u32 port_no, vm::ptr<u32> device_type, vm::ptr<CellPadData> data)
 {
-	sys_io.Log("cellPadGetDataExtra(port_no=%d, device_type=*0x%x, device_type=*0x%x)", port_no, device_type, data);
+	sys_io.trace("cellPadGetDataExtra(port_no=%d, device_type=*0x%x, device_type=*0x%x)", port_no, device_type, data);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -312,7 +312,7 @@ s32 cellPadGetDataExtra(u32 port_no, vm::ptr<u32> device_type, vm::ptr<CellPadDa
 
 s32 cellPadSetActDirect(u32 port_no, vm::ptr<struct CellPadActParam> param)
 {
-	sys_io.Log("cellPadSetActDirect(port_no=%d, param=*0x%x)", port_no, param);
+	sys_io.trace("cellPadSetActDirect(port_no=%d, param=*0x%x)", port_no, param);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -329,7 +329,7 @@ s32 cellPadSetActDirect(u32 port_no, vm::ptr<struct CellPadActParam> param)
 
 s32 cellPadGetInfo(vm::ptr<CellPadInfo> info)
 {
-	sys_io.Log("cellPadGetInfo(info=*0x%x)", info);
+	sys_io.trace("cellPadGetInfo(info=*0x%x)", info);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -358,7 +358,7 @@ s32 cellPadGetInfo(vm::ptr<CellPadInfo> info)
 
 s32 cellPadGetInfo2(vm::ptr<CellPadInfo2> info)
 {
-	sys_io.Log("cellPadGetInfo2(info=*0x%x)", info);
+	sys_io.trace("cellPadGetInfo2(info=*0x%x)", info);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -387,7 +387,7 @@ s32 cellPadGetInfo2(vm::ptr<CellPadInfo2> info)
 
 s32 cellPadGetCapabilityInfo(u32 port_no, vm::ptr<CellCapabilityInfo> info)
 {
-	sys_io.Log("cellPadGetCapabilityInfo(port_no=%d, data_addr:=0x%x)", port_no, info.addr());
+	sys_io.trace("cellPadGetCapabilityInfo(port_no=%d, data_addr:=0x%x)", port_no, info.addr());
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -409,7 +409,7 @@ s32 cellPadGetCapabilityInfo(u32 port_no, vm::ptr<CellCapabilityInfo> info)
 
 s32 cellPadSetPortSetting(u32 port_no, u32 port_setting)
 {
-	sys_io.Log("cellPadSetPortSetting(port_no=%d, port_setting=0x%x)", port_no, port_setting);
+	sys_io.trace("cellPadSetPortSetting(port_no=%d, port_setting=0x%x)", port_no, port_setting);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -429,7 +429,7 @@ s32 cellPadSetPortSetting(u32 port_no, u32 port_setting)
 
 s32 cellPadInfoPressMode(u32 port_no)
 {
-	sys_io.Log("cellPadInfoPressMode(port_no=%d)", port_no);
+	sys_io.trace("cellPadInfoPressMode(port_no=%d)", port_no);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -448,7 +448,7 @@ s32 cellPadInfoPressMode(u32 port_no)
 
 s32 cellPadInfoSensorMode(u32 port_no)
 {
-	sys_io.Log("cellPadInfoSensorMode(port_no=%d)", port_no);
+	sys_io.trace("cellPadInfoSensorMode(port_no=%d)", port_no);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -467,7 +467,7 @@ s32 cellPadInfoSensorMode(u32 port_no)
 
 s32 cellPadSetPressMode(u32 port_no, u32 mode)
 {
-	sys_io.Log("cellPadSetPressMode(port_no=%d, mode=%d)", port_no, mode);
+	sys_io.trace("cellPadSetPressMode(port_no=%d, mode=%d)", port_no, mode);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -493,7 +493,7 @@ s32 cellPadSetPressMode(u32 port_no, u32 mode)
 
 s32 cellPadSetSensorMode(u32 port_no, u32 mode)
 {
-	sys_io.Log("cellPadSetSensorMode(port_no=%d, mode=%d)", port_no, mode);
+	sys_io.trace("cellPadSetSensorMode(port_no=%d, mode=%d)", port_no, mode);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -519,7 +519,7 @@ s32 cellPadSetSensorMode(u32 port_no, u32 mode)
 
 s32 cellPadLddRegisterController()
 {
-	sys_io.Todo("cellPadLddRegisterController()");
+	sys_io.todo("cellPadLddRegisterController()");
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -529,7 +529,7 @@ s32 cellPadLddRegisterController()
 
 s32 cellPadLddDataInsert(s32 handle, vm::ptr<CellPadData> data)
 {
-	sys_io.Todo("cellPadLddDataInsert(handle=%d, data=*0x%x)", handle, data);
+	sys_io.todo("cellPadLddDataInsert(handle=%d, data=*0x%x)", handle, data);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -539,7 +539,7 @@ s32 cellPadLddDataInsert(s32 handle, vm::ptr<CellPadData> data)
 
 s32 cellPadLddGetPortNo(s32 handle)
 {
-	sys_io.Todo("cellPadLddGetPortNo(handle=%d)", handle);
+	sys_io.todo("cellPadLddGetPortNo(handle=%d)", handle);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;
@@ -549,7 +549,7 @@ s32 cellPadLddGetPortNo(s32 handle)
 
 s32 cellPadLddUnregisterController(s32 handle)
 {
-	sys_io.Todo("cellPadLddUnregisterController(handle=%d)", handle);
+	sys_io.todo("cellPadLddUnregisterController(handle=%d)", handle);
 
 	if (!Emu.GetPadManager().IsInited())
 		return CELL_PAD_ERROR_UNINITIALIZED;

rpcs3/Emu/SysCalls/Modules/cellPamf.cpp

@@ -98,7 +98,7 @@ s32 pamfStreamTypeToEsFilterId(u8 type, u8 ch, CellCodecEsFilterId& pEsFilterId)
 		
 	default:
 	{
-		cellPamf.Error("pamfStreamTypeToEsFilterId(): unknown type (%d, ch=%d)", type, ch);
+		cellPamf.error("pamfStreamTypeToEsFilterId(): unknown type (%d, ch=%d)", type, ch);
 		Emu.Pause();
 		return CELL_PAMF_ERROR_INVALID_ARG;
 	}
@@ -123,7 +123,7 @@ u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u32 stream)
 	case 0xdd: return CELL_PAMF_STREAM_TYPE_USER_DATA;
 	}
 
-	cellPamf.Todo("pamfGetStreamType(): unsupported stream type found(0x%x)", header.type);
+	cellPamf.todo("pamfGetStreamType(): unsupported stream type found(0x%x)", header.type);
 	Emu.Pause();
 	return 0xff;
 }
@@ -166,14 +166,14 @@ u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u32 stream)
 	}
 	}
 
-	cellPamf.Todo("pamfGetStreamChannel(): unsupported stream type found(0x%x)", header.type);
+	cellPamf.todo("pamfGetStreamChannel(): unsupported stream type found(0x%x)", header.type);
 	Emu.Pause();
 	return 0xff;
 }
 
 s32 cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetHeaderSize(pAddr=*0x%x, fileSize=0x%llx, pSize=*0x%x)", pAddr, fileSize, pSize);
+	cellPamf.warning("cellPamfGetHeaderSize(pAddr=*0x%x, fileSize=0x%llx, pSize=*0x%x)", pAddr, fileSize, pSize);
 
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
@@ -184,7 +184,7 @@ s32 cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64>
 
 s32 cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribute, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetHeaderSize2(pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x, pSize=*0x%x)", pAddr, fileSize, attribute, pSize);
+	cellPamf.warning("cellPamfGetHeaderSize2(pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x, pSize=*0x%x)", pAddr, fileSize, attribute, pSize);
 
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
@@ -195,7 +195,7 @@ s32 cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribut
 
 s32 cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<u64> pOffset, vm::ptr<u64> pSize)
 {
-	cellPamf.Warning("cellPamfGetStreamOffsetAndSize(pAddr=*0x%x, fileSize=0x%llx, pOffset=*0x%x, pSize=*0x%x)", pAddr, fileSize, pOffset, pSize);
+	cellPamf.warning("cellPamfGetStreamOffsetAndSize(pAddr=*0x%x, fileSize=0x%llx, pOffset=*0x%x, pSize=*0x%x)", pAddr, fileSize, pOffset, pSize);
 
 	//if ((u32)pAddr->magic != 0x464d4150) return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
@@ -208,7 +208,7 @@ s32 cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::
 
 s32 cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 {
-	cellPamf.Todo("cellPamfVerify(pAddr=*0x%x, fileSize=0x%llx)", pAddr, fileSize);
+	cellPamf.todo("cellPamfVerify(pAddr=*0x%x, fileSize=0x%llx)", pAddr, fileSize);
 
 	// TODO
 	return CELL_OK;
@@ -216,7 +216,7 @@ s32 cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 
 s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute)
 {
-	cellPamf.Warning("cellPamfReaderInitialize(pSelf=*0x%x, pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x)", pSelf, pAddr, fileSize, attribute);
+	cellPamf.warning("cellPamfReaderInitialize(pSelf=*0x%x, pAddr=*0x%x, fileSize=0x%llx, attribute=0x%x)", pSelf, pAddr, fileSize, attribute);
 	
 	if (fileSize)
 	{
@@ -231,7 +231,7 @@ s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader>
 	if (attribute & CELL_PAMF_ATTRIBUTE_VERIFY_ON)
 	{
 		// TODO
-		cellPamf.Todo("cellPamfReaderInitialize(): verification");
+		cellPamf.todo("cellPamfReaderInitialize(): verification");
 	}
 
 	pSelf->stream = 0; // currently set stream
@@ -240,7 +240,7 @@ s32 cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader>
 
 s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf.Warning("cellPamfReaderGetPresentationStartTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
+	cellPamf.warning("cellPamfReaderGetPresentationStartTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
 
 	// always returns CELL_OK
 
@@ -251,7 +251,7 @@ s32 cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::pt
 
 s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf.Warning("cellPamfReaderGetPresentationEndTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
+	cellPamf.warning("cellPamfReaderGetPresentationEndTime(pSelf=*0x%x, pTimeStamp=*0x%x)", pSelf, pTimeStamp);
 
 	// always returns CELL_OK
 
@@ -262,7 +262,7 @@ s32 cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<
 
 u32 cellPamfReaderGetMuxRateBound(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Warning("cellPamfReaderGetMuxRateBound(pSelf=*0x%x)", pSelf);
+	cellPamf.warning("cellPamfReaderGetMuxRateBound(pSelf=*0x%x)", pSelf);
 
 	// cannot return error code
 	return pSelf->pAddr->mux_rate_max;
@@ -270,7 +270,7 @@ u32 cellPamfReaderGetMuxRateBound(vm::ptr<CellPamfReader> pSelf)
 
 u8 cellPamfReaderGetNumberOfStreams(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Warning("cellPamfReaderGetNumberOfStreams(pSelf=*0x%x)", pSelf);
+	cellPamf.warning("cellPamfReaderGetNumberOfStreams(pSelf=*0x%x)", pSelf);
 
 	// cannot return error code
 	return pSelf->pAddr->stream_count;
@@ -278,7 +278,7 @@ u8 cellPamfReaderGetNumberOfStreams(vm::ptr<CellPamfReader> pSelf)
 
 u8 cellPamfReaderGetNumberOfSpecificStreams(vm::ptr<CellPamfReader> pSelf, u8 streamType)
 {
-	cellPamf.Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=*0x%x, streamType=%d)", pSelf, streamType);
+	cellPamf.warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=*0x%x, streamType=%d)", pSelf, streamType);
 	
 	// cannot return error code
 
@@ -312,14 +312,14 @@ u8 cellPamfReaderGetNumberOfSpecificStreams(vm::ptr<CellPamfReader> pSelf, u8 st
 	}
 	}
 
-	cellPamf.Todo("cellPamfReaderGetNumberOfSpecificStreams(): unsupported stream type (0x%x)", streamType);
+	cellPamf.todo("cellPamfReaderGetNumberOfSpecificStreams(): unsupported stream type (0x%x)", streamType);
 	Emu.Pause();
 	return 0;
 }
 
 s32 cellPamfReaderSetStreamWithIndex(vm::ptr<CellPamfReader> pSelf, u8 streamIndex)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithIndex(pSelf=*0x%x, streamIndex=%d)", pSelf, streamIndex);
+	cellPamf.warning("cellPamfReaderSetStreamWithIndex(pSelf=*0x%x, streamIndex=%d)", pSelf, streamIndex);
 
 	if (streamIndex >= pSelf->pAddr->stream_count)
 	{
@@ -332,12 +332,12 @@ s32 cellPamfReaderSetStreamWithIndex(vm::ptr<CellPamfReader> pSelf, u8 streamInd
 
 s32 cellPamfReaderSetStreamWithTypeAndChannel(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 ch)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=*0x%x, streamType=%d, ch=%d)", pSelf, streamType, ch);
+	cellPamf.warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=*0x%x, streamType=%d, ch=%d)", pSelf, streamType, ch);
 
 	// it probably doesn't support "any audio" or "any video" argument
 	if (streamType > 5 || ch >= 16)
 	{
-		cellPamf.Error("cellPamfReaderSetStreamWithTypeAndChannel(): invalid arguments (streamType=%d, ch=%d)", streamType, ch);
+		cellPamf.error("cellPamfReaderSetStreamWithTypeAndChannel(): invalid arguments (streamType=%d, ch=%d)", streamType, ch);
 		Emu.Pause();
 		return CELL_PAMF_ERROR_INVALID_ARG;
 	}
@@ -359,7 +359,7 @@ s32 cellPamfReaderSetStreamWithTypeAndChannel(vm::ptr<CellPamfReader> pSelf, u8
 
 s32 cellPamfReaderSetStreamWithTypeAndIndex(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 streamIndex)
 {
-	cellPamf.Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=*0x%x, streamType=%d, streamIndex=%d)", pSelf, streamType, streamIndex);
+	cellPamf.warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=*0x%x, streamType=%d, streamIndex=%d)", pSelf, streamType, streamIndex);
 
 	u32 found = 0;
 
@@ -412,7 +412,7 @@ s32 cellPamfReaderSetStreamWithTypeAndIndex(vm::ptr<CellPamfReader> pSelf, u8 st
 
 s32 cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf.Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId=*0x%x)", type, ch, pEsFilterId);
+	cellPamf.warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId=*0x%x)", type, ch, pEsFilterId);
 
 	if (!pEsFilterId)
 	{
@@ -424,7 +424,7 @@ s32 cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId>
 
 s32 cellPamfReaderGetStreamIndex(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Log("cellPamfReaderGetStreamIndex(pSelf=*0x%x)", pSelf);
+	cellPamf.trace("cellPamfReaderGetStreamIndex(pSelf=*0x%x)", pSelf);
 
 	// seems that CELL_PAMF_ERROR_INVALID_PAMF must be already written in pSelf->stream if it's the case
 	return pSelf->stream;
@@ -432,7 +432,7 @@ s32 cellPamfReaderGetStreamIndex(vm::ptr<CellPamfReader> pSelf)
 
 s32 cellPamfReaderGetStreamTypeAndChannel(vm::ptr<CellPamfReader> pSelf, vm::ptr<u8> pType, vm::ptr<u8> pCh)
 {
-	cellPamf.Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=*0x%x, pType=*0x%x, pCh=*0x%x", pSelf, pType, pCh);
+	cellPamf.warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=*0x%x, pType=*0x%x, pCh=*0x%x", pSelf, pType, pCh);
 
 	// unclear
 
@@ -443,7 +443,7 @@ s32 cellPamfReaderGetStreamTypeAndChannel(vm::ptr<CellPamfReader> pSelf, vm::ptr
 
 s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf.Warning("cellPamfReaderGetEsFilterId(pSelf=*0x%x, pEsFilterId=*0x%x)", pSelf, pEsFilterId);
+	cellPamf.warning("cellPamfReaderGetEsFilterId(pSelf=*0x%x, pEsFilterId=*0x%x)", pSelf, pEsFilterId);
 
 	// always returns CELL_OK
 
@@ -458,7 +458,7 @@ s32 cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodec
 
 s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pInfo, u32 size)
 {
-	cellPamf.Warning("cellPamfReaderGetStreamInfo(pSelf=*0x%x, pInfo=*0x%x, size=%d)", pSelf, pInfo, size);
+	cellPamf.warning("cellPamfReaderGetStreamInfo(pSelf=*0x%x, pInfo=*0x%x, size=%d)", pSelf, pInfo, size);
 
 	assert((u32)pSelf->stream < (u32)pSelf->pAddr->stream_count);
 	auto& header = pSelf->pAddr->stream_headers[pSelf->stream];
@@ -524,7 +524,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 		info->nfwIdc = header.AVC.x18 & 0x03;
 		info->maxMeanBitrate = header.AVC.maxMeanBitrate;
 
-		cellPamf.Notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_AVC");
+		cellPamf.notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_AVC");
 		break;
 	}
 		
@@ -582,7 +582,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 			info->matrixCoefficients = 0;
 		}
 
-		cellPamf.Notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_M2V");
+		cellPamf.notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_M2V");
 		break;
 	}
 		
@@ -598,7 +598,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 		info->samplingFrequency = header.audio.freq & 0xf;
 		info->numberOfChannels = header.audio.channels & 0xf;
 
-		cellPamf.Notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_ATRAC3PLUS");
+		cellPamf.notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_ATRAC3PLUS");
 		break;
 	}
 
@@ -615,7 +615,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 		info->numberOfChannels = header.audio.channels & 0xf;
 		info->bitsPerSample = header.audio.bps >> 6;
 
-		cellPamf.Notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_PAMF_LPCM");
+		cellPamf.notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_PAMF_LPCM");
 		break;
 	}
 
@@ -631,13 +631,13 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 		info->samplingFrequency = header.audio.freq & 0xf;
 		info->numberOfChannels = header.audio.channels & 0xf;
 
-		cellPamf.Notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_AC3");
+		cellPamf.notice("cellPamfReaderGetStreamInfo(): CELL_PAMF_STREAM_TYPE_AC3");
 		break;
 	}
 
 	case CELL_PAMF_STREAM_TYPE_USER_DATA:
 	{
-		cellPamf.Error("cellPamfReaderGetStreamInfo(): invalid type CELL_PAMF_STREAM_TYPE_USER_DATA");
+		cellPamf.error("cellPamfReaderGetStreamInfo(): invalid type CELL_PAMF_STREAM_TYPE_USER_DATA");
 		return CELL_PAMF_ERROR_INVALID_ARG;
 	}
 
@@ -648,7 +648,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
 
-		cellPamf.Todo("cellPamfReaderGetStreamInfo(): type 6");
+		cellPamf.todo("cellPamfReaderGetStreamInfo(): type 6");
 		break;
 	}
 
@@ -659,7 +659,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
 
-		cellPamf.Todo("cellPamfReaderGetStreamInfo(): type 7");
+		cellPamf.todo("cellPamfReaderGetStreamInfo(): type 7");
 		break;
 	}
 
@@ -670,20 +670,20 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 			return CELL_PAMF_ERROR_INVALID_ARG;
 		}
 
-		cellPamf.Todo("cellPamfReaderGetStreamInfo(): type 8");
+		cellPamf.todo("cellPamfReaderGetStreamInfo(): type 8");
 		break;
 	}
 
 	case 9:
 	{
-		cellPamf.Error("cellPamfReaderGetStreamInfo(): invalid type 9");
+		cellPamf.error("cellPamfReaderGetStreamInfo(): invalid type 9");
 		return CELL_PAMF_ERROR_INVALID_ARG;
 	}
 
 	default:
 	{
 		// invalid type or getting type/ch failed
-		cellPamf.Error("cellPamfReaderGetStreamInfo(): invalid type %d (ch=%d)", type, ch);
+		cellPamf.error("cellPamfReaderGetStreamInfo(): invalid type %d (ch=%d)", type, ch);
 		return CELL_PAMF_ERROR_INVALID_PAMF;
 	}
 	}
@@ -693,7 +693,7 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, vm::ptr<void> pIn
 
 u32 cellPamfReaderGetNumberOfEp(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf.Todo("cellPamfReaderGetNumberOfEp(pSelf=*0x%x)", pSelf);
+	cellPamf.todo("cellPamfReaderGetNumberOfEp(pSelf=*0x%x)", pSelf);
 
 	// cannot return error code
 	return 0; //pSelf->pAddr->stream_headers[pSelf->stream].ep_num;
@@ -701,7 +701,7 @@ u32 cellPamfReaderGetNumberOfEp(vm::ptr<CellPamfReader> pSelf)
 
 s32 cellPamfReaderGetEpIteratorWithIndex(vm::ptr<CellPamfReader> pSelf, u32 epIndex, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf.Todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=*0x%x, epIndex=%d, pIt=*0x%x)", pSelf, epIndex, pIt);
+	cellPamf.todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=*0x%x, epIndex=%d, pIt=*0x%x)", pSelf, epIndex, pIt);
 
 	// TODO
 	return CELL_OK;
@@ -709,7 +709,7 @@ s32 cellPamfReaderGetEpIteratorWithIndex(vm::ptr<CellPamfReader> pSelf, u32 epIn
 
 s32 cellPamfReaderGetEpIteratorWithTimeStamp(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf.Todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=*0x%x, pTimeStamp=*0x%x, pIt=*0x%x)", pSelf, pTimeStamp, pIt);
+	cellPamf.todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=*0x%x, pTimeStamp=*0x%x, pIt=*0x%x)", pSelf, pTimeStamp, pIt);
 
 	// TODO
 	return CELL_OK;
@@ -717,7 +717,7 @@ s32 cellPamfReaderGetEpIteratorWithTimeStamp(vm::ptr<CellPamfReader> pSelf, vm::
 
 s32 cellPamfEpIteratorGetEp(vm::ptr<CellPamfEpIterator> pIt, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf.Todo("cellPamfEpIteratorGetEp(pIt=*0x%x, pEp=*0x%x)", pIt, pEp);
+	cellPamf.todo("cellPamfEpIteratorGetEp(pIt=*0x%x, pEp=*0x%x)", pIt, pEp);
 
 	// always returns CELL_OK
 	// TODO
@@ -726,7 +726,7 @@ s32 cellPamfEpIteratorGetEp(vm::ptr<CellPamfEpIterator> pIt, vm::ptr<CellPamfEp>
 
 s32 cellPamfEpIteratorMove(vm::ptr<CellPamfEpIterator> pIt, s32 steps, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf.Todo("cellPamfEpIteratorMove(pIt=*0x%x, steps=%d, pEp=*0x%x)", pIt, steps, pEp);
+	cellPamf.todo("cellPamfEpIteratorMove(pIt=*0x%x, steps=%d, pEp=*0x%x)", pIt, steps, pEp);
 
 	// cannot return error code
 	// TODO

rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp

@@ -179,7 +179,7 @@ s32 pngReadHeader(PSubHandle stream, vm::ptr<CellPngDecInfo> info, PExtInfo extI
 	case 4: current_info.colorSpace = CELL_PNGDEC_GRAYSCALE_ALPHA; current_info.numComponents = 2; break;
 	case 6: current_info.colorSpace = CELL_PNGDEC_RGBA;            current_info.numComponents = 4; break;
 	default:
-		cellPngDec.Error("cellPngDecDecodeData: Unsupported color space (%d)", (u32)buffer[25]);
+		cellPngDec.error("cellPngDecDecodeData: Unsupported color space (%d)", (u32)buffer[25]);
 		return CELL_PNGDEC_ERROR_HEADER;
 	}
 
@@ -226,7 +226,7 @@ s32 pngDecSetParameter(PSubHandle stream, PInParam inParam, POutParam outParam,
 		current_outParam.outputComponents = 4; break;
 
 	default:
-		cellPngDec.Error("pngDecSetParameter: Unsupported color space (%d)", current_outParam.outputColorSpace);
+		cellPngDec.error("pngDecSetParameter: Unsupported color space (%d)", current_outParam.outputColorSpace);
 		return CELL_PNGDEC_ERROR_ARG;
 	}
 
@@ -274,7 +274,7 @@ s32 pngDecodeData(PSubHandle stream, vm::ptr<u8> data, PDataCtrlParam dataCtrlPa
 		);
 	if (!image)
 	{
-		cellPngDec.Error("pngDecodeData: stbi_load_from_memory failed");
+		cellPngDec.error("pngDecodeData: stbi_load_from_memory failed");
 		return CELL_PNGDEC_ERROR_STREAM_FORMAT;
 	}
 
@@ -351,11 +351,11 @@ s32 pngDecodeData(PSubHandle stream, vm::ptr<u8> data, PDataCtrlParam dataCtrlPa
 	case CELL_PNGDEC_GRAYSCALE:
 	case CELL_PNGDEC_PALETTE:
 	case CELL_PNGDEC_GRAYSCALE_ALPHA:
-		cellPngDec.Error("pngDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
+		cellPngDec.error("pngDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
 		break;
 
 	default:
-		cellPngDec.Error("pngDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
+		cellPngDec.error("pngDecodeData: Unsupported color space (%d)", current_outParam.outputColorSpace);
 		return CELL_PNGDEC_ERROR_ARG;
 	}
 
@@ -366,7 +366,7 @@ s32 pngDecodeData(PSubHandle stream, vm::ptr<u8> data, PDataCtrlParam dataCtrlPa
 
 s32 cellPngDecCreate(PPMainHandle mainHandle, PThreadInParam threadInParam, PThreadOutParam threadOutParam)
 {
-	cellPngDec.Warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x)", mainHandle, threadInParam, threadOutParam);
+	cellPngDec.warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x)", mainHandle, threadInParam, threadOutParam);
 
 	// create decoder
 	if (auto res = pngDecCreate(mainHandle, threadInParam)) return res;
@@ -379,7 +379,7 @@ s32 cellPngDecCreate(PPMainHandle mainHandle, PThreadInParam threadInParam, PThr
 
 s32 cellPngDecExtCreate(PPMainHandle mainHandle, PThreadInParam threadInParam, PThreadOutParam threadOutParam, PExtThreadInParam extThreadInParam, PExtThreadOutParam extThreadOutParam)
 {
-	cellPngDec.Warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x, extThreadInParam=*0x%x, extThreadOutParam=*0x%x)",
+	cellPngDec.warning("cellPngDecCreate(mainHandle=**0x%x, threadInParam=*0x%x, threadOutParam=*0x%x, extThreadInParam=*0x%x, extThreadOutParam=*0x%x)",
 		mainHandle, threadInParam, threadOutParam, extThreadInParam, extThreadOutParam);
 
 	// create decoder
@@ -395,7 +395,7 @@ s32 cellPngDecExtCreate(PPMainHandle mainHandle, PThreadInParam threadInParam, P
 
 s32 cellPngDecDestroy(PMainHandle mainHandle)
 {
-	cellPngDec.Warning("cellPngDecDestroy(mainHandle=*0x%x)", mainHandle);
+	cellPngDec.warning("cellPngDecDestroy(mainHandle=*0x%x)", mainHandle);
 
 	// destroy decoder
 	return pngDecDestroy(mainHandle);
@@ -403,7 +403,7 @@ s32 cellPngDecDestroy(PMainHandle mainHandle)
 
 s32 cellPngDecOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, POpenInfo openInfo)
 {
-	cellPngDec.Warning("cellPngDecOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
+	cellPngDec.warning("cellPngDecOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x)", mainHandle, subHandle, src, openInfo);
 
 	// create stream handle
 	return pngDecOpen(mainHandle, subHandle, src, openInfo);
@@ -411,7 +411,7 @@ s32 cellPngDecOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, POpe
 
 s32 cellPngDecExtOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, POpenInfo openInfo, vm::cptr<CellPngDecCbCtrlStrm> cbCtrlStrm, vm::cptr<CellPngDecOpnParam> opnParam)
 {
-	cellPngDec.Warning("cellPngDecExtOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x, cbCtrlStrm=*0x%x, opnParam=*0x%x)", mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam);
+	cellPngDec.warning("cellPngDecExtOpen(mainHandle=*0x%x, subHandle=**0x%x, src=*0x%x, openInfo=*0x%x, cbCtrlStrm=*0x%x, opnParam=*0x%x)", mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam);
 
 	// create stream handle
 	return pngDecOpen(mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam);
@@ -419,35 +419,35 @@ s32 cellPngDecExtOpen(PMainHandle mainHandle, PPSubHandle subHandle, PSrc src, P
 
 s32 cellPngDecClose(PMainHandle mainHandle, PSubHandle subHandle)
 {
-	cellPngDec.Warning("cellPngDecClose(mainHandle=*0x%x, subHandle=*0x%x)", mainHandle, subHandle);
+	cellPngDec.warning("cellPngDecClose(mainHandle=*0x%x, subHandle=*0x%x)", mainHandle, subHandle);
 
 	return pngDecClose(subHandle);
 }
 
 s32 cellPngDecReadHeader(PMainHandle mainHandle, PSubHandle subHandle, PInfo info)
 {
-	cellPngDec.Warning("cellPngDecReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x)", mainHandle, subHandle, info);
+	cellPngDec.warning("cellPngDecReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x)", mainHandle, subHandle, info);
 
 	return pngReadHeader(subHandle, info);
 }
 
 s32 cellPngDecExtReadHeader(PMainHandle mainHandle, PSubHandle subHandle, PInfo info, PExtInfo extInfo)
 {
-	cellPngDec.Warning("cellPngDecExtReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x, extInfo=*0x%x)", mainHandle, subHandle, info, extInfo);
+	cellPngDec.warning("cellPngDecExtReadHeader(mainHandle=*0x%x, subHandle=*0x%x, info=*0x%x, extInfo=*0x%x)", mainHandle, subHandle, info, extInfo);
 
 	return pngReadHeader(subHandle, info, extInfo);
 }
 
 s32 cellPngDecSetParameter(PMainHandle mainHandle, PSubHandle subHandle, PInParam inParam, POutParam outParam)
 {
-	cellPngDec.Warning("cellPngDecSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
+	cellPngDec.warning("cellPngDecSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x)", mainHandle, subHandle, inParam, outParam);
 
 	return pngDecSetParameter(subHandle, inParam, outParam);
 }
 
 s32 cellPngDecExtSetParameter(PMainHandle mainHandle, PSubHandle subHandle, PInParam inParam, POutParam outParam, PExtInParam extInParam, PExtOutParam extOutParam)
 {
-	cellPngDec.Warning("cellPngDecExtSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x, extInParam=*0x%x, extOutParam=*0x%x",
+	cellPngDec.warning("cellPngDecExtSetParameter(mainHandle=*0x%x, subHandle=*0x%x, inParam=*0x%x, outParam=*0x%x, extInParam=*0x%x, extOutParam=*0x%x",
 		mainHandle, subHandle, inParam, outParam, extInParam, extOutParam);
 
 	return pngDecSetParameter(subHandle, inParam, outParam, extInParam, extOutParam);
@@ -455,7 +455,7 @@ s32 cellPngDecExtSetParameter(PMainHandle mainHandle, PSubHandle subHandle, PInP
 
 s32 cellPngDecDecodeData(PMainHandle mainHandle, PSubHandle subHandle, vm::ptr<u8> data, PDataCtrlParam dataCtrlParam, PDataOutInfo dataOutInfo)
 {
-	cellPngDec.Warning("cellPngDecDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)",
+	cellPngDec.warning("cellPngDecDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x)",
 		mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
 
 	return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo);
@@ -463,7 +463,7 @@ s32 cellPngDecDecodeData(PMainHandle mainHandle, PSubHandle subHandle, vm::ptr<u
 
 s32 cellPngDecExtDecodeData(PMainHandle mainHandle, PSubHandle subHandle, vm::ptr<u8> data, PDataCtrlParam dataCtrlParam, PDataOutInfo dataOutInfo, PCbCtrlDisp cbCtrlDisp, PDispParam dispParam)
 {
-	cellPngDec.Warning("cellPngDecExtDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x, cbCtrlDisp=*0x%x, dispParam=*0x%x)",
+	cellPngDec.warning("cellPngDecExtDecodeData(mainHandle=*0x%x, subHandle=*0x%x, data=*0x%x, dataCtrlParam=*0x%x, dataOutInfo=*0x%x, cbCtrlDisp=*0x%x, dispParam=*0x%x)",
 		mainHandle, subHandle, data, dataCtrlParam, dataOutInfo, cbCtrlDisp, dispParam);
 
 	return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo, cbCtrlDisp, dispParam);

rpcs3/Emu/SysCalls/Modules/cellResc.cpp

@@ -573,17 +573,17 @@ void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
 // Module<> Functions
 s32 cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
 {
-	cellResc.Warning("cellRescInit(initConfig=*0x%x)", initConfig);
+	cellResc.warning("cellRescInit(initConfig=*0x%x)", initConfig);
 
 	if (s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescInit : CELL_RESC_ERROR_REINITIALIZED");
+		cellResc.error("cellRescInit : CELL_RESC_ERROR_REINITIALIZED");
 		return CELL_RESC_ERROR_REINITIALIZED;
 	}
 
 	if (InternalVersion(initConfig) == -1 || !CheckInitConfig(initConfig))
 	{
-		cellResc.Error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -596,11 +596,11 @@ s32 cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
 
 void cellRescExit()
 {
-	cellResc.Warning("cellRescExit()");
+	cellResc.warning("cellRescExit()");
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescExit(): not initialized");
+		cellResc.error("cellRescExit(): not initialized");
 		return;
 	}
 
@@ -616,7 +616,7 @@ void cellRescExit()
 			//s32 ret = ExitSystemResource();
 			//if (ret != CELL_OK)
 			//{
-			//	cellResc.Error("failed to clean up system resources.. continue. 0x%x\n", ret);
+			//	cellResc.error("failed to clean up system resources.. continue. 0x%x\n", ret);
 			//}
 		}
 	}
@@ -626,7 +626,7 @@ void cellRescExit()
 
 s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> bufferMode)
 {
-	cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode=*0x%x)", resolutionId, bufferMode);
+	cellResc.trace("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode=*0x%x)", resolutionId, bufferMode);
 
 	switch (resolutionId)
 	{
@@ -643,7 +643,7 @@ s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> b
 		*bufferMode = CELL_RESC_720x576;   
 		break;
 	default: 
-		cellResc.Error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -652,17 +652,17 @@ s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> b
 
 s32 cellRescSetDsts(u32 dstsMode, vm::ptr<CellRescDsts> dsts)
 {
-	cellResc.Log("cellRescSetDsts(dstsMode=%d, dsts=*0x%x)", dstsMode, dsts);
+	cellResc.trace("cellRescSetDsts(dstsMode=%d, dsts=*0x%x)", dstsMode, dsts);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetDst : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetDst : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if ((dstsMode != CELL_RESC_720x480) && (dstsMode != CELL_RESC_720x576) && (dstsMode != CELL_RESC_1280x720) && (dstsMode != CELL_RESC_1920x1080))
 	{
-		cellResc.Error("cellRescSetDsts : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetDsts : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -719,24 +719,24 @@ void SetFlipHandler(vm::ptr<void(u32)> handler)
 
 s32 cellRescSetDisplayMode(u32 displayMode)
 {
-	cellResc.Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
+	cellResc.warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetDisplayMode : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if (!(s_rescInternalInstance->m_initConfig.supportModes & displayMode))
 	{
-		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
 	if ((displayMode != CELL_RESC_720x480) && (displayMode != CELL_RESC_720x576) &&
 		(displayMode != CELL_RESC_1280x720) && (displayMode != CELL_RESC_1920x1080))
 	{
-		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -744,13 +744,13 @@ s32 cellRescSetDisplayMode(u32 displayMode)
 
 	if ((IsPalInterpolate() || IsPalDrop()) && s_rescInternalInstance->m_initConfig.flipMode == CELL_RESC_DISPLAY_HSYNC)
 	{
-		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
+		cellResc.error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
 		return CELL_RESC_ERROR_BAD_COMBINATION;
 	}
 
 	if (IsPal60Hsync() && s_rescInternalInstance->m_initConfig.flipMode==CELL_RESC_DISPLAY_VSYNC)
 	{
-		cellResc.Error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
+		cellResc.error("cellRescSetDisplayMode : CELL_RESC_ERROR_BAD_COMBINATIONT");
 		return CELL_RESC_ERROR_BAD_COMBINATION;
 	}
 
@@ -809,17 +809,17 @@ s32 cellRescSetDisplayMode(u32 displayMode)
 
 s32 cellRescAdjustAspectRatio(float horizontal, float vertical)
 {
-	cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
+	cellResc.warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if ((horizontal < 0.5f || 2.f < horizontal) || (vertical < 0.5f || 2.f < vertical))
 	{
-		cellResc.Error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescAdjustAspectRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -843,17 +843,17 @@ s32 cellRescAdjustAspectRatio(float horizontal, float vertical)
 
 s32 cellRescSetPalInterpolateDropFlexRatio(float ratio)
 {
-	cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
+	cellResc.warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if (ratio < 0.f || 1.f < ratio)
 	{
-		cellResc.Error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetPalInterpolateDropFlexRatio : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -864,11 +864,11 @@ s32 cellRescSetPalInterpolateDropFlexRatio(float ratio)
 
 s32 cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
 {
-	cellResc.Warning("cellRescGetBufferSize(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
+	cellResc.warning("cellRescGetBufferSize(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescGetBufferSize : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescGetBufferSize : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
@@ -907,11 +907,11 @@ s32 cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, v
 
 s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 {
-	cellResc.Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
+	cellResc.trace("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
 
 	if (reserved != 0)
 	{
-		cellResc.Error("cellRescGetNumColorBuffers : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescGetNumColorBuffers : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -928,7 +928,7 @@ s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 
 s32 cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellRescSrc> rescSrc)
 {
-	cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface=*0x%x, rescSrc=*0x%x)", gcmSurface, rescSrc);
+	cellResc.trace("cellRescGcmSurface2RescSrc(gcmSurface=*0x%x, rescSrc=*0x%x)", gcmSurface, rescSrc);
 
 	u8 textureFormat = GcmSurfaceFormat2GcmTextureFormat(gcmSurface->colorFormat, gcmSurface->type);
 	s32 xW = 1, xH = 1;
@@ -959,25 +959,25 @@ s32 cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellR
 
 s32 cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
 {
-	cellResc.Log("cellRescSetSrc(idx=0x%x, src=*0x%x)", idx, src);
+	cellResc.trace("cellRescSetSrc(idx=0x%x, src=*0x%x)", idx, src);
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetSrc : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if (idx < 0 || idx >= SRC_BUFFER_NUM || src->width < 1 || src->width > 4096 || src->height < 1 || src->height > 4096)
 	{
-		cellResc.Error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetSrc : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
-	cellResc.Log(" *** format=0x%x", src->format);
+	cellResc.trace(" *** format=0x%x", src->format);
-	cellResc.Log(" *** pitch=%d", src->pitch);
+	cellResc.trace(" *** pitch=%d", src->pitch);
-	cellResc.Log(" *** width=%d", src->width);
+	cellResc.trace(" *** width=%d", src->width);
-	cellResc.Log(" *** height=%d", src->height);
+	cellResc.trace(" *** height=%d", src->height);
-	cellResc.Log(" *** offset=0x%x", src->offset);
+	cellResc.trace(" *** offset=0x%x", src->offset);
 
 	s_rescInternalInstance->m_rescSrc[idx] = *src;
 
@@ -988,17 +988,17 @@ s32 cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
 
 s32 cellRescSetConvertAndFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> cntxt, s32 idx)
 {
-	cellResc.Log("cellRescSetConvertAndFlip(cntxt=*0x%x, idx=0x%x)", cntxt, idx);
+	cellResc.trace("cellRescSetConvertAndFlip(cntxt=*0x%x, idx=0x%x)", cntxt, idx);
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if(idx < 0 || SRC_BUFFER_NUM <= idx)
 	{
-		cellResc.Error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescSetConvertAndFlip : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
@@ -1026,7 +1026,7 @@ s32 cellRescSetConvertAndFlip(PPUThread& ppu, vm::ptr<CellGcmContextData> cntxt,
 
 s32 cellRescSetWaitFlip()
 {
-	cellResc.Warning("cellRescSetWaitFlip()");
+	cellResc.warning("cellRescSetWaitFlip()");
 	
 	// TODO: emit RSX command for "wait flip" operation
 
@@ -1035,17 +1035,17 @@ s32 cellRescSetWaitFlip()
 
 s32 cellRescSetBufferAddress(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
 {
-	cellResc.Warning("cellRescSetBufferAddress(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
+	cellResc.warning("cellRescSetBufferAddress(colorBuffers=*0x%x, vertexArray=*0x%x, fragmentShader=*0x%x)", colorBuffers, vertexArray, fragmentShader);
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescSetBufferAddress : CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if(colorBuffers.addr() % COLOR_BUFFER_ALIGNMENT || vertexArray.addr() % VERTEX_BUFFER_ALIGNMENT || fragmentShader.addr() % FRAGMENT_SHADER_ALIGNMENT)
 	{
-		cellResc.Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ALIGNMENT");
+		cellResc.error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ALIGNMENT");
 		return CELL_RESC_ERROR_BAD_ALIGNMENT;
 	}
 
@@ -1079,21 +1079,21 @@ s32 cellRescSetBufferAddress(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray
 
 void cellRescSetFlipHandler(vm::ptr<void(u32)> handler)
 {
-	cellResc.Warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
+	cellResc.warning("cellRescSetFlipHandler(handler=*0x%x)", handler);
 
 	Emu.GetGSManager().GetRender().flip_handler = handler;
 }
 
 void cellRescResetFlipStatus()
 {
-	cellResc.Log("cellRescResetFlipStatus()");
+	cellResc.trace("cellRescResetFlipStatus()");
 
 	Emu.GetGSManager().GetRender().flip_status = 1;
 }
 
 s32 cellRescGetFlipStatus()
 {
-	cellResc.Log("cellRescGetFlipStatus()");
+	cellResc.trace("cellRescGetFlipStatus()");
 
 	return Emu.GetGSManager().GetRender().flip_status;
 }
@@ -1106,7 +1106,7 @@ s32 cellRescGetRegisterCount()
 
 u64 cellRescGetLastFlipTime()
 {
-	cellResc.Log("cellRescGetLastFlipTime()");
+	cellResc.trace("cellRescGetLastFlipTime()");
 
 	return Emu.GetGSManager().GetRender().last_flip_time;
 }
@@ -1119,7 +1119,7 @@ s32 cellRescSetRegisterCount()
 
 void cellRescSetVBlankHandler(vm::ptr<void(u32)> handler)
 {
-	cellResc.Warning("cellRescSetVBlankHandler(handler=*0x%x)", handler);
+	cellResc.warning("cellRescSetVBlankHandler(handler=*0x%x)", handler);
 
 	Emu.GetGSManager().GetRender().vblank_handler = handler;
 }
@@ -1216,23 +1216,23 @@ s32 CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
 
 s32 cellRescCreateInterlaceTable(u32 ea_addr, float srcH, CellRescTableElement depth, s32 length)
 {
-	cellResc.Warning("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, depth, length);
+	cellResc.warning("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, depth, length);
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
-		cellResc.Error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_NOT_INITIALIZED");
+		cellResc.error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_NOT_INITIALIZED");
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
 	if ((ea_addr == 0) || (srcH <= 0.f) || (!(depth == CELL_RESC_ELEMENT_HALF || depth == CELL_RESC_ELEMENT_FLOAT)) || (length <= 0))
 	{
-		cellResc.Error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_BAD_ARGUMENT");
+		cellResc.error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
 	}
 
 	if (s_rescInternalInstance->m_dstHeight == 0)
 	{
-		cellResc.Error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_BAD_COMBINATION");
+		cellResc.error("cellRescCreateInterlaceTable: CELL_RESC_ERROR_BAD_COMBINATION");
 		return CELL_RESC_ERROR_BAD_COMBINATION;
 	}
 

rpcs3/Emu/SysCalls/Modules/cellRtc.cpp

@@ -24,7 +24,7 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, s32 ye
 
 s32 cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc.Log("cellRtcGetCurrentTick(pTick=*0x%x)", pTick);
+	cellRtc.trace("cellRtcGetCurrentTick(pTick=*0x%x)", pTick);
 
 	rDateTime unow = rDateTime::UNow();
 	pTick->tick = unow.GetTicks();
@@ -33,7 +33,7 @@ s32 cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
 
 s32 cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
 {
-	cellRtc.Log("cellRtcGetCurrentClock(pClock=*0x%x, time_zone=%d)", pClock, iTimeZone);
+	cellRtc.trace("cellRtcGetCurrentClock(pClock=*0x%x, time_zone=%d)", pClock, iTimeZone);
 
 	rDateTime unow = rDateTime::UNow();
 
@@ -54,7 +54,7 @@ s32 cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
 
 s32 cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
 {
-	cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=*0x%x)", pClock);
+	cellRtc.trace("cellRtcGetCurrentClockLocalTime(pClock=*0x%x)", pClock);
 
 	rDateTime unow = rDateTime::UNow();
 
@@ -71,7 +71,7 @@ s32 cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
 
 s32 cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc.Log("cellRtcFormatRfc2822(pszDateTime=*0x%x, pUtc=*0x%x, time_zone=%d)", pszDateTime, pUtc, iTimeZone);
+	cellRtc.trace("cellRtcFormatRfc2822(pszDateTime=*0x%x, pUtc=*0x%x, time_zone=%d)", pszDateTime, pUtc, iTimeZone);
 
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@@ -89,7 +89,7 @@ s32 cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
 
 s32 cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
+	cellRtc.trace("cellRtcFormatRfc2822LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
 
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t)pUtc->tick);
@@ -103,7 +103,7 @@ s32 cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
 
 s32 cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc.Log("cellRtcFormatRfc3339(pszDateTime=*0x%x, pUtc=*0x%x, iTimeZone=%d)", pszDateTime, pUtc, iTimeZone);
+	cellRtc.trace("cellRtcFormatRfc3339(pszDateTime=*0x%x, pUtc=*0x%x, iTimeZone=%d)", pszDateTime, pUtc, iTimeZone);
 	
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@@ -121,7 +121,7 @@ s32 cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
 
 s32 cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
+	cellRtc.trace("cellRtcFormatRfc3339LocalTime(pszDateTime=*0x%x, pUtc=*0x%x)", pszDateTime, pUtc);
 	
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t) pUtc->tick);
@@ -135,7 +135,7 @@ s32 cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
 
 s32 cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
-	cellRtc.Log("cellRtcParseDateTime(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
+	cellRtc.trace("cellRtcParseDateTime(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
 
 	// Get date from formatted string.
 	rDateTime date;
@@ -148,7 +148,7 @@ s32 cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 
 s32 cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 {
-	cellRtc.Log("cellRtcParseRfc3339(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
+	cellRtc.trace("cellRtcParseRfc3339(pUtc=*0x%x, pszDateTime=*0x%x)", pUtc, pszDateTime);
 
 	// Get date from RFC3339 formatted string.
 	rDateTime date;
@@ -161,7 +161,7 @@ s32 cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
 
 s32 cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc.Log("cellRtcGetTick(pTime=*0x%x, pTick=*0x%x)", pTime, pTick);
+	cellRtc.trace("cellRtcGetTick(pTime=*0x%x, pTick=*0x%x)", pTime, pTick);
 
 	rDateTime datetime = rDateTime(pTime->day, (rDateTime::Month)pTime->month.value(), pTime->year, pTime->hour, pTime->minute, pTime->second, (pTime->microsecond / 1000));
 	pTick->tick = datetime.GetTicks();
@@ -171,7 +171,7 @@ s32 cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 
 s32 cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc.Log("cellRtcSetTick(pTime=*0x%x, pTick=*0x%x)", pTime, pTick);
+	cellRtc.trace("cellRtcSetTick(pTime=*0x%x, pTick=*0x%x)", pTime, pTick);
 	
 	rDateTime date = rDateTime((time_t)pTick->tick);
 
@@ -188,7 +188,7 @@ s32 cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 
 s32 cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc.Log("cellRtcTickAddTicks(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
+	cellRtc.trace("cellRtcTickAddTicks(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
 
 	pTick0->tick = pTick1->tick + lAdd;
 	return CELL_OK;
@@ -196,7 +196,7 @@ s32 cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
 
 s32 cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc.Log("cellRtcTickAddMicroseconds(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
+	cellRtc.trace("cellRtcTickAddMicroseconds(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
 	
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan microseconds = rTimeSpan(0, 0, 0, lAdd / 1000);
@@ -208,7 +208,7 @@ s32 cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick>
 
 s32 cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc.Log("cellRtcTickAddSeconds(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
+	cellRtc.trace("cellRtcTickAddSeconds(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan seconds = rTimeSpan(0, 0, lAdd, 0);
@@ -220,7 +220,7 @@ s32 cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
 
 s32 cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc.Log("cellRtcTickAddMinutes(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
+	cellRtc.trace("cellRtcTickAddMinutes(pTick0=*0x%x, pTick1=*0x%x, lAdd=%lld)", pTick0, pTick1, lAdd);
 	
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan minutes = rTimeSpan(0, lAdd, 0, 0); // ???
@@ -232,7 +232,7 @@ s32 cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
 
 s32 cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc.Log("cellRtcTickAddHours(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
+	cellRtc.trace("cellRtcTickAddHours(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan hours = rTimeSpan(iAdd, 0, 0, 0); // ???
@@ -244,7 +244,7 @@ s32 cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
 
 s32 cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc.Log("cellRtcTickAddDays(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
+	cellRtc.trace("cellRtcTickAddDays(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan days = rDateSpan(0, 0, 0, iAdd); // ???
@@ -256,7 +256,7 @@ s32 cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1,
 
 s32 cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc.Log("cellRtcTickAddWeeks(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
+	cellRtc.trace("cellRtcTickAddWeeks(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan weeks = rDateSpan(0, 0, iAdd, 0);
@@ -268,7 +268,7 @@ s32 cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
 
 s32 cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc.Log("cellRtcTickAddMonths(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
+	cellRtc.trace("cellRtcTickAddMonths(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan months = rDateSpan(0, iAdd, 0, 0);
@@ -280,7 +280,7 @@ s32 cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick
 
 s32 cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc.Log("cellRtcTickAddYears(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
+	cellRtc.trace("cellRtcTickAddYears(pTick0=*0x%x, pTick1=*0x%x, iAdd=%d)", pTick0, pTick1, iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan years = rDateSpan(iAdd, 0, 0, 0);
@@ -292,7 +292,7 @@ s32 cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
 
 s32 cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick> pLocalTime)
 {
-	cellRtc.Log("cellRtcConvertUtcToLocalTime(pUtc=*0x%x, pLocalTime=*0x%x)", pUtc, pLocalTime);
+	cellRtc.trace("cellRtcConvertUtcToLocalTime(pUtc=*0x%x, pLocalTime=*0x%x)", pUtc, pLocalTime);
 
 	rDateTime time = rDateTime((time_t)pUtc->tick);
 	rDateTime local_time = time.FromUTC(false);
@@ -302,7 +302,7 @@ s32 cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick>
 
 s32 cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc.Log("cellRtcConvertLocalTimeToUtc(pLocalTime=*0x%x, pUtc=*0x%x)", pLocalTime, pUtc);
+	cellRtc.trace("cellRtcConvertLocalTimeToUtc(pLocalTime=*0x%x, pUtc=*0x%x)", pLocalTime, pUtc);
 
 	rDateTime time = rDateTime((time_t)pLocalTime->tick);
 	rDateTime utc_time = time.ToUTC(false);
@@ -312,7 +312,7 @@ s32 cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRt
 
 s32 cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTime)
 {
-	cellRtc.Log("cellRtcGetDosTime(pDateTime=*0x%x, puiDosTime=*0x%x)", pDateTime, puiDosTime);
+	cellRtc.trace("cellRtcGetDosTime(pDateTime=*0x%x, puiDosTime=*0x%x)", pDateTime, puiDosTime);
 
 	// Convert to DOS time.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.value(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -323,7 +323,7 @@ s32 cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTim
 
 s32 cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime)
 {
-	cellRtc.Log("cellRtcGetTime_t(pDateTime=*0x%x, piTime=*0x%x)", pDateTime, piTime);
+	cellRtc.trace("cellRtcGetTime_t(pDateTime=*0x%x, piTime=*0x%x)", pDateTime, piTime);
 
 	// Convert to POSIX time_t.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.value(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -335,7 +335,7 @@ s32 cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime)
 
 s32 cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pulWin32FileTime)
 {
-	cellRtc.Log("cellRtcGetWin32FileTime(pDateTime=*0x%x, pulWin32FileTime=*0x%x)", pDateTime, pulWin32FileTime);
+	cellRtc.trace("cellRtcGetWin32FileTime(pDateTime=*0x%x, pulWin32FileTime=*0x%x)", pDateTime, pulWin32FileTime);
 
 	// Convert to WIN32 FILETIME.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.value(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -347,7 +347,7 @@ s32 cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pul
 
 s32 cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
 {
-	cellRtc.Log("cellRtcSetDosTime(pDateTime=*0x%x, uiDosTime=0x%x)", pDateTime, uiDosTime);
+	cellRtc.trace("cellRtcSetDosTime(pDateTime=*0x%x, uiDosTime=0x%x)", pDateTime, uiDosTime);
 
 	rDateTime date_time;
 	rDateTime dos_time = date_time.SetFromDOS(uiDosTime);
@@ -365,7 +365,7 @@ s32 cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
 
 s32 cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
 {
-	cellRtc.Log("cellRtcSetTime_t(pDateTime=*0x%x, iTime=0x%llx)", pDateTime, iTime);
+	cellRtc.trace("cellRtcSetTime_t(pDateTime=*0x%x, iTime=0x%llx)", pDateTime, iTime);
 
 	rDateTime date_time = rDateTime((time_t)iTime);
 	
@@ -382,7 +382,7 @@ s32 cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
 
 s32 cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
 {
-	cellRtc.Log("cellRtcSetWin32FileTime(pDateTime=*0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
+	cellRtc.trace("cellRtcSetWin32FileTime(pDateTime=*0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
 
 	rDateTime date_time = rDateTime((time_t)ulWin32FileTime);
 	
@@ -399,7 +399,7 @@ s32 cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileT
 
 s32 cellRtcIsLeapYear(s32 year)
 {
-	cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
+	cellRtc.trace("cellRtcIsLeapYear(year=%d)", year);
 
 	rDateTime datetime;
 	return datetime.IsLeapYear(year, rDateTime::Gregorian);
@@ -407,7 +407,7 @@ s32 cellRtcIsLeapYear(s32 year)
 
 s32 cellRtcGetDaysInMonth(s32 year, s32 month)
 {
-	cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
+	cellRtc.trace("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
 
 	rDateTime datetime;
 	return datetime.GetNumberOfDays((rDateTime::Month) month, year, rDateTime::Gregorian);
@@ -415,7 +415,7 @@ s32 cellRtcGetDaysInMonth(s32 year, s32 month)
 
 s32 cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 {
-	cellRtc.Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
+	cellRtc.trace("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
 
 	rDateTime datetime;
 	datetime.SetToWeekDay((rDateTime::WeekDay) day, 1, (rDateTime::Month) month, year);
@@ -424,7 +424,7 @@ s32 cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 
 s32 cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
 {
-	cellRtc.Log("cellRtcCheckValid(pTime=*0x%x)", pTime);
+	cellRtc.trace("cellRtcCheckValid(pTime=*0x%x)", pTime);
 
 	if ((pTime->year < 1) || (pTime->year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR;
 	else if ((pTime->month < 1) || (pTime->month > 12)) return CELL_RTC_ERROR_INVALID_MONTH;
@@ -438,7 +438,7 @@ s32 cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
 
 s32 cellRtcCompareTick(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1)
 {
-	cellRtc.Log("cellRtcCompareTick(pTick0=*0x%x, pTick1=*0x%x)", pTick0, pTick1);
+	cellRtc.trace("cellRtcCompareTick(pTick0=*0x%x, pTick1=*0x%x)", pTick0, pTick1);
 
 	if (pTick0->tick < pTick1->tick) return -1;
 	else if (pTick0->tick > pTick1->tick) return 1;

rpcs3/Emu/SysCalls/Modules/cellRudp.cpp

@@ -21,7 +21,7 @@ struct rudp_t
 
 s32 cellRudpInit(vm::ptr<CellRudpAllocator> allocator)
 {
-	cellRudp.Warning("cellRudpInit(allocator=*0x%x)", allocator);
+	cellRudp.warning("cellRudpInit(allocator=*0x%x)", allocator);
 
 	const auto rudp = fxm::make<rudp_t>();
 
@@ -56,7 +56,7 @@ s32 cellRudpInit(vm::ptr<CellRudpAllocator> allocator)
 
 s32 cellRudpEnd()
 {
-	cellRudp.Warning("cellRudpEnd()");
+	cellRudp.warning("cellRudpEnd()");
 
 	if (!fxm::remove<rudp_t>())
 	{
@@ -74,7 +74,7 @@ s32 cellRudpEnableInternalIOThread()
 
 s32 cellRudpSetEventHandler(vm::ptr<CellRudpEventHandler> handler, vm::ptr<void> arg)
 {
-	cellRudp.Todo("cellRudpSetEventHandler(handler=*0x%x, arg=*0x%x)", handler, arg);
+	cellRudp.todo("cellRudpSetEventHandler(handler=*0x%x, arg=*0x%x)", handler, arg);
 
 	const auto rudp = fxm::get<rudp_t>();
 
@@ -91,7 +91,7 @@ s32 cellRudpSetEventHandler(vm::ptr<CellRudpEventHandler> handler, vm::ptr<void>
 
 s32 cellRudpSetMaxSegmentSize(u16 mss)
 {
-	cellRudp.Todo("cellRudpSetMaxSegmentSize(mss=%d)", mss);
+	cellRudp.todo("cellRudpSetMaxSegmentSize(mss=%d)", mss);
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/cellSail.cpp

@@ -34,7 +34,7 @@ void playerBoot(vm::ptr<CellSailPlayer> pSelf, u64 userParam)
 
 s32 cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<CellSailMemAllocatorFuncs> pCallbacks)
 {
-	cellSail.Warning("cellSailMemAllocatorInitialize(pSelf=*0x%x, pCallbacks=*0x%x)", pSelf, pCallbacks);
+	cellSail.warning("cellSailMemAllocatorInitialize(pSelf=*0x%x, pCallbacks=*0x%x)", pSelf, pCallbacks);
 
 	pSelf->callbacks = pCallbacks;
 
@@ -43,37 +43,37 @@ s32 cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<
 
 s32 cellSailFutureInitialize(vm::ptr<CellSailFuture> pSelf)
 {
-	cellSail.Todo("cellSailFutureInitialize(pSelf=*0x%x)", pSelf);
+	cellSail.todo("cellSailFutureInitialize(pSelf=*0x%x)", pSelf);
 	return CELL_OK;
 }
 
 s32 cellSailFutureFinalize(vm::ptr<CellSailFuture> pSelf)
 {
-	cellSail.Todo("cellSailFutureFinalize(pSelf=*0x%x)", pSelf);
+	cellSail.todo("cellSailFutureFinalize(pSelf=*0x%x)", pSelf);
 	return CELL_OK;
 }
 
 s32 cellSailFutureReset(vm::ptr<CellSailFuture> pSelf, b8 wait)
 {
-	cellSail.Todo("cellSailFutureReset(pSelf=*0x%x, wait=%d)", pSelf, wait);
+	cellSail.todo("cellSailFutureReset(pSelf=*0x%x, wait=%d)", pSelf, wait);
 	return CELL_OK;
 }
 
 s32 cellSailFutureSet(vm::ptr<CellSailFuture> pSelf, s32 result)
 {
-	cellSail.Todo("cellSailFutureSet(pSelf=*0x%x, result=%d)", pSelf, result);
+	cellSail.todo("cellSailFutureSet(pSelf=*0x%x, result=%d)", pSelf, result);
 	return CELL_OK;
 }
 
 s32 cellSailFutureGet(vm::ptr<CellSailFuture> pSelf, u64 timeout, vm::ptr<s32> pResult)
 {
-	cellSail.Todo("cellSailFutureGet(pSelf=*0x%x, timeout=%lld, result=*0x%x)", pSelf, timeout, pResult);
+	cellSail.todo("cellSailFutureGet(pSelf=*0x%x, timeout=%lld, result=*0x%x)", pSelf, timeout, pResult);
 	return CELL_OK;
 }
 
 s32 cellSailFutureIsDone(vm::ptr<CellSailFuture> pSelf, vm::ptr<s32> pResult)
 {
-	cellSail.Todo("cellSailFutureIsDone(pSelf=*0x%x, result=*0x%x)", pSelf, pResult);
+	cellSail.todo("cellSailFutureIsDone(pSelf=*0x%x, result=*0x%x)", pSelf, pResult);
 	return CELL_OK;
 }
 
@@ -97,7 +97,7 @@ s32 cellSailDescriptorGetMediaInfo()
 
 s32 cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, b8 autoSelection)
 {
-	cellSail.Warning("cellSailDescriptorSetAutoSelection(pSelf=*0x%x, autoSelection=%d)", pSelf, autoSelection);
+	cellSail.warning("cellSailDescriptorSetAutoSelection(pSelf=*0x%x, autoSelection=%d)", pSelf, autoSelection);
 
 	if (pSelf)
 	{
@@ -110,7 +110,7 @@ s32 cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, b8 aut
 
 s32 cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
 {
-	cellSail.Warning("cellSailDescriptorIsAutoSelection(pSelf=*0x%x)", pSelf);
+	cellSail.warning("cellSailDescriptorIsAutoSelection(pSelf=*0x%x)", pSelf);
 	
 	if (pSelf)
 	{
@@ -122,7 +122,7 @@ s32 cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
 
 s32 cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<void> pDatabase, u32 size, u64 arg)
 {
-	cellSail.Warning("cellSailDescriptorCreateDatabase(pSelf=*0x%x, pDatabase=*0x%x, size=0x%x, arg=0x%llx)", pSelf, pDatabase, size, arg);
+	cellSail.warning("cellSailDescriptorCreateDatabase(pSelf=*0x%x, pDatabase=*0x%x, size=0x%x, arg=0x%llx)", pSelf, pDatabase, size, arg);
 
 	switch ((s32)pSelf->streamType)
 	{
@@ -134,7 +134,7 @@ s32 cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<
 			break;
 		}
 		default:
-			cellSail.Error("Unhandled stream type: %d", pSelf->streamType);
+			cellSail.error("Unhandled stream type: %d", pSelf->streamType);
 	}
 
 	return CELL_OK;
@@ -190,7 +190,7 @@ s32 cellSailDescriptorSetParameter()
 
 s32 cellSailSoundAdapterInitialize(vm::ptr<CellSailSoundAdapter> pSelf, vm::cptr<CellSailSoundAdapterFuncs> pCallbacks, vm::ptr<void> pArg)
 {
-	cellSail.Warning("cellSailSoundAdapterInitialize(pSelf=*0x%x, pCallbacks=*0x%x, pArg=*0x%x)", pSelf, pCallbacks, pArg);
+	cellSail.warning("cellSailSoundAdapterInitialize(pSelf=*0x%x, pCallbacks=*0x%x, pArg=*0x%x)", pSelf, pCallbacks, pArg);
 
 	if (pSelf->initialized)
 	{
@@ -214,7 +214,7 @@ s32 cellSailSoundAdapterInitialize(vm::ptr<CellSailSoundAdapter> pSelf, vm::cptr
 
 s32 cellSailSoundAdapterFinalize(vm::ptr<CellSailSoundAdapter> pSelf)
 {
-	cellSail.Warning("cellSailSoundAdapterFinalize(pSelf=*0x%x)", pSelf);
+	cellSail.warning("cellSailSoundAdapterFinalize(pSelf=*0x%x)", pSelf);
 
 	if (!pSelf->initialized)
 	{
@@ -231,7 +231,7 @@ s32 cellSailSoundAdapterFinalize(vm::ptr<CellSailSoundAdapter> pSelf)
 
 s32 cellSailSoundAdapterSetPreferredFormat(vm::ptr<CellSailSoundAdapter> pSelf, vm::cptr<CellSailAudioFormat> pFormat)
 {
-	cellSail.Warning("cellSailSoundAdapterSetPreferredFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
+	cellSail.warning("cellSailSoundAdapterSetPreferredFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
 
 	pSelf->format = *pFormat;
 
@@ -240,7 +240,7 @@ s32 cellSailSoundAdapterSetPreferredFormat(vm::ptr<CellSailSoundAdapter> pSelf,
 
 s32 cellSailSoundAdapterGetFrame(vm::ptr<CellSailSoundAdapter> pSelf, u32 samples, vm::ptr<CellSailSoundFrameInfo> pInfo)
 {
-	cellSail.Todo("cellSailSoundAdapterGetFrame(pSelf=*0x%x, samples=%d, pInfo=*0x%x)", pSelf, samples, pInfo);
+	cellSail.todo("cellSailSoundAdapterGetFrame(pSelf=*0x%x, samples=%d, pInfo=*0x%x)", pSelf, samples, pInfo);
 
 	if (!pSelf->initialized)
 	{
@@ -262,7 +262,7 @@ s32 cellSailSoundAdapterGetFrame(vm::ptr<CellSailSoundAdapter> pSelf, u32 sample
 
 s32 cellSailSoundAdapterGetFormat(vm::ptr<CellSailSoundAdapter> pSelf, vm::ptr<CellSailAudioFormat> pFormat)
 {
-	cellSail.Warning("cellSailSoundAdapterGetFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
+	cellSail.warning("cellSailSoundAdapterGetFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
 
 	*pFormat = pSelf->format;
 
@@ -283,7 +283,7 @@ s32 cellSailSoundAdapterPtsToTimePosition()
 
 s32 cellSailGraphicsAdapterInitialize(vm::ptr<CellSailGraphicsAdapter> pSelf, vm::cptr<CellSailGraphicsAdapterFuncs> pCallbacks, vm::ptr<void> pArg)
 {
-	cellSail.Warning("cellSailGraphicsAdapterInitialize(pSelf=*0x%x, pCallbacks=*0x%x, pArg=*0x%x)", pSelf, pCallbacks, pArg);
+	cellSail.warning("cellSailGraphicsAdapterInitialize(pSelf=*0x%x, pCallbacks=*0x%x, pArg=*0x%x)", pSelf, pCallbacks, pArg);
 
 	if (pSelf->initialized)
 	{
@@ -309,7 +309,7 @@ s32 cellSailGraphicsAdapterInitialize(vm::ptr<CellSailGraphicsAdapter> pSelf, vm
 
 s32 cellSailGraphicsAdapterFinalize(vm::ptr<CellSailGraphicsAdapter> pSelf)
 {
-	cellSail.Todo("cellSailGraphicsAdapterFinalize(pSelf=*0x%x)", pSelf);
+	cellSail.todo("cellSailGraphicsAdapterFinalize(pSelf=*0x%x)", pSelf);
 
 	if (!pSelf->initialized)
 	{
@@ -326,7 +326,7 @@ s32 cellSailGraphicsAdapterFinalize(vm::ptr<CellSailGraphicsAdapter> pSelf)
 
 s32 cellSailGraphicsAdapterSetPreferredFormat(vm::ptr<CellSailGraphicsAdapter> pSelf, vm::cptr<CellSailVideoFormat> pFormat)
 {
-	cellSail.Warning("cellSailGraphicsAdapterSetPreferredFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
+	cellSail.warning("cellSailGraphicsAdapterSetPreferredFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
 
 	pSelf->format = *pFormat;
 
@@ -335,20 +335,20 @@ s32 cellSailGraphicsAdapterSetPreferredFormat(vm::ptr<CellSailGraphicsAdapter> p
 
 s32 cellSailGraphicsAdapterGetFrame(vm::ptr<CellSailGraphicsAdapter> pSelf, vm::ptr<CellSailGraphicsFrameInfo> pInfo)
 {
-	cellSail.Todo("cellSailGraphicsAdapterGetFrame(pSelf=*0x%x, pInfo=*0x%x)", pSelf, pInfo);
+	cellSail.todo("cellSailGraphicsAdapterGetFrame(pSelf=*0x%x, pInfo=*0x%x)", pSelf, pInfo);
 	return CELL_OK;
 }
 
 s32 cellSailGraphicsAdapterGetFrame2(vm::ptr<CellSailGraphicsAdapter> pSelf, vm::ptr<CellSailGraphicsFrameInfo> pInfo, vm::ptr<CellSailGraphicsFrameInfo> pPrevInfo, vm::ptr<u64> pFlipTime, u64 flags)
 {
-	cellSail.Todo("cellSailGraphicsAdapterGetFrame2(pSelf=*0x%x, pInfo=*0x%x, pPrevInfo=*0x%x, flipTime=*0x%x, flags=0x%llx)", pSelf, pInfo, pPrevInfo, pFlipTime, flags);
+	cellSail.todo("cellSailGraphicsAdapterGetFrame2(pSelf=*0x%x, pInfo=*0x%x, pPrevInfo=*0x%x, flipTime=*0x%x, flags=0x%llx)", pSelf, pInfo, pPrevInfo, pFlipTime, flags);
 
 	return CELL_OK;
 }
 
 s32 cellSailGraphicsAdapterGetFormat(vm::ptr<CellSailGraphicsAdapter> pSelf, vm::ptr<CellSailVideoFormat> pFormat)
 {
-	cellSail.Warning("cellSailGraphicsAdapterGetFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
+	cellSail.warning("cellSailGraphicsAdapterGetFormat(pSelf=*0x%x, pFormat=*0x%x)", pSelf, pFormat);
 
 	*pFormat = pSelf->format;
 
@@ -622,7 +622,7 @@ s32 cellSailPlayerInitialize2(
 	vm::ptr<CellSailPlayerAttribute> pAttribute,
 	vm::ptr<CellSailPlayerResource> pResource)
 {
-	cellSail.Warning("cellSailPlayerInitialize2(pSelf=*0x%x, pAllocator=*0x%x, pCallback=*0x%x, callbackArg=*0x%x, pAttribute=*0x%x, pResource=*0x%x)",
+	cellSail.warning("cellSailPlayerInitialize2(pSelf=*0x%x, pAllocator=*0x%x, pCallback=*0x%x, callbackArg=*0x%x, pAttribute=*0x%x, pResource=*0x%x)",
 		pSelf, pAllocator, pCallback, callbackArg, pAttribute, pResource);
 
 	pSelf->allocator = *pAllocator;
@@ -646,7 +646,7 @@ s32 cellSailPlayerInitialize2(
 
 s32 cellSailPlayerFinalize(vm::ptr<CellSailPlayer> pSelf)
 {
-	cellSail.Todo("cellSailPlayerFinalize(pSelf=*0x%x)", pSelf);
+	cellSail.todo("cellSailPlayerFinalize(pSelf=*0x%x)", pSelf);
 
 	if (pSelf->sAdapter)
 	{
@@ -675,7 +675,7 @@ s32 cellSailPlayerGetRegisteredProtocols()
 
 s32 cellSailPlayerSetSoundAdapter(vm::ptr<CellSailPlayer> pSelf, u32 index, vm::ptr<CellSailSoundAdapter> pAdapter)
 {
-	cellSail.Warning("cellSailPlayerSetSoundAdapter(pSelf=*0x%x, index=%d, pAdapter=*0x%x)", pSelf, index, pAdapter);
+	cellSail.warning("cellSailPlayerSetSoundAdapter(pSelf=*0x%x, index=%d, pAdapter=*0x%x)", pSelf, index, pAdapter);
 
 	if (index > pSelf->attribute.maxAudioStreamNum)
 	{
@@ -691,7 +691,7 @@ s32 cellSailPlayerSetSoundAdapter(vm::ptr<CellSailPlayer> pSelf, u32 index, vm::
 
 s32 cellSailPlayerSetGraphicsAdapter(vm::ptr<CellSailPlayer> pSelf, u32 index, vm::ptr<CellSailGraphicsAdapter> pAdapter)
 {
-	cellSail.Warning("cellSailPlayerSetGraphicsAdapter(pSelf=*0x%x, index=%d, pAdapter=*0x%x)", pSelf, index, pAdapter);
+	cellSail.warning("cellSailPlayerSetGraphicsAdapter(pSelf=*0x%x, index=%d, pAdapter=*0x%x)", pSelf, index, pAdapter);
 
 	if (index > pSelf->attribute.maxVideoStreamNum)
 	{
@@ -725,14 +725,14 @@ s32 cellSailPlayerSetRendererVideo()
 
 s32 cellSailPlayerSetParameter(vm::ptr<CellSailPlayer> pSelf, s32 parameterType, u64 param0, u64 param1)
 {
-	cellSail.Warning("cellSailPlayerSetParameter(pSelf=*0x%x, parameterType=0x%x, param0=0x%llx, param1=0x%llx)", pSelf, parameterType, param0, param1);
+	cellSail.warning("cellSailPlayerSetParameter(pSelf=*0x%x, parameterType=0x%x, param0=0x%llx, param1=0x%llx)", pSelf, parameterType, param0, param1);
 
 	switch (parameterType)
 	{
 	case CELL_SAIL_PARAMETER_GRAPHICS_ADAPTER_BUFFER_RELEASE_DELAY: pSelf->graphics_adapter_buffer_release_delay = param1; break; // TODO: Stream index
 	case CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_STACK_SIZE:         pSelf->control_ppu_thread_stack_size = param0; break;
 	case CELL_SAIL_PARAMETER_ENABLE_APOST_SRC:                      pSelf->enable_apost_src = param1; break; // TODO: Stream index
-	default: cellSail.Todo("cellSailPlayerSetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
+	default: cellSail.todo("cellSailPlayerSetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
 	}
 
 	return CELL_OK;
@@ -740,11 +740,11 @@ s32 cellSailPlayerSetParameter(vm::ptr<CellSailPlayer> pSelf, s32 parameterType,
 
 s32 cellSailPlayerGetParameter(vm::ptr<CellSailPlayer> pSelf, s32 parameterType, vm::ptr<u64> pParam0, vm::ptr<u64> pParam1)
 {
-	cellSail.Todo("cellSailPlayerGetParameter(pSelf=*0x%x, parameterType=0x%x, param0=*0x%x, param1=*0x%x)", pSelf, parameterType, pParam0, pParam1);
+	cellSail.todo("cellSailPlayerGetParameter(pSelf=*0x%x, parameterType=0x%x, param0=*0x%x, param1=*0x%x)", pSelf, parameterType, pParam0, pParam1);
 
 	switch (parameterType)
 	{
-	default: cellSail.Error("cellSailPlayerGetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
+	default: cellSail.error("cellSailPlayerGetParameter(): unimplemented parameter %s", ParameterCodeToName(parameterType));
 	}
 
 	return CELL_OK;
@@ -770,7 +770,7 @@ s32 cellSailPlayerReplaceEventHandler()
 
 s32 cellSailPlayerBoot(PPUThread& ppu, vm::ptr<CellSailPlayer> pSelf, u64 userParam)
 {
-	cellSail.Warning("cellSailPlayerBoot(pSelf=*0x%x, userParam=%d)", pSelf, userParam);
+	cellSail.warning("cellSailPlayerBoot(pSelf=*0x%x, userParam=%d)", pSelf, userParam);
 
 	playerBoot(pSelf, userParam);
 
@@ -779,7 +779,7 @@ s32 cellSailPlayerBoot(PPUThread& ppu, vm::ptr<CellSailPlayer> pSelf, u64 userPa
 
 s32 cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc)
 {
-	cellSail.Warning("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, pDesc);
+	cellSail.warning("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, pDesc);
 
 	if (pSelf && pSelf->descriptors < 3 && pDesc)
 	{
@@ -789,7 +789,7 @@ s32 cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailD
 	}
 	else
 	{
-		cellSail.Error("Descriptor limit reached or the descriptor is unspecified! This should never happen, report this to a developer.");
+		cellSail.error("Descriptor limit reached or the descriptor is unspecified! This should never happen, report this to a developer.");
 	}
 
 	return CELL_OK;
@@ -797,7 +797,7 @@ s32 cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailD
 
 s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, vm::pptr<CellSailDescriptor> ppDesc)
 {
-	cellSail.Todo("cellSailPlayerCreateDescriptor(pSelf=*0x%x, streamType=%d, pMediaInfo=*0x%x, pUri=*0x%x, ppDesc=**0x%x)", pSelf, streamType, pMediaInfo, pUri, ppDesc);
+	cellSail.todo("cellSailPlayerCreateDescriptor(pSelf=*0x%x, streamType=%d, pMediaInfo=*0x%x, pUri=*0x%x, ppDesc=**0x%x)", pSelf, streamType, pMediaInfo, pUri, ppDesc);
 	
 	u32 descriptorAddress = vm::alloc(sizeof(CellSailDescriptor), vm::main);
 	auto descriptor = vm::ptr<CellSailDescriptor>::make(descriptorAddress);
@@ -833,17 +833,17 @@ s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
 				}
 				else
 				{
-					cellSail.Warning("Couldn't open PAMF: %s", uri.c_str());
+					cellSail.warning("Couldn't open PAMF: %s", uri.c_str());
 				}
 			}
 			else
 			{
-				cellSail.Warning("Unhandled uri: %s", uri.c_str());
+				cellSail.warning("Unhandled uri: %s", uri.c_str());
 			}
 			break;
 		}
 		default:
-			cellSail.Error("Unhandled stream type: %d", streamType);
+			cellSail.error("Unhandled stream type: %d", streamType);
 	}
 
 	return CELL_OK;
@@ -851,7 +851,7 @@ s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
 
 s32 cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc)
 {
-	cellSail.Todo("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, pDesc);
+	cellSail.todo("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, pDesc);
 
 	if (pDesc->registered)
 		return CELL_SAIL_ERROR_INVALID_STATE;
@@ -861,7 +861,7 @@ s32 cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellS
 
 s32 cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> ppDesc)
 {
-	cellSail.Warning("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, ppDesc);
+	cellSail.warning("cellSailPlayerAddDescriptor(pSelf=*0x%x, pDesc=*0x%x)", pSelf, ppDesc);
 
 	if (pSelf->descriptors > 0)
 	{
@@ -876,7 +876,7 @@ s32 cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSa
 
 s32 cellSailPlayerGetDescriptorCount(vm::ptr<CellSailPlayer> pSelf)
 {
-	cellSail.Warning("cellSailPlayerGetDescriptorCount(pSelf=*0x%x)", pSelf);
+	cellSail.warning("cellSailPlayerGetDescriptorCount(pSelf=*0x%x)", pSelf);
 	return pSelf->descriptors;
 }
 
@@ -978,19 +978,19 @@ s32 cellSailPlayerCancel()
 
 s32 cellSailPlayerSetPaused(vm::ptr<CellSailPlayer> pSelf, b8 paused)
 {
-	cellSail.Todo("cellSailPlayerSetPaused(pSelf=*0x%x, paused=%d)", pSelf, paused);
+	cellSail.todo("cellSailPlayerSetPaused(pSelf=*0x%x, paused=%d)", pSelf, paused);
 	return CELL_OK;
 }
 
 s32 cellSailPlayerIsPaused(vm::ptr<CellSailPlayer> pSelf)
 {
-	cellSail.Warning("cellSailPlayerIsPaused(pSelf=*0x%x)", pSelf);
+	cellSail.warning("cellSailPlayerIsPaused(pSelf=*0x%x)", pSelf);
 	return pSelf->paused;
 }
 
 s32 cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, vm::ptr<CellSailStartCommand> pCommand)
 {
-	cellSail.Warning("cellSailPlayerSetRepeatMode(pSelf=*0x%x, repeatMode=%d, pCommand=*0x%x)", pSelf, repeatMode, pCommand);
+	cellSail.warning("cellSailPlayerSetRepeatMode(pSelf=*0x%x, repeatMode=%d, pCommand=*0x%x)", pSelf, repeatMode, pCommand);
 
 	pSelf->repeatMode = repeatMode;
 	pSelf->playbackCommand = pCommand;
@@ -1000,7 +1000,7 @@ s32 cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, v
 
 s32 cellSailPlayerGetRepeatMode(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailStartCommand> pCommand)
 {
-	cellSail.Warning("cellSailPlayerGetRepeatMode(pSelf=*0x%x, pCommand=*0x%x)", pSelf, pCommand);
+	cellSail.warning("cellSailPlayerGetRepeatMode(pSelf=*0x%x, pCommand=*0x%x)", pSelf, pCommand);
 
 	pCommand = pSelf->playbackCommand;
 

rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp

@@ -185,7 +185,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 			if (result->result < 0)
 			{
-				cellSysutil.Warning("savedata_op(): funcList returned < 0.");
+				cellSysutil.warning("savedata_op(): funcList returned < 0.");
 				return CELL_SAVEDATA_ERROR_CBRESULT;
 			}
 
@@ -267,7 +267,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 			}
 			default:
 			{
-				cellSysutil.Error("savedata_op(): unknown listSet->focusPosition (0x%x)", pos_type);
+				cellSysutil.error("savedata_op(): unknown listSet->focusPosition (0x%x)", pos_type);
 				return CELL_SAVEDATA_ERROR_PARAM;
 			}
 			}
@@ -295,7 +295,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 			if (result->result < 0)
 			{
-				cellSysutil.Warning("savedata_op(): funcFixed returned < 0.");
+				cellSysutil.warning("savedata_op(): funcFixed returned < 0.");
 				return CELL_SAVEDATA_ERROR_CBRESULT;
 			}
 
@@ -432,7 +432,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 		if (result->result < 0)
 		{
-			cellSysutil.Warning("savedata_op(): funcStat returned < 0.");
+			cellSysutil.warning("savedata_op(): funcStat returned < 0.");
 			return CELL_SAVEDATA_ERROR_CBRESULT;
 		}
 
@@ -464,7 +464,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 		{
 		case CELL_SAVEDATA_RECREATE_NO:
 		{
-			cellSaveData.Error("Savedata %s considered broken", save_entry.dirName);
+			cellSaveData.error("Savedata %s considered broken", save_entry.dirName);
 			// fallthrough
 		}
 
@@ -488,7 +488,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 			if (!statSet->setParam)
 			{
 				// Savedata deleted and setParam is NULL: delete directory and abort operation
-				if (Emu.GetVFS().RemoveDir(dir_path)) cellSysutil.Error("savedata_op(): savedata directory %s deleted", save_entry.dirName);
+				if (Emu.GetVFS().RemoveDir(dir_path)) cellSysutil.error("savedata_op(): savedata directory %s deleted", save_entry.dirName);
 
 				return CELL_OK;
 			}
@@ -498,7 +498,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 		default:
 		{
-			cellSysutil.Error("savedata_op(): unknown statSet->reCreateMode (0x%x)", statSet->reCreateMode);
+			cellSysutil.error("savedata_op(): unknown statSet->reCreateMode (0x%x)", statSet->reCreateMode);
 			return CELL_SAVEDATA_ERROR_PARAM;
 		}
 		}
@@ -521,7 +521,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 		if (result->result < 0)
 		{
-			cellSysutil.Warning("savedata_op(): funcFile returned < 0.");
+			cellSysutil.warning("savedata_op(): funcFile returned < 0.");
 			return CELL_SAVEDATA_ERROR_CBRESULT;
 		}
 
@@ -567,7 +567,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 		default:
 		{
-			cellSysutil.Error("savedata_op(): unknown fileSet->fileType (0x%x)", type);
+			cellSysutil.error("savedata_op(): unknown fileSet->fileType (0x%x)", type);
 			return CELL_SAVEDATA_ERROR_PARAM;
 		}
 		}
@@ -614,7 +614,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 
 		default:
 		{
-			cellSysutil.Error("savedata_op(): unknown fileSet->fileOperation (0x%x)", op);
+			cellSysutil.error("savedata_op(): unknown fileSet->fileOperation (0x%x)", op);
 			return CELL_SAVEDATA_ERROR_PARAM;
 		}
 		}
@@ -634,7 +634,7 @@ never_inline s32 savedata_op(PPUThread& ppu, u32 operation, u32 version, vm::cpt
 s32 cellSaveDataListSave2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncList funcList,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataListSave2(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataListSave2(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, setList, setBuf, funcList, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_SAVE, version, vm::null, 1, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -643,7 +643,7 @@ s32 cellSaveDataListSave2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataListLoad2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncList funcList,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataListLoad2(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataListLoad2(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, setList, setBuf, funcList, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_LOAD, version, vm::null, 1, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -652,7 +652,7 @@ s32 cellSaveDataListLoad2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataListSave(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncList funcList,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataListSave(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataListSave(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, setList, setBuf, funcList, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_SAVE, version, vm::null, 1, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -661,7 +661,7 @@ s32 cellSaveDataListSave(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataListLoad(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncList funcList,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataListLoad(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataListLoad(version=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, setList, setBuf, funcList, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_LOAD, version, vm::null, 1, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -671,7 +671,7 @@ s32 cellSaveDataListLoad(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataFixedSave2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataFixedSave2(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataFixedSave2(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_SAVE, version, vm::null, 1, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -680,7 +680,7 @@ s32 cellSaveDataFixedSave2(PPUThread& ppu, u32 version, PSetList setList, PSetBu
 s32 cellSaveDataFixedLoad2(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataFixedLoad2(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataFixedLoad2(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_LOAD, version, vm::null, 1, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -689,7 +689,7 @@ s32 cellSaveDataFixedLoad2(PPUThread& ppu, u32 version, PSetList setList, PSetBu
 s32 cellSaveDataFixedSave(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, 
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataFixedSave(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataFixedSave(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, setList, setBuf, funcFixed, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_SAVE, version, vm::null, 1, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -699,7 +699,7 @@ s32 cellSaveDataFixedSave(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataFixedLoad(PPUThread& ppu, u32 version, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataFixedLoad(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataFixedLoad(version=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, setList, setBuf, funcFixed, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_LOAD, version, vm::null, 1, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -708,7 +708,7 @@ s32 cellSaveDataFixedLoad(PPUThread& ppu, u32 version, PSetList setList, PSetBuf
 s32 cellSaveDataAutoSave2(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataAutoSave2(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataAutoSave2(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, dirName, errDialog, setBuf, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_SAVE, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -717,7 +717,7 @@ s32 cellSaveDataAutoSave2(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u
 s32 cellSaveDataAutoLoad2(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataAutoLoad2(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataAutoLoad2(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, dirName, errDialog, setBuf, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_LOAD, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 2, userdata, 0, vm::null);
@@ -726,7 +726,7 @@ s32 cellSaveDataAutoLoad2(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u
 s32 cellSaveDataAutoSave(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataAutoSave(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataAutoSave(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, dirName, errDialog, setBuf, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_SAVE, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -735,7 +735,7 @@ s32 cellSaveDataAutoSave(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u3
 s32 cellSaveDataAutoLoad(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf,
 	PFuncStat funcStat, PFuncFile funcFile, u32 container)
 {
-	cellSysutil.Warning("cellSaveDataAutoLoad(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
+	cellSysutil.warning("cellSaveDataAutoLoad(version=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x)",
 		version, dirName, errDialog, setBuf, funcStat, funcFile, container);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_LOAD, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 2, vm::null, 0, vm::null);
@@ -743,7 +743,7 @@ s32 cellSaveDataAutoLoad(PPUThread& ppu, u32 version, vm::cptr<char> dirName, u3
 
 s32 cellSaveDataListAutoSave(PPUThread& ppu, u32 version, u32 errDialog, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataListAutoSave(version=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataListAutoSave(version=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, errDialog, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_AUTO_SAVE, version, vm::null, errDialog, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 0, userdata, 0, vm::null);
@@ -751,7 +751,7 @@ s32 cellSaveDataListAutoSave(PPUThread& ppu, u32 version, u32 errDialog, PSetLis
 
 s32 cellSaveDataListAutoLoad(PPUThread& ppu, u32 version, u32 errDialog, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSaveDataListAutoLoad(version=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.warning("cellSaveDataListAutoLoad(version=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, errDialog, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_AUTO_LOAD, version, vm::null, errDialog, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 0, userdata, 0, vm::null);
@@ -759,21 +759,21 @@ s32 cellSaveDataListAutoLoad(PPUThread& ppu, u32 version, u32 errDialog, PSetLis
 
 s32 cellSaveDataDelete2(u32 container)
 {
-	cellSysutil.Todo("cellSaveDataDelete2(container=0x%x)", container);
+	cellSysutil.todo("cellSaveDataDelete2(container=0x%x)", container);
 
 	return CELL_SAVEDATA_RET_CANCEL;
 }
 
 s32 cellSaveDataDelete(u32 container)
 {
-	cellSysutil.Todo("cellSaveDataDelete(container=0x%x)", container);
+	cellSysutil.todo("cellSaveDataDelete(container=0x%x)", container);
 
 	return CELL_SAVEDATA_RET_CANCEL;
 }
 
 s32 cellSaveDataFixedDelete(PPUThread& ppu, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Todo("cellSaveDataFixedDelete(setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.todo("cellSaveDataFixedDelete(setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
 		setList, setBuf, funcFixed, funcDone, container, userdata);
 
 	return CELL_OK;
@@ -781,7 +781,7 @@ s32 cellSaveDataFixedDelete(PPUThread& ppu, PSetList setList, PSetBuf setBuf, PF
 
 s32 cellSaveDataUserListSave(PPUThread& ppu, u32 version, u32 userId, PSetList setList, PSetBuf setBuf, PFuncList funcList, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserListSave(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserListSave(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, setList, setBuf, funcList, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_SAVE, version, vm::null, 0, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -789,7 +789,7 @@ s32 cellSaveDataUserListSave(PPUThread& ppu, u32 version, u32 userId, PSetList s
 
 s32 cellSaveDataUserListLoad(PPUThread& ppu, u32 version, u32 userId, PSetList setList, PSetBuf setBuf, PFuncList funcList, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserListLoad(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserListLoad(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcList=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, setList, setBuf, funcList, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_LOAD, version, vm::null, 0, setList, setBuf, funcList, vm::null, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -797,7 +797,7 @@ s32 cellSaveDataUserListLoad(PPUThread& ppu, u32 version, u32 userId, PSetList s
 
 s32 cellSaveDataUserFixedSave(PPUThread& ppu, u32 version, u32 userId, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserFixedSave(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserFixedSave(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_SAVE, version, vm::null, 0, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -805,7 +805,7 @@ s32 cellSaveDataUserFixedSave(PPUThread& ppu, u32 version, u32 userId, PSetList
 
 s32 cellSaveDataUserFixedLoad(PPUThread& ppu, u32 version, u32 userId, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserFixedLoad(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserFixedLoad(version=%d, userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_FIXED_LOAD, version, vm::null, 0, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -813,7 +813,7 @@ s32 cellSaveDataUserFixedLoad(PPUThread& ppu, u32 version, u32 userId, PSetList
 
 s32 cellSaveDataUserAutoSave(PPUThread& ppu, u32 version, u32 userId, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserAutoSave(version=%d, userId=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserAutoSave(version=%d, userId=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, dirName, errDialog, setBuf, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_SAVE, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -821,7 +821,7 @@ s32 cellSaveDataUserAutoSave(PPUThread& ppu, u32 version, u32 userId, vm::cptr<c
 
 s32 cellSaveDataUserAutoLoad(PPUThread& ppu, u32 version, u32 userId, vm::cptr<char> dirName, u32 errDialog, PSetBuf setBuf, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserAutoLoad(version=%d, userId=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserAutoLoad(version=%d, userId=%d, dirName=*0x%x, errDialog=%d, setBuf=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, dirName, errDialog, setBuf, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_AUTO_LOAD, version, dirName, errDialog, vm::null, setBuf, vm::null, vm::null, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -829,7 +829,7 @@ s32 cellSaveDataUserAutoLoad(PPUThread& ppu, u32 version, u32 userId, vm::cptr<c
 
 s32 cellSaveDataUserListAutoSave(PPUThread& ppu, u32 version, u32 userId, u32 errDialog, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserListAutoSave(version=%d, userId=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserListAutoSave(version=%d, userId=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, errDialog, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_AUTO_SAVE, version, vm::null, errDialog, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -837,7 +837,7 @@ s32 cellSaveDataUserListAutoSave(PPUThread& ppu, u32 version, u32 userId, u32 er
 
 s32 cellSaveDataUserListAutoLoad(PPUThread& ppu, u32 version, u32 userId, u32 errDialog, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncStat funcStat, PFuncFile funcFile, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Error("cellSaveDataUserListAutoLoad(version=%d, userId=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.error("cellSaveDataUserListAutoLoad(version=%d, userId=%d, errDialog=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcStat=*0x%x, funcFile=*0x%x, container=0x%x, userdata=*0x%x)",
 		version, userId, errDialog, setList, setBuf, funcFixed, funcStat, funcFile, container, userdata);
 
 	return savedata_op(ppu, SAVEDATA_OP_LIST_AUTO_LOAD, version, vm::null, errDialog, setList, setBuf, vm::null, funcFixed, funcStat, funcFile, container, 6, userdata, userId, vm::null);
@@ -845,7 +845,7 @@ s32 cellSaveDataUserListAutoLoad(PPUThread& ppu, u32 version, u32 userId, u32 er
 
 s32 cellSaveDataUserFixedDelete(PPUThread& ppu, u32 userId, PSetList setList, PSetBuf setBuf, PFuncFixed funcFixed, PFuncDone funcDone, u32 container, vm::ptr<void> userdata)
 {
-	cellSysutil.Todo("cellSaveDataUserFixedDelete(userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
+	cellSysutil.todo("cellSaveDataUserFixedDelete(userId=%d, setList=*0x%x, setBuf=*0x%x, funcFixed=*0x%x, funcDone=*0x%x, container=0x%x, userdata=*0x%x)",
 		userId, setList, setBuf, funcFixed, funcDone, container, userdata);
 
 	return CELL_OK;
@@ -853,7 +853,7 @@ s32 cellSaveDataUserFixedDelete(PPUThread& ppu, u32 userId, PSetList setList, PS
 
 void cellSaveDataEnableOverlay(s32 enable)
 {
-	cellSysutil.Error("cellSaveDataEnableOverlay(enable=%d)", enable);
+	cellSysutil.error("cellSaveDataEnableOverlay(enable=%d)", enable);
 
 	return;
 }

rpcs3/Emu/SysCalls/Modules/cellSearch.cpp

@@ -8,7 +8,7 @@ extern Module<> cellSearch;
 
 s32 cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchSystemCallback> func, vm::ptr<u32> userData)
 {
-	cellSearch.Warning("cellSearchInitialize()");
+	cellSearch.warning("cellSearchInitialize()");
 
 	// TODO: Store the arguments somewhere so we can use them later.
 
@@ -17,7 +17,7 @@ s32 cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchS
 
 s32 cellSearchFinalize()
 {
-	cellSearch.Warning("cellSearchFinalize()");
+	cellSearch.warning("cellSearchFinalize()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp

@@ -1185,7 +1185,7 @@ s32 _spurs::initialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, u32 revision, u
 /// Initialize SPURS
 s32 cellSpursInitialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork)
 {
-	cellSpurs.Warning("cellSpursInitialize(spurs=*0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs, nSpus, spuPriority, ppuPriority, exitIfNoWork);
+	cellSpurs.warning("cellSpursInitialize(spurs=*0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs, nSpus, spuPriority, ppuPriority, exitIfNoWork);
 
 	return _spurs::initialize(ppu, spurs, 0, 0, nSpus, spuPriority, ppuPriority, exitIfNoWork ? SAF_EXIT_IF_NO_WORK : SAF_NONE, vm::null, 0, 0, vm::null, 0, 0);
 }
@@ -1193,7 +1193,7 @@ s32 cellSpursInitialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, s32 nSpus, s32
 /// Initialise SPURS
 s32 cellSpursInitializeWithAttribute(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
 {
-	cellSpurs.Warning("cellSpursInitializeWithAttribute(spurs=*0x%x, attr=*0x%x)", spurs, attr);
+	cellSpurs.warning("cellSpursInitializeWithAttribute(spurs=*0x%x, attr=*0x%x)", spurs, attr);
 
 	if (!attr)
 	{
@@ -1230,7 +1230,7 @@ s32 cellSpursInitializeWithAttribute(PPUThread& ppu, vm::ptr<CellSpurs> spurs, v
 /// Initialise SPURS
 s32 cellSpursInitializeWithAttribute2(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursAttribute> attr)
 {
-	cellSpurs.Warning("cellSpursInitializeWithAttribute2(spurs=*0x%x, attr=*0x%x)", spurs, attr);
+	cellSpurs.warning("cellSpursInitializeWithAttribute2(spurs=*0x%x, attr=*0x%x)", spurs, attr);
 
 	if (!attr)
 	{
@@ -1267,7 +1267,7 @@ s32 cellSpursInitializeWithAttribute2(PPUThread& ppu, vm::ptr<CellSpurs> spurs,
 /// Initialise SPURS attribute
 s32 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, b8 exitIfNoWork)
 {
-	cellSpurs.Warning("_cellSpursAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
+	cellSpurs.warning("_cellSpursAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
 		attr, revision, sdkVersion, nSpus, spuPriority, ppuPriority, exitIfNoWork);
 
 	if (!attr)
@@ -1293,7 +1293,7 @@ s32 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision
 /// Set memory container ID for creating the SPU thread group
 s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container)
 {
-	cellSpurs.Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr=*0x%x, container=0x%x)", attr, container);
+	cellSpurs.warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr=*0x%x, container=0x%x)", attr, container);
 
 	if (!attr)
 	{
@@ -1318,7 +1318,7 @@ s32 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute>
 /// Set the prefix for SPURS
 s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::cptr<char> prefix, u32 size)
 {
-	cellSpurs.Warning("cellSpursAttributeSetNamePrefix(attr=*0x%x, prefix=*0x%x, size=%d)", attr, prefix, size);
+	cellSpurs.warning("cellSpursAttributeSetNamePrefix(attr=*0x%x, prefix=*0x%x, size=%d)", attr, prefix, size);
 
 	if (!attr || !prefix)
 	{
@@ -1343,7 +1343,7 @@ s32 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::cptr<c
 /// Enable spu_printf()
 s32 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr<CellSpursAttribute> attr)
 {
-	cellSpurs.Warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr=*0x%x)", attr);
+	cellSpurs.warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr=*0x%x)", attr);
 
 	if (!attr)
 	{
@@ -1362,7 +1362,7 @@ s32 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr<CellSpursAttribute> att
 /// Set the type of SPU thread group
 s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s32 type)
 {
-	cellSpurs.Warning("cellSpursAttributeSetSpuThreadGroupType(attr=*0x%x, type=%d)", attr, type);
+	cellSpurs.warning("cellSpursAttributeSetSpuThreadGroupType(attr=*0x%x, type=%d)", attr, type);
 
 	if (!attr)
 	{
@@ -1397,7 +1397,7 @@ s32 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s3
 /// Enable the system workload
 s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::cptr<u8[8]> priority, u32 maxSpu, vm::cptr<b8[8]> isPreemptible)
 {
-	cellSpurs.Warning("cellSpursAttributeEnableSystemWorkload(attr=*0x%x, priority=*0x%x, maxSpu=%d, isPreemptible=*0x%x)", attr, priority, maxSpu, isPreemptible);
+	cellSpurs.warning("cellSpursAttributeEnableSystemWorkload(attr=*0x%x, priority=*0x%x, maxSpu=%d, isPreemptible=*0x%x)", attr, priority, maxSpu, isPreemptible);
 
 	if (!attr)
 	{
@@ -1459,7 +1459,7 @@ s32 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
 /// Release resources allocated for SPURS
 s32 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Todo("cellSpursFinalize(spurs=*0x%x)", spurs);
+	cellSpurs.todo("cellSpursFinalize(spurs=*0x%x)", spurs);
 
 	if (!spurs)
 	{
@@ -1494,7 +1494,7 @@ s32 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
 /// Get the SPU thread group ID
 s32 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> group)
 {
-	cellSpurs.Warning("cellSpursGetSpuThreadGroupId(spurs=*0x%x, group=*0x%x)", spurs, group);
+	cellSpurs.warning("cellSpursGetSpuThreadGroupId(spurs=*0x%x, group=*0x%x)", spurs, group);
 
 	if (!spurs || !group)
 	{
@@ -1513,7 +1513,7 @@ s32 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> group)
 // Get the number of SPU threads
 s32 cellSpursGetNumSpuThread(vm::ptr<CellSpurs> spurs, vm::ptr<u32> nThreads)
 {
-	cellSpurs.Warning("cellSpursGetNumSpuThread(spurs=*0x%x, nThreads=*0x%x)", spurs, nThreads);
+	cellSpurs.warning("cellSpursGetNumSpuThread(spurs=*0x%x, nThreads=*0x%x)", spurs, nThreads);
 
 	if (!spurs || !nThreads)
 	{
@@ -1532,7 +1532,7 @@ s32 cellSpursGetNumSpuThread(vm::ptr<CellSpurs> spurs, vm::ptr<u32> nThreads)
 /// Get SPU thread ids
 s32 cellSpursGetSpuThreadId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> thread, vm::ptr<u32> nThreads)
 {
-	cellSpurs.Warning("cellSpursGetSpuThreadId(spurs=*0x%x, thread=*0x%x, nThreads=*0x%x)", spurs, thread, nThreads);
+	cellSpurs.warning("cellSpursGetSpuThreadId(spurs=*0x%x, thread=*0x%x, nThreads=*0x%x)", spurs, thread, nThreads);
 
 	if (!spurs || !thread || !nThreads)
 	{
@@ -1558,7 +1558,7 @@ s32 cellSpursGetSpuThreadId(vm::ptr<CellSpurs> spurs, vm::ptr<u32> thread, vm::p
 /// Set the maximum contention for a workload
 s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 wid, u32 maxContention)
 {
-	cellSpurs.Warning("cellSpursSetMaxContention(spurs=*0x%x, wid=%d, maxContention=%d)", spurs, wid, maxContention);
+	cellSpurs.warning("cellSpursSetMaxContention(spurs=*0x%x, wid=%d, maxContention=%d)", spurs, wid, maxContention);
 
 	if (!spurs)
 	{
@@ -1602,7 +1602,7 @@ s32 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 wid, u32 maxContenti
 /// Set the priority of a workload on each SPU
 s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> priorities)
 {
-	cellSpurs.Warning("cellSpursSetPriorities(spurs=*0x%x, wid=%d, priorities=*0x%x)", spurs, wid, priorities);
+	cellSpurs.warning("cellSpursSetPriorities(spurs=*0x%x, wid=%d, priorities=*0x%x)", spurs, wid, priorities);
 
 	if (!spurs)
 	{
@@ -1657,7 +1657,7 @@ s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> prior
 /// Set the priority of a workload for the specified SPU
 s32 cellSpursSetPriority(vm::ptr<CellSpurs> spurs, u32 wid, u32 spuId, u32 priority)
 {
-	cellSpurs.Todo("cellSpursSetPriority(spurs=*0x%x, wid=%d, spuId=%d, priority=%d)", spurs, wid, spuId, priority);
+	cellSpurs.todo("cellSpursSetPriority(spurs=*0x%x, wid=%d, spuId=%d, priority=%d)", spurs, wid, spuId, priority);
 	return CELL_OK;
 }
 
@@ -1671,7 +1671,7 @@ s32 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::cptr<b8> isP
 /// Attach an LV2 event queue to a SPURS instance
 s32 cellSpursAttachLv2EventQueue(PPUThread& ppu, vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic)
 {
-	cellSpurs.Warning("cellSpursAttachLv2EventQueue(spurs=*0x%x, queue=0x%x, port=*0x%x, isDynamic=%d)", spurs, queue, port, isDynamic);
+	cellSpurs.warning("cellSpursAttachLv2EventQueue(spurs=*0x%x, queue=0x%x, port=*0x%x, isDynamic=%d)", spurs, queue, port, isDynamic);
 
 	return _spurs::attach_lv2_eq(ppu, spurs, queue, port, isDynamic, false);
 }
@@ -1679,14 +1679,14 @@ s32 cellSpursAttachLv2EventQueue(PPUThread& ppu, vm::ptr<CellSpurs> spurs, u32 q
 /// Detach an LV2 event queue from a SPURS instance
 s32 cellSpursDetachLv2EventQueue(vm::ptr<CellSpurs> spurs, u8 port)
 {
-	cellSpurs.Warning("cellSpursDetachLv2EventQueue(spurs=*0x%x, port=%d)", spurs, port);
+	cellSpurs.warning("cellSpursDetachLv2EventQueue(spurs=*0x%x, port=%d)", spurs, port);
 
 	return _spurs::detach_lv2_eq(spurs, port, false);
 }
 
 s32 cellSpursEnableExceptionEventHandler(vm::ptr<CellSpurs> spurs, b8 flag)
 {
-	cellSpurs.Warning("cellSpursEnableExceptionEventHandler(spurs=*0x%x, flag=%d)", spurs, flag);
+	cellSpurs.warning("cellSpursEnableExceptionEventHandler(spurs=*0x%x, flag=%d)", spurs, flag);
 
 	if (!spurs)
 	{
@@ -1721,7 +1721,7 @@ s32 cellSpursEnableExceptionEventHandler(vm::ptr<CellSpurs> spurs, b8 flag)
 /// Set the global SPU exception event handler
 s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursGlobalExceptionEventHandler> eaHandler, vm::ptr<void> arg)
 {
-	cellSpurs.Warning("cellSpursSetGlobalExceptionEventHandler(spurs=*0x%x, eaHandler=*0x%x, arg=*0x%x)", spurs, eaHandler, arg);
+	cellSpurs.warning("cellSpursSetGlobalExceptionEventHandler(spurs=*0x%x, eaHandler=*0x%x, arg=*0x%x)", spurs, eaHandler, arg);
 
 	if (!spurs || !eaHandler)
 	{
@@ -1753,7 +1753,7 @@ s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, vm::ptr<Ce
 /// Remove the global SPU exception event handler
 s32 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs=*0x%x)", spurs);
+	cellSpurs.warning("cellSpursUnsetGlobalExceptionEventHandler(spurs=*0x%x)", spurs);
 
 	spurs->globalSpuExceptionHandlerArgs = 0;
 	spurs->globalSpuExceptionHandler.exchange(0);
@@ -1855,7 +1855,7 @@ s32 _spurs::trace_initialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<C
 /// Initialize SPURS trace
 s32 cellSpursTraceInitialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTraceInfo> buffer, u32 size, u32 mode)
 {
-	cellSpurs.Warning("cellSpursTraceInitialize(spurs=*0x%x, buffer=*0x%x, size=0x%x, mode=0x%x)", spurs, buffer, size, mode);
+	cellSpurs.warning("cellSpursTraceInitialize(spurs=*0x%x, buffer=*0x%x, size=0x%x, mode=0x%x)", spurs, buffer, size, mode);
 
 	if (_spurs::is_libprof_loaded())
 	{
@@ -1868,7 +1868,7 @@ s32 cellSpursTraceInitialize(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<C
 /// Finalize SPURS trace
 s32 cellSpursTraceFinalize(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Warning("cellSpursTraceFinalize(spurs=*0x%x)", spurs);
+	cellSpurs.warning("cellSpursTraceFinalize(spurs=*0x%x)", spurs);
 
 	if (!spurs)
 	{
@@ -1923,7 +1923,7 @@ s32 _spurs::trace_start(PPUThread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStat
 /// Start SPURS trace
 s32 cellSpursTraceStart(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Warning("cellSpursTraceStart(spurs=*0x%x)", spurs);
+	cellSpurs.warning("cellSpursTraceStart(spurs=*0x%x)", spurs);
 
 	if (!spurs)
 	{
@@ -1967,7 +1967,7 @@ s32 _spurs::trace_stop(PPUThread& ppu, vm::ptr<CellSpurs> spurs, u32 updateStatu
 /// Stop SPURS trace
 s32 cellSpursTraceStop(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Warning("cellSpursTraceStop(spurs=*0x%x)", spurs);
+	cellSpurs.warning("cellSpursTraceStop(spurs=*0x%x)", spurs);
 
 	if (!spurs)
 	{
@@ -1989,7 +1989,7 @@ s32 cellSpursTraceStop(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 /// Initialize attributes of a workload
 s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> attr, u32 revision, u32 sdkVersion, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
 {
-	cellSpurs.Warning("_cellSpursWorkloadAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
+	cellSpurs.warning("_cellSpursWorkloadAttributeInitialize(attr=*0x%x, revision=%d, sdkVersion=0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
 		attr, revision, sdkVersion, pm, size, data, priority, minCnt, maxCnt);
 
 	if (!attr)
@@ -2032,7 +2032,7 @@ s32 _cellSpursWorkloadAttributeInitialize(vm::ptr<CellSpursWorkloadAttribute> at
 /// Set the name of a workload
 s32 cellSpursWorkloadAttributeSetName(vm::ptr<CellSpursWorkloadAttribute> attr, vm::cptr<char> nameClass, vm::cptr<char> nameInstance)
 {
-	cellSpurs.Warning("cellSpursWorkloadAttributeSetName(attr=*0x%x, nameClass=*0x%x, nameInstance=*0x%x)", attr, nameClass, nameInstance);
+	cellSpurs.warning("cellSpursWorkloadAttributeSetName(attr=*0x%x, nameClass=*0x%x, nameInstance=*0x%x)", attr, nameClass, nameInstance);
 
 	if (!attr)
 	{
@@ -2052,7 +2052,7 @@ s32 cellSpursWorkloadAttributeSetName(vm::ptr<CellSpursWorkloadAttribute> attr,
 /// Set a hook function for shutdown completion event of a workload
 s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook(vm::ptr<CellSpursWorkloadAttribute> attr, vm::ptr<CellSpursShutdownCompletionEventHook> hook, vm::ptr<void> arg)
 {
-	cellSpurs.Warning("cellSpursWorkloadAttributeSetShutdownCompletionEventHook(attr=*0x%x, hook=*0x%x, arg=*0x%x)", attr, hook, arg);
+	cellSpurs.warning("cellSpursWorkloadAttributeSetShutdownCompletionEventHook(attr=*0x%x, hook=*0x%x, arg=*0x%x)", attr, hook, arg);
 
 	if (!attr || !hook)
 	{
@@ -2237,7 +2237,7 @@ s32 _spurs::add_workload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
 /// Add workload
 s32 cellSpursAddWorkload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<void> pm, u32 size, u64 data, vm::cptr<u8[8]> priority, u32 minCnt, u32 maxCnt)
 {
-	cellSpurs.Warning("cellSpursAddWorkload(spurs=*0x%x, wid=*0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
+	cellSpurs.warning("cellSpursAddWorkload(spurs=*0x%x, wid=*0x%x, pm=*0x%x, size=0x%x, data=0x%llx, priority=*0x%x, minCnt=0x%x, maxCnt=0x%x)",
 		spurs, wid, pm, size, data, priority, minCnt, maxCnt);
 
 	return _spurs::add_workload(spurs, wid, pm, size, data, *priority, minCnt, maxCnt, vm::null, vm::null, vm::null, vm::null);
@@ -2246,7 +2246,7 @@ s32 cellSpursAddWorkload(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<vo
 /// Add workload
 s32 cellSpursAddWorkloadWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<u32> wid, vm::cptr<CellSpursWorkloadAttribute> attr)
 {
-	cellSpurs.Warning("cellSpursAddWorkloadWithAttribute(spurs=*0x%x, wid=*0x%x, attr=*0x%x)", spurs, wid, attr);
+	cellSpurs.warning("cellSpursAddWorkloadWithAttribute(spurs=*0x%x, wid=*0x%x, attr=*0x%x)", spurs, wid, attr);
 
 	if (!attr)
 	{
@@ -2289,7 +2289,7 @@ s32 cellSpursRemoveWorkload()
 
 s32 cellSpursWakeUp(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs.Warning("cellSpursWakeUp(spurs=*0x%x)", spurs);
+	cellSpurs.warning("cellSpursWakeUp(spurs=*0x%x)", spurs);
 
 	if (!spurs)
 	{
@@ -2319,7 +2319,7 @@ s32 cellSpursWakeUp(PPUThread& ppu, vm::ptr<CellSpurs> spurs)
 /// Send a workload signal
 s32 cellSpursSendWorkloadSignal(vm::ptr<CellSpurs> spurs, u32 wid)
 {
-	cellSpurs.Warning("cellSpursSendWorkloadSignal(spurs=*0x%x, wid=%d)", spurs, wid);
+	cellSpurs.warning("cellSpursSendWorkloadSignal(spurs=*0x%x, wid=%d)", spurs, wid);
 
 	if (!spurs)
 	{
@@ -2366,7 +2366,7 @@ s32 cellSpursSendWorkloadSignal(vm::ptr<CellSpurs> spurs, u32 wid)
 /// Get the address of the workload flag
 s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloadFlag> flag)
 {
-	cellSpurs.Warning("cellSpursGetWorkloadFlag(spurs=*0x%x, flag=**0x%x)", spurs, flag);
+	cellSpurs.warning("cellSpursGetWorkloadFlag(spurs=*0x%x, flag=**0x%x)", spurs, flag);
 
 	if (!spurs || !flag)
 	{
@@ -2385,7 +2385,7 @@ s32 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursWorkloa
 /// Set ready count
 s32 cellSpursReadyCountStore(vm::ptr<CellSpurs> spurs, u32 wid, u32 value)
 {
-	cellSpurs.Warning("cellSpursReadyCountStore(spurs=*0x%x, wid=%d, value=0x%x)", spurs, wid, value);
+	cellSpurs.warning("cellSpursReadyCountStore(spurs=*0x%x, wid=%d, value=0x%x)", spurs, wid, value);
 
 	if (!spurs)
 	{
@@ -2448,7 +2448,7 @@ s32 cellSpursReadyCountAdd()
 /// Get workload's data to be passed to policy module
 s32 cellSpursGetWorkloadData(vm::ptr<CellSpurs> spurs, vm::ptr<u64> data, u32 wid)
 {
-	cellSpurs.Warning("cellSpursGetWorkloadData(spurs=*0x%x, data=*0x%x, wid=%d)", spurs, data, wid);
+	cellSpurs.warning("cellSpursGetWorkloadData(spurs=*0x%x, data=*0x%x, wid=%d)", spurs, data, wid);
 
 	if (!spurs || !data)
 	{
@@ -2511,7 +2511,7 @@ s32 cellSpursUnsetExceptionEventHandler()
 /// Set/unset the recipient of the workload flag
 s32 _cellSpursWorkloadFlagReceiver(vm::ptr<CellSpurs> spurs, u32 wid, u32 is_set)
 {
-	cellSpurs.Warning("_cellSpursWorkloadFlagReceiver(spurs=*0x%x, wid=%d, is_set=%d)", spurs, wid, is_set);
+	cellSpurs.warning("_cellSpursWorkloadFlagReceiver(spurs=*0x%x, wid=%d, is_set=%d)", spurs, wid, is_set);
 
 	if (!spurs)
 	{
@@ -2604,7 +2604,7 @@ s32 cellSpursRequestIdleSpu()
 /// Initialize a SPURS event flag
 s32 _cellSpursEventFlagInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
 {
-	cellSpurs.Warning("_cellSpursEventFlagInitialize(spurs=*0x%x, taskset=*0x%x, eventFlag=*0x%x, flagClearMode=%d, flagDirection=%d)", spurs, taskset, eventFlag, flagClearMode, flagDirection);
+	cellSpurs.warning("_cellSpursEventFlagInitialize(spurs=*0x%x, taskset=*0x%x, eventFlag=*0x%x, flagClearMode=%d, flagDirection=%d)", spurs, taskset, eventFlag, flagClearMode, flagDirection);
 
 	if ((!taskset && !spurs) || !eventFlag)
 	{
@@ -2647,7 +2647,7 @@ s32 _cellSpursEventFlagInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTas
 /// Reset a SPURS event flag
 s32 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
 {
-	cellSpurs.Warning("cellSpursEventFlagClear(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);
+	cellSpurs.warning("cellSpursEventFlagClear(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);
 
 	if (!eventFlag)
 	{
@@ -2666,7 +2666,7 @@ s32 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
 /// Set a SPURS event flag
 s32 cellSpursEventFlagSet(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
 {
-	cellSpurs.Warning("cellSpursEventFlagSet(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);
+	cellSpurs.warning("cellSpursEventFlagSet(eventFlag=*0x%x, bits=0x%x)", eventFlag, bits);
 
 	if (!eventFlag)
 	{
@@ -2949,7 +2949,7 @@ s32 _spurs::event_flag_wait(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFla
 /// Wait for SPURS event flag
 s32 cellSpursEventFlagWait(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode)
 {
-	cellSpurs.Warning("cellSpursEventFlagWait(eventFlag=*0x%x, mask=*0x%x, mode=%d)", eventFlag, mask, mode);
+	cellSpurs.warning("cellSpursEventFlagWait(eventFlag=*0x%x, mask=*0x%x, mode=%d)", eventFlag, mask, mode);
 
 	return _spurs::event_flag_wait(ppu, eventFlag, mask, mode, 1);
 }
@@ -2957,7 +2957,7 @@ s32 cellSpursEventFlagWait(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFlag
 /// Check SPURS event flag
 s32 cellSpursEventFlagTryWait(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u16> mask, u32 mode)
 {
-	cellSpurs.Warning("cellSpursEventFlagTryWait(eventFlag=*0x%x, mask=*0x%x, mode=0x%x)", eventFlag, mask, mode);
+	cellSpurs.warning("cellSpursEventFlagTryWait(eventFlag=*0x%x, mask=*0x%x, mode=0x%x)", eventFlag, mask, mode);
 
 	return _spurs::event_flag_wait(ppu, eventFlag, mask, mode, 0);
 }
@@ -2965,7 +2965,7 @@ s32 cellSpursEventFlagTryWait(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventF
 /// Attach an LV2 event queue to a SPURS event flag
 s32 cellSpursEventFlagAttachLv2EventQueue(PPUThread& ppu, vm::ptr<CellSpursEventFlag> eventFlag)
 {
-	cellSpurs.Warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag=*0x%x)", eventFlag);
+	cellSpurs.warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag=*0x%x)", eventFlag);
 
 	if (!eventFlag)
 	{
@@ -3049,7 +3049,7 @@ s32 cellSpursEventFlagAttachLv2EventQueue(PPUThread& ppu, vm::ptr<CellSpursEvent
 /// Detach an LV2 event queue from SPURS event flag
 s32 cellSpursEventFlagDetachLv2EventQueue(vm::ptr<CellSpursEventFlag> eventFlag)
 {
-	cellSpurs.Warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag=*0x%x)", eventFlag);
+	cellSpurs.warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag=*0x%x)", eventFlag);
 
 	if (!eventFlag)
 	{
@@ -3110,7 +3110,7 @@ s32 cellSpursEventFlagDetachLv2EventQueue(vm::ptr<CellSpursEventFlag> eventFlag)
 /// Get send-receive direction of the SPURS event flag
 s32 cellSpursEventFlagGetDirection(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> direction)
 {
-	cellSpurs.Warning("cellSpursEventFlagGetDirection(eventFlag=*0x%x, direction=*0x%x)", eventFlag, direction);
+	cellSpurs.warning("cellSpursEventFlagGetDirection(eventFlag=*0x%x, direction=*0x%x)", eventFlag, direction);
 
 	if (!eventFlag || !direction)
 	{
@@ -3129,7 +3129,7 @@ s32 cellSpursEventFlagGetDirection(vm::ptr<CellSpursEventFlag> eventFlag, vm::pt
 /// Get clearing mode of SPURS event flag
 s32 cellSpursEventFlagGetClearMode(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<u32> clear_mode)
 {
-	cellSpurs.Warning("cellSpursEventFlagGetClearMode(eventFlag=*0x%x, clear_mode=*0x%x)", eventFlag, clear_mode);
+	cellSpurs.warning("cellSpursEventFlagGetClearMode(eventFlag=*0x%x, clear_mode=*0x%x)", eventFlag, clear_mode);
 
 	if (!eventFlag || !clear_mode)
 	{
@@ -3148,7 +3148,7 @@ s32 cellSpursEventFlagGetClearMode(vm::ptr<CellSpursEventFlag> eventFlag, vm::pt
 /// Get address of taskset to which the SPURS event flag belongs
 s32 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, vm::pptr<CellSpursTaskset> taskset)
 {
-	cellSpurs.Warning("cellSpursEventFlagGetTasksetAddress(eventFlag=*0x%x, taskset=**0x%x)", eventFlag, taskset);
+	cellSpurs.warning("cellSpursEventFlagGetTasksetAddress(eventFlag=*0x%x, taskset=**0x%x)", eventFlag, taskset);
 
 	if (!eventFlag || !taskset)
 	{
@@ -3166,7 +3166,7 @@ s32 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, v
 
 s32 _cellSpursLFQueueInitialize(vm::ptr<void> pTasksetOrSpurs, vm::ptr<CellSpursLFQueue> pQueue, vm::cptr<void> buffer, u32 size, u32 depth, u32 direction)
 {
-	cellSpurs.Todo("_cellSpursLFQueueInitialize(pTasksetOrSpurs=*0x%x, pQueue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x, direction=%d)", pTasksetOrSpurs, pQueue, buffer, size, depth, direction);
+	cellSpurs.todo("_cellSpursLFQueueInitialize(pTasksetOrSpurs=*0x%x, pQueue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x, direction=%d)", pTasksetOrSpurs, pQueue, buffer, size, depth, direction);
 
 	return SyncErrorToSpursError(cellSyncLFQueueInitialize(pQueue, buffer, size, depth, direction, pTasksetOrSpurs));
 }
@@ -3311,7 +3311,7 @@ s32 _spurs::create_taskset(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<Cel
 
 s32 cellSpursCreateTasksetWithAttribute(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute> attr)
 {
-	cellSpurs.Warning("cellSpursCreateTasksetWithAttribute(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);
+	cellSpurs.warning("cellSpursCreateTasksetWithAttribute(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);
 
 	if (!attr)
 	{
@@ -3340,14 +3340,14 @@ s32 cellSpursCreateTasksetWithAttribute(PPUThread& ppu, vm::ptr<CellSpurs> spurs
 
 s32 cellSpursCreateTaskset(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::cptr<u8[8]> priority, u32 maxContention)
 {
-	cellSpurs.Warning("cellSpursCreateTaskset(spurs=*0x%x, taskset=*0x%x, args=0x%llx, priority=*0x%x, maxContention=%d)", spurs, taskset, args, priority, maxContention);
+	cellSpurs.warning("cellSpursCreateTaskset(spurs=*0x%x, taskset=*0x%x, args=0x%llx, priority=*0x%x, maxContention=%d)", spurs, taskset, args, priority, maxContention);
 
 	return _spurs::create_taskset(ppu, spurs, taskset, args, priority, maxContention, vm::null, sizeof32(CellSpursTaskset), 0);
 }
 
 s32 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset)
 {
-	cellSpurs.Warning("cellSpursJoinTaskset(taskset=*0x%x)", taskset);
+	cellSpurs.warning("cellSpursJoinTaskset(taskset=*0x%x)", taskset);
 
 	UNIMPLEMENTED_FUNC(cellSpurs);
 	return CELL_OK;
@@ -3355,7 +3355,7 @@ s32 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset)
 
 s32 cellSpursGetTasksetId(vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> wid)
 {
-	cellSpurs.Warning("cellSpursGetTasksetId(taskset=*0x%x, wid=*0x%x)", taskset, wid);
+	cellSpurs.warning("cellSpursGetTasksetId(taskset=*0x%x, wid=*0x%x)", taskset, wid);
 
 	if (!taskset || !wid)
 	{
@@ -3505,7 +3505,7 @@ s32 _spurs::task_start(PPUThread& ppu, vm::ptr<CellSpursTaskset> taskset, u32 ta
 
 s32 cellSpursCreateTask(PPUThread& ppu, vm::ptr<CellSpursTaskset> taskset, vm::ptr<u32> taskId, vm::cptr<void> elf, vm::cptr<void> context, u32 size, vm::ptr<CellSpursTaskLsPattern> lsPattern, vm::ptr<CellSpursTaskArgument> argument)
 {
-	cellSpurs.Warning("cellSpursCreateTask(taskset=*0x%x, taskID=*0x%x, elf=*0x%x, context=*0x%x, size=0x%x, lsPattern=*0x%x, argument=*0x%x)", taskset, taskId, elf, context, size, lsPattern, argument);
+	cellSpurs.warning("cellSpursCreateTask(taskset=*0x%x, taskID=*0x%x, elf=*0x%x, context=*0x%x, size=0x%x, lsPattern=*0x%x, argument=*0x%x)", taskset, taskId, elf, context, size, lsPattern, argument);
 
 	if (!taskset)
 	{
@@ -3586,7 +3586,7 @@ s32 cellSpursCreateTaskWithAttribute()
 
 s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm::cptr<char> name)
 {
-	cellSpurs.Warning("cellSpursTasksetAttributeSetName(attr=*0x%x, name=*0x%x)", attr, name);
+	cellSpurs.warning("cellSpursTasksetAttributeSetName(attr=*0x%x, name=*0x%x)", attr, name);
 
 	if (!attr || !name)
 	{
@@ -3604,7 +3604,7 @@ s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm
 
 s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> attr, u32 size)
 {
-	cellSpurs.Warning("cellSpursTasksetAttributeSetTasksetSize(attr=*0x%x, size=0x%x)", attr, size);
+	cellSpurs.warning("cellSpursTasksetAttributeSetTasksetSize(attr=*0x%x, size=0x%x)", attr, size);
 
 	if (!attr)
 	{
@@ -3627,7 +3627,7 @@ s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> a
 
 s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr<CellSpursTasksetAttribute> attr, s32 enable)
 {
-	cellSpurs.Warning("cellSpursTasksetAttributeEnableClearLS(attr=*0x%x, enable=%d)", attr, enable);
+	cellSpurs.warning("cellSpursTasksetAttributeEnableClearLS(attr=*0x%x, enable=%d)", attr, enable);
 
 	if (!attr)
 	{
@@ -3645,7 +3645,7 @@ s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr<CellSpursTasksetAttribute> at
 
 s32 _cellSpursTasksetAttribute2Initialize(vm::ptr<CellSpursTasksetAttribute2> attribute, u32 revision)
 {
-	cellSpurs.Warning("_cellSpursTasksetAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);
+	cellSpurs.warning("_cellSpursTasksetAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);
 
 	memset(attribute.get_ptr(), 0, sizeof(CellSpursTasksetAttribute2));
 	attribute->revision = revision;
@@ -3713,7 +3713,7 @@ s32 cellSpursTaskAttributeSetExitCodeContainer()
 
 s32 _cellSpursTaskAttribute2Initialize(vm::ptr<CellSpursTaskAttribute2> attribute, u32 revision)
 {
-	cellSpurs.Warning("_cellSpursTaskAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);
+	cellSpurs.warning("_cellSpursTaskAttribute2Initialize(attribute=*0x%x, revision=%d)", attribute, revision);
 
 	attribute->revision = revision;
 	attribute->sizeContext = 0;
@@ -3737,7 +3737,7 @@ s32 cellSpursTaskGetContextSaveAreaSize()
 
 s32 cellSpursCreateTaskset2(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute2> attr)
 {
-	cellSpurs.Warning("cellSpursCreateTaskset2(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);
+	cellSpurs.warning("cellSpursCreateTaskset2(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);
 
 	vm::var<CellSpursTasksetAttribute2> tmp_attr;
 
@@ -3793,7 +3793,7 @@ s32 cellSpursCreateTask2WithBinInfo()
 
 s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetExceptionEventHandler> handler, vm::ptr<u64> arg)
 {
-	cellSpurs.Warning("cellSpursTasksetSetExceptionEventHandler(taskset=*0x%x, handler=*0x%x, arg=*0x%x)", taskset, handler, arg);
+	cellSpurs.warning("cellSpursTasksetSetExceptionEventHandler(taskset=*0x%x, handler=*0x%x, arg=*0x%x)", taskset, handler, arg);
 
 	if (!taskset || !handler)
 	{
@@ -3822,7 +3822,7 @@ s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset,
 
 s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset)
 {
-	cellSpurs.Warning("cellSpursTasksetUnsetExceptionEventHandler(taskset=*0x%x)", taskset);
+	cellSpurs.warning("cellSpursTasksetUnsetExceptionEventHandler(taskset=*0x%x)", taskset);
 
 	if (!taskset)
 	{
@@ -3846,7 +3846,7 @@ s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset
 
 s32 cellSpursLookUpTasksetAddress(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::pptr<CellSpursTaskset> taskset, u32 id)
 {
-	cellSpurs.Warning("cellSpursLookUpTasksetAddress(spurs=*0x%x, taskset=**0x%x, id=0x%x)", spurs, taskset, id);
+	cellSpurs.warning("cellSpursLookUpTasksetAddress(spurs=*0x%x, taskset=**0x%x, id=0x%x)", spurs, taskset, id);
 
 	if (!taskset)
 	{
@@ -3866,7 +3866,7 @@ s32 cellSpursLookUpTasksetAddress(PPUThread& ppu, vm::ptr<CellSpurs> spurs, vm::
 
 s32 cellSpursTasksetGetSpursAddress(vm::cptr<CellSpursTaskset> taskset, vm::ptr<u32> spurs)
 {
-	cellSpurs.Warning("cellSpursTasksetGetSpursAddress(taskset=*0x%x, spurs=**0x%x)", taskset, spurs);
+	cellSpurs.warning("cellSpursTasksetGetSpursAddress(taskset=*0x%x, spurs=**0x%x)", taskset, spurs);
 
 	if (!taskset || !spurs)
 	{
@@ -3895,7 +3895,7 @@ s32 cellSpursGetTasksetInfo()
 
 s32 _cellSpursTasksetAttributeInitialize(vm::ptr<CellSpursTasksetAttribute> attribute, u32 revision, u32 sdk_version, u64 args, vm::cptr<u8> priority, u32 max_contention)
 {
-	cellSpurs.Warning("_cellSpursTasksetAttributeInitialize(attribute=*0x%x, revision=%d, skd_version=0x%x, args=0x%llx, priority=*0x%x, max_contention=%d)",
+	cellSpurs.warning("_cellSpursTasksetAttributeInitialize(attribute=*0x%x, revision=%d, skd_version=0x%x, args=0x%llx, priority=*0x%x, max_contention=%d)",
 		attribute, revision, sdk_version, args, priority, max_contention);
 
 	if (!attribute)

rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp

@@ -20,7 +20,7 @@ s32 cellSubDisplayEnd()
 
 s32 cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
 {
-	cellSubdisplay.Warning("cellSubDisplayGetRequiredMemory(pParam=*0x%x)", pParam);
+	cellSubdisplay.warning("cellSubDisplayGetRequiredMemory(pParam=*0x%x)", pParam);
 
 	if (pParam->version == CELL_SUBDISPLAY_VERSION_0002)
 	{

rpcs3/Emu/SysCalls/Modules/cellSync.cpp

@@ -13,7 +13,7 @@ extern Module<> cellSync;
 
 s32 cellSyncMutexInitialize(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync.Log("cellSyncMutexInitialize(mutex=*0x%x)", mutex);
+	cellSync.trace("cellSyncMutexInitialize(mutex=*0x%x)", mutex);
 
 	if (!mutex)
 	{
@@ -32,7 +32,7 @@ s32 cellSyncMutexInitialize(vm::ptr<CellSyncMutex> mutex)
 
 s32 cellSyncMutexLock(PPUThread& ppu, vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync.Log("cellSyncMutexLock(mutex=*0x%x)", mutex);
+	cellSync.trace("cellSyncMutexLock(mutex=*0x%x)", mutex);
 
 	if (!mutex)
 	{
@@ -57,7 +57,7 @@ s32 cellSyncMutexLock(PPUThread& ppu, vm::ptr<CellSyncMutex> mutex)
 
 s32 cellSyncMutexTryLock(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync.Log("cellSyncMutexTryLock(mutex=*0x%x)", mutex);
+	cellSync.trace("cellSyncMutexTryLock(mutex=*0x%x)", mutex);
 
 	if (!mutex)
 	{
@@ -79,7 +79,7 @@ s32 cellSyncMutexTryLock(vm::ptr<CellSyncMutex> mutex)
 
 s32 cellSyncMutexUnlock(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync.Log("cellSyncMutexUnlock(mutex=*0x%x)", mutex);
+	cellSync.trace("cellSyncMutexUnlock(mutex=*0x%x)", mutex);
 
 	if (!mutex)
 	{
@@ -100,7 +100,7 @@ s32 cellSyncMutexUnlock(vm::ptr<CellSyncMutex> mutex)
 
 s32 cellSyncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count)
 {
-	cellSync.Log("cellSyncBarrierInitialize(barrier=*0x%x, total_count=%d)", barrier, total_count);
+	cellSync.trace("cellSyncBarrierInitialize(barrier=*0x%x, total_count=%d)", barrier, total_count);
 
 	if (!barrier)
 	{
@@ -125,7 +125,7 @@ s32 cellSyncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count)
 
 s32 cellSyncBarrierNotify(PPUThread& ppu, vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync.Log("cellSyncBarrierNotify(barrier=*0x%x)", barrier);
+	cellSync.trace("cellSyncBarrierNotify(barrier=*0x%x)", barrier);
 
 	if (!barrier)
 	{
@@ -146,7 +146,7 @@ s32 cellSyncBarrierNotify(PPUThread& ppu, vm::ptr<CellSyncBarrier> barrier)
 
 s32 cellSyncBarrierTryNotify(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync.Log("cellSyncBarrierTryNotify(barrier=*0x%x)", barrier);
+	cellSync.trace("cellSyncBarrierTryNotify(barrier=*0x%x)", barrier);
 
 	if (!barrier)
 	{
@@ -172,7 +172,7 @@ s32 cellSyncBarrierTryNotify(vm::ptr<CellSyncBarrier> barrier)
 
 s32 cellSyncBarrierWait(PPUThread& ppu, vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync.Log("cellSyncBarrierWait(barrier=*0x%x)", barrier);
+	cellSync.trace("cellSyncBarrierWait(barrier=*0x%x)", barrier);
 
 	if (!barrier)
 	{
@@ -195,7 +195,7 @@ s32 cellSyncBarrierWait(PPUThread& ppu, vm::ptr<CellSyncBarrier> barrier)
 
 s32 cellSyncBarrierTryWait(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync.Log("cellSyncBarrierTryWait(barrier=*0x%x)", barrier);
+	cellSync.trace("cellSyncBarrierTryWait(barrier=*0x%x)", barrier);
 
 	if (!barrier)
 	{
@@ -221,7 +221,7 @@ s32 cellSyncBarrierTryWait(vm::ptr<CellSyncBarrier> barrier)
 
 s32 cellSyncRwmInitialize(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer, u32 buffer_size)
 {
-	cellSync.Log("cellSyncRwmInitialize(rwm=*0x%x, buffer=*0x%x, buffer_size=0x%x)", rwm, buffer, buffer_size);
+	cellSync.trace("cellSyncRwmInitialize(rwm=*0x%x, buffer=*0x%x, buffer_size=0x%x)", rwm, buffer, buffer_size);
 
 	if (!rwm || !buffer)
 	{
@@ -250,7 +250,7 @@ s32 cellSyncRwmInitialize(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer, u32 bu
 
 s32 cellSyncRwmRead(PPUThread& ppu, vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncRwmRead(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
+	cellSync.trace("cellSyncRwmRead(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
 	if (!rwm || !buffer)
 	{
@@ -281,7 +281,7 @@ s32 cellSyncRwmRead(PPUThread& ppu, vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buff
 
 s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncRwmTryRead(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
+	cellSync.trace("cellSyncRwmTryRead(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
 	if (!rwm || !buffer)
 	{
@@ -315,7 +315,7 @@ s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer)
 
 s32 cellSyncRwmWrite(PPUThread& ppu, vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
 {
-	cellSync.Log("cellSyncRwmWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
+	cellSync.trace("cellSyncRwmWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
 	if (!rwm || !buffer)
 	{
@@ -346,7 +346,7 @@ s32 cellSyncRwmWrite(PPUThread& ppu, vm::ptr<CellSyncRwm> rwm, vm::cptr<void> bu
 
 s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
 {
-	cellSync.Log("cellSyncRwmTryWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
+	cellSync.trace("cellSyncRwmTryWrite(rwm=*0x%x, buffer=*0x%x)", rwm, buffer);
 
 	if (!rwm || !buffer)
 	{
@@ -377,7 +377,7 @@ s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
 
 s32 cellSyncQueueInitialize(vm::ptr<CellSyncQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth)
 {
-	cellSync.Log("cellSyncQueueInitialize(queue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x)", queue, buffer, size, depth);
+	cellSync.trace("cellSyncQueueInitialize(queue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x)", queue, buffer, size, depth);
 
 	if (!queue)
 	{
@@ -412,7 +412,7 @@ s32 cellSyncQueueInitialize(vm::ptr<CellSyncQueue> queue, vm::ptr<u8> buffer, u3
 
 s32 cellSyncQueuePush(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueuePush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueuePush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -443,7 +443,7 @@ s32 cellSyncQueuePush(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::cptr<voi
 
 s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueueTryPush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueueTryPush(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -477,7 +477,7 @@ s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
 
 s32 cellSyncQueuePop(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueuePop(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueuePop(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -508,7 +508,7 @@ s32 cellSyncQueuePop(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::ptr<void>
 
 s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueueTryPop(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueueTryPop(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -542,7 +542,7 @@ s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 
 s32 cellSyncQueuePeek(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueuePeek(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueuePeek(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -573,7 +573,7 @@ s32 cellSyncQueuePeek(PPUThread& ppu, vm::ptr<CellSyncQueue> queue, vm::ptr<void
 
 s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 {
-	cellSync.Log("cellSyncQueueTryPeek(queue=*0x%x, buffer=*0x%x)", queue, buffer);
+	cellSync.trace("cellSyncQueueTryPeek(queue=*0x%x, buffer=*0x%x)", queue, buffer);
 
 	if (!queue || !buffer)
 	{
@@ -607,7 +607,7 @@ s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
 
 s32 cellSyncQueueSize(vm::ptr<CellSyncQueue> queue)
 {
-	cellSync.Log("cellSyncQueueSize(queue=*0x%x)", queue);
+	cellSync.trace("cellSyncQueueSize(queue=*0x%x)", queue);
 
 	if (!queue)
 	{
@@ -626,7 +626,7 @@ s32 cellSyncQueueSize(vm::ptr<CellSyncQueue> queue)
 
 s32 cellSyncQueueClear(PPUThread& ppu, vm::ptr<CellSyncQueue> queue)
 {
-	cellSync.Log("cellSyncQueueClear(queue=*0x%x)", queue);
+	cellSync.trace("cellSyncQueueClear(queue=*0x%x)", queue);
 
 	if (!queue)
 	{
@@ -694,7 +694,7 @@ void syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer
 
 s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer, u32 size, u32 depth, u32 direction, vm::ptr<void> eaSignal)
 {
-	cellSync.Warning("cellSyncLFQueueInitialize(queue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal=*0x%x)", queue, buffer, size, depth, direction, eaSignal);
+	cellSync.warning("cellSyncLFQueueInitialize(queue=*0x%x, buffer=*0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal=*0x%x)", queue, buffer, size, depth, direction, eaSignal);
 
 	if (!queue)
 	{
@@ -803,7 +803,7 @@ s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buf
 
 s32 _cellSyncLFQueueGetPushPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::ptr<s32> pointer, u32 isBlocking, u32 useEventQueue)
 {
-	cellSync.Warning("_cellSyncLFQueueGetPushPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
+	cellSync.warning("_cellSyncLFQueueGetPushPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
 
 	if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU)
 	{
@@ -900,14 +900,14 @@ s32 _cellSyncLFQueueGetPushPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queu
 s32 _cellSyncLFQueueGetPushPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::ptr<s32> pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPushPointer
-	cellSync.Todo("_cellSyncLFQueueGetPushPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
+	cellSync.todo("_cellSyncLFQueueGetPushPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
 
 	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueueCompletePushPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal)
 {
-	cellSync.Warning("_cellSyncLFQueueCompletePushPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal);
+	cellSync.warning("_cellSyncLFQueueCompletePushPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal);
 
 	if (queue->m_direction != CELL_SYNC_QUEUE_PPU2SPU)
 	{
@@ -1044,7 +1044,7 @@ s32 _cellSyncLFQueueCompletePushPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue>
 s32 _cellSyncLFQueueCompletePushPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer
-	cellSync.Todo("_cellSyncLFQueueCompletePushPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal);
+	cellSync.todo("_cellSyncLFQueueCompletePushPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x)", queue, pointer, fpSendSignal);
 
 	throw EXCEPTION("");
 }
@@ -1052,7 +1052,7 @@ s32 _cellSyncLFQueueCompletePushPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue
 s32 _cellSyncLFQueuePushBody(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer, u32 isBlocking)
 {
 	// cellSyncLFQueuePush has 1 in isBlocking param, cellSyncLFQueueTryPush has 0
-	cellSync.Warning("_cellSyncLFQueuePushBody(queue=*0x%x, buffer=*0x%x, isBlocking=%d)", queue, buffer, isBlocking);
+	cellSync.warning("_cellSyncLFQueuePushBody(queue=*0x%x, buffer=*0x%x, isBlocking=%d)", queue, buffer, isBlocking);
 
 	if (!queue || !buffer)
 	{
@@ -1109,7 +1109,7 @@ s32 _cellSyncLFQueuePushBody(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm:
 
 s32 _cellSyncLFQueueGetPopPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::ptr<s32> pointer, u32 isBlocking, u32 arg4, u32 useEventQueue)
 {
-	cellSync.Warning("_cellSyncLFQueueGetPopPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)", queue, pointer, isBlocking, arg4, useEventQueue);
+	cellSync.warning("_cellSyncLFQueueGetPopPointer(queue=*0x%x, pointer=*0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)", queue, pointer, isBlocking, arg4, useEventQueue);
 
 	if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU)
 	{
@@ -1206,7 +1206,7 @@ s32 _cellSyncLFQueueGetPopPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue
 s32 _cellSyncLFQueueGetPopPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::ptr<s32> pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPopPointer
-	cellSync.Todo("_cellSyncLFQueueGetPopPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
+	cellSync.todo("_cellSyncLFQueueGetPopPointer2(queue=*0x%x, pointer=*0x%x, isBlocking=%d, useEventQueue=%d)", queue, pointer, isBlocking, useEventQueue);
 
 	throw EXCEPTION("");
 }
@@ -1214,7 +1214,7 @@ s32 _cellSyncLFQueueGetPopPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queu
 s32 _cellSyncLFQueueCompletePopPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer + unknown argument (noQueueFull taken from LFQueue2CompletePopPointer)
-	cellSync.Warning("_cellSyncLFQueueCompletePopPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull);
+	cellSync.warning("_cellSyncLFQueueCompletePopPointer(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull);
 
 	if (queue->m_direction != CELL_SYNC_QUEUE_SPU2PPU)
 	{
@@ -1350,7 +1350,7 @@ s32 _cellSyncLFQueueCompletePopPointer(PPUThread& ppu, vm::ptr<CellSyncLFQueue>
 s32 _cellSyncLFQueueCompletePopPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePopPointer
-	cellSync.Todo("_cellSyncLFQueueCompletePopPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull);
+	cellSync.todo("_cellSyncLFQueueCompletePopPointer2(queue=*0x%x, pointer=%d, fpSendSignal=*0x%x, noQueueFull=%d)", queue, pointer, fpSendSignal, noQueueFull);
 
 	throw EXCEPTION("");
 }
@@ -1358,7 +1358,7 @@ s32 _cellSyncLFQueueCompletePopPointer2(PPUThread& ppu, vm::ptr<CellSyncLFQueue>
 s32 _cellSyncLFQueuePopBody(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::ptr<void> buffer, u32 isBlocking)
 {
 	// cellSyncLFQueuePop has 1 in isBlocking param, cellSyncLFQueueTryPop has 0
-	cellSync.Warning("_cellSyncLFQueuePopBody(queue=*0x%x, buffer=*0x%x, isBlocking=%d)", queue, buffer, isBlocking);
+	cellSync.warning("_cellSyncLFQueuePopBody(queue=*0x%x, buffer=*0x%x, isBlocking=%d)", queue, buffer, isBlocking);
 
 	if (!queue || !buffer)
 	{
@@ -1415,7 +1415,7 @@ s32 _cellSyncLFQueuePopBody(PPUThread& ppu, vm::ptr<CellSyncLFQueue> queue, vm::
 
 s32 cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync.Warning("cellSyncLFQueueClear(queue=*0x%x)", queue);
+	cellSync.warning("cellSyncLFQueueClear(queue=*0x%x)", queue);
 
 	if (!queue)
 	{
@@ -1466,7 +1466,7 @@ s32 cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
 
 s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> size)
 {
-	cellSync.Warning("cellSyncLFQueueSize(queue=*0x%x, size=*0x%x)", queue, size);
+	cellSync.warning("cellSyncLFQueueSize(queue=*0x%x, size=*0x%x)", queue, size);
 
 	if (!queue || !size)
 	{
@@ -1503,7 +1503,7 @@ s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> size)
 
 s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> depth)
 {
-	cellSync.Log("cellSyncLFQueueDepth(queue=*0x%x, depth=*0x%x)", queue, depth);
+	cellSync.trace("cellSyncLFQueueDepth(queue=*0x%x, depth=*0x%x)", queue, depth);
 
 	if (!queue || !depth)
 	{
@@ -1522,7 +1522,7 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> depth)
 
 s32 _cellSyncLFQueueGetSignalAddress(vm::cptr<CellSyncLFQueue> queue, vm::pptr<void> ppSignal)
 {
-	cellSync.Log("_cellSyncLFQueueGetSignalAddress(queue=*0x%x, ppSignal=**0x%x)", queue, ppSignal);
+	cellSync.trace("_cellSyncLFQueueGetSignalAddress(queue=*0x%x, ppSignal=**0x%x)", queue, ppSignal);
 
 	if (!queue || !ppSignal)
 	{
@@ -1541,7 +1541,7 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::cptr<CellSyncLFQueue> queue, vm::pptr<v
 
 s32 cellSyncLFQueueGetDirection(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> direction)
 {
-	cellSync.Log("cellSyncLFQueueGetDirection(queue=*0x%x, direction=*0x%x)", queue, direction);
+	cellSync.trace("cellSyncLFQueueGetDirection(queue=*0x%x, direction=*0x%x)", queue, direction);
 
 	if (!queue || !direction)
 	{
@@ -1560,7 +1560,7 @@ s32 cellSyncLFQueueGetDirection(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> di
 
 s32 cellSyncLFQueueGetEntrySize(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> entry_size)
 {
-	cellSync.Log("cellSyncLFQueueGetEntrySize(queue=*0x%x, entry_size=*0x%x)", queue, entry_size);
+	cellSync.trace("cellSyncLFQueueGetEntrySize(queue=*0x%x, entry_size=*0x%x)", queue, entry_size);
 
 	if (!queue || !entry_size)
 	{
@@ -1579,14 +1579,14 @@ s32 cellSyncLFQueueGetEntrySize(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> en
 
 s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync.Todo("_cellSyncLFQueueAttachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
+	cellSync.todo("_cellSyncLFQueueAttachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
 
 	throw EXCEPTION("");
 }
 
 s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync.Todo("_cellSyncLFQueueDetachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
+	cellSync.todo("_cellSyncLFQueueDetachLv2EventQueue(spus=*0x%x, num=%d, queue=*0x%x)", spus, num, queue);
 
 	throw EXCEPTION("");
 }
@@ -1624,7 +1624,7 @@ Module<> cellSync("cellSync", []()
 		// analyse error code
 		if (u32 code = (value & 0xffffff00) == 0x80410100 ? static_cast<u32>(value) : 0)
 		{
-			cellSync.Error("%s() -> %s (0x%x)", func->name, get_error(code), code);
+			cellSync.error("%s() -> %s (0x%x)", func->name, get_error(code), code);
 		}
 	};
 

rpcs3/Emu/SysCalls/Modules/cellSync2.cpp

@@ -19,7 +19,7 @@ extern Module<Sync2Instance> cellSync2;
 
 s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
+	cellSync2.warning("_cellSync2MutexAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@@ -34,7 +34,7 @@ s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u3
 
 s32 cellSync2MutexEstimateBufferSize(vm::cptr<CellSync2MutexAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
+	cellSync2.todo("cellSync2MutexEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 
 	if (attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@@ -74,7 +74,7 @@ s32 cellSync2MutexUnlock()
 
 s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2CondAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
+	cellSync2.warning("_cellSync2CondAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 
 	attr->sdkVersion = sdkVersion;
 	attr->maxWaiters = 15;
@@ -85,7 +85,7 @@ s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32
 
 s32 cellSync2CondEstimateBufferSize(vm::cptr<CellSync2CondAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2CondEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
+	cellSync2.todo("cellSync2CondEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 
 	if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@@ -125,7 +125,7 @@ s32 cellSync2CondSignalAll()
 
 s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
+	cellSync2.warning("_cellSync2SemaphoreAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@@ -139,7 +139,7 @@ s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute>
 
 s32 cellSync2SemaphoreEstimateBufferSize(vm::cptr<CellSync2SemaphoreAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
+	cellSync2.todo("cellSync2SemaphoreEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 
 	if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
 		return CELL_SYNC2_ERROR_INVAL;
@@ -185,7 +185,7 @@ s32 cellSync2SemaphoreGetCount()
 
 s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u32 sdkVersion)
 {
-	cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
+	cellSync2.warning("_cellSync2QueueAttributeInitialize(attr=*0x%x, sdkVersion=0x%x)", attr, sdkVersion);
 
 	attr->sdkVersion = sdkVersion;
 	attr->threadTypes = CELL_SYNC2_THREAD_TYPE_PPU_THREAD | CELL_SYNC2_THREAD_TYPE_PPU_FIBER |
@@ -202,7 +202,7 @@ s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u3
 
 s32 cellSync2QueueEstimateBufferSize(vm::cptr<CellSync2QueueAttribute> attr, vm::ptr<u32> bufferSize)
 {
-	cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
+	cellSync2.todo("cellSync2QueueEstimateBufferSize(attr=*0x%x, bufferSize=*0x%x)", attr, bufferSize);
 
 	if (attr->elementSize == 0 || attr->elementSize > 16384 || attr->elementSize % 16 || attr->depth == 0 || attr->depth > 4294967292 ||
 		attr->maxPushWaiters > 32768 || attr->maxPopWaiters > 32768)

rpcs3/Emu/SysCalls/Modules/cellSysmodule.cpp

@@ -131,25 +131,25 @@ const char* get_module_id(u16 id)
 
 s32 cellSysmoduleInitialize()
 {
-	cellSysmodule.Warning("cellSysmoduleInitialize()");
+	cellSysmodule.warning("cellSysmoduleInitialize()");
 	return CELL_OK;
 }
 
 s32 cellSysmoduleFinalize()
 {
-	cellSysmodule.Warning("cellSysmoduleFinalize()");
+	cellSysmodule.warning("cellSysmoduleFinalize()");
 	return CELL_OK;
 }
 
 s32 cellSysmoduleSetMemcontainer(u32 ct_id)
 {
-	cellSysmodule.Todo("cellSysmoduleSetMemcontainer(ct_id=0x%x)", ct_id);
+	cellSysmodule.todo("cellSysmoduleSetMemcontainer(ct_id=0x%x)", ct_id);
 	return CELL_OK;
 }
 
 s32 cellSysmoduleLoadModule(u16 id)
 {
-	cellSysmodule.Warning("cellSysmoduleLoadModule(id=0x%04x: %s)", id, get_module_id(id));
+	cellSysmodule.warning("cellSysmoduleLoadModule(id=0x%04x: %s)", id, get_module_id(id));
 
 	if (!Emu.GetModuleManager().CheckModuleId(id))
 	{
@@ -167,7 +167,7 @@ s32 cellSysmoduleLoadModule(u16 id)
 
 s32 cellSysmoduleUnloadModule(u16 id)
 {
-	cellSysmodule.Warning("cellSysmoduleUnloadModule(id=0x%04x: %s)", id, get_module_id(id));
+	cellSysmodule.warning("cellSysmoduleUnloadModule(id=0x%04x: %s)", id, get_module_id(id));
 
 	if (!Emu.GetModuleManager().CheckModuleId(id))
 	{
@@ -178,7 +178,7 @@ s32 cellSysmoduleUnloadModule(u16 id)
 	{
 		if (!m->IsLoaded())
 		{
-			cellSysmodule.Error("cellSysmoduleUnloadModule() failed: module not loaded (id=0x%04x)", id);
+			cellSysmodule.error("cellSysmoduleUnloadModule() failed: module not loaded (id=0x%04x)", id);
 			return CELL_SYSMODULE_ERROR_FATAL;
 		}
 
@@ -190,11 +190,11 @@ s32 cellSysmoduleUnloadModule(u16 id)
 
 s32 cellSysmoduleIsLoaded(u16 id)
 {
-	cellSysmodule.Warning("cellSysmoduleIsLoaded(id=0x%04x: %s)", id, get_module_id(id));
+	cellSysmodule.warning("cellSysmoduleIsLoaded(id=0x%04x: %s)", id, get_module_id(id));
 
 	if (!Emu.GetModuleManager().CheckModuleId(id))
 	{
-		cellSysmodule.Error("cellSysmoduleIsLoaded(): unknown module (id=0x%04x)", id);
+		cellSysmodule.error("cellSysmoduleIsLoaded(): unknown module (id=0x%04x)", id);
 		return CELL_SYSMODULE_ERROR_UNKNOWN;
 	}
 
@@ -202,7 +202,7 @@ s32 cellSysmoduleIsLoaded(u16 id)
 	{
 		if (!m->IsLoaded())
 		{
-			cellSysmodule.Warning("cellSysmoduleIsLoaded(): module not loaded (id=0x%04x)", id);
+			cellSysmodule.warning("cellSysmoduleIsLoaded(): module not loaded (id=0x%04x)", id);
 			return CELL_SYSMODULE_ERROR_UNLOADED;
 		}
 	}

rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp

@@ -39,7 +39,7 @@ const char* get_systemparam_id_name(s32 id)
 
 s32 cellSysutilGetSystemParamInt(s32 id, vm::ptr<s32> value)
 {
-	cellSysutil.Warning("cellSysutilGetSystemParamInt(id=0x%x(%s), value=*0x%x)", id, get_systemparam_id_name(id), value);
+	cellSysutil.warning("cellSysutilGetSystemParamInt(id=0x%x(%s), value=*0x%x)", id, get_systemparam_id_name(id), value);
 
 	switch(id)
 	{
@@ -112,7 +112,7 @@ s32 cellSysutilGetSystemParamInt(s32 id, vm::ptr<s32> value)
 
 s32 cellSysutilGetSystemParamString(s32 id, vm::ptr<char> buf, u32 bufsize)
 {
-	cellSysutil.Log("cellSysutilGetSystemParamString(id=0x%x(%s), buf=*0x%x, bufsize=%d)", id, get_systemparam_id_name(id), buf, bufsize);
+	cellSysutil.trace("cellSysutilGetSystemParamString(id=0x%x(%s), buf=*0x%x, bufsize=%d)", id, get_systemparam_id_name(id), buf, bufsize);
 
 	memset(buf.get_ptr(), 0, bufsize);
 
@@ -158,7 +158,7 @@ void sysutilSendSystemCommand(u64 status, u64 param)
 
 s32 cellSysutilCheckCallback(PPUThread& CPU)
 {
-	cellSysutil.Log("cellSysutilCheckCallback()");
+	cellSysutil.trace("cellSysutilCheckCallback()");
 
 	while (auto func = Emu.GetCallbackManager().Check())
 	{
@@ -175,7 +175,7 @@ s32 cellSysutilCheckCallback(PPUThread& CPU)
 
 s32 cellSysutilRegisterCallback(s32 slot, vm::ptr<CellSysutilCallback> func, vm::ptr<void> userdata)
 {
-	cellSysutil.Warning("cellSysutilRegisterCallback(slot=%d, func=*0x%x, userdata=*0x%x)", slot, func, userdata);
+	cellSysutil.warning("cellSysutilRegisterCallback(slot=%d, func=*0x%x, userdata=*0x%x)", slot, func, userdata);
 
 	if ((u32)slot > 3)
 	{
@@ -189,7 +189,7 @@ s32 cellSysutilRegisterCallback(s32 slot, vm::ptr<CellSysutilCallback> func, vm:
 
 s32 cellSysutilUnregisterCallback(s32 slot)
 {
-	cellSysutil.Warning("cellSysutilUnregisterCallback(slot=%d)", slot);
+	cellSysutil.warning("cellSysutilUnregisterCallback(slot=%d)", slot);
 
 	if ((u32)slot > 3)
 	{
@@ -203,7 +203,7 @@ s32 cellSysutilUnregisterCallback(s32 slot)
 
 s32 cellSysCacheClear(void)
 {
-	cellSysutil.Todo("cellSysCacheClear()");
+	cellSysutil.todo("cellSysCacheClear()");
 
 	if (!g_sysutil->cacheMounted)
 	{
@@ -220,7 +220,7 @@ s32 cellSysCacheClear(void)
 
 s32 cellSysCacheMount(vm::ptr<CellSysCacheParam> param)
 {
-	cellSysutil.Warning("cellSysCacheMount(param=*0x%x)", param);
+	cellSysutil.warning("cellSysCacheMount(param=*0x%x)", param);
 
 	// TODO: implement
 	char id[CELL_SYSCACHE_ID_SIZE] = { '\0' };
@@ -237,7 +237,7 @@ bool g_bgm_playback_enabled = true;
 
 s32 cellSysutilEnableBgmPlayback()
 {
-	cellSysutil.Warning("cellSysutilEnableBgmPlayback()");
+	cellSysutil.warning("cellSysutilEnableBgmPlayback()");
 
 	// TODO
 	g_bgm_playback_enabled = true;
@@ -247,7 +247,7 @@ s32 cellSysutilEnableBgmPlayback()
 
 s32 cellSysutilEnableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> param)
 {
-	cellSysutil.Warning("cellSysutilEnableBgmPlaybackEx(param=*0x%x)", param);
+	cellSysutil.warning("cellSysutilEnableBgmPlaybackEx(param=*0x%x)", param);
 
 	// TODO
 	g_bgm_playback_enabled = true; 
@@ -257,7 +257,7 @@ s32 cellSysutilEnableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> par
 
 s32 cellSysutilDisableBgmPlayback()
 {
-	cellSysutil.Warning("cellSysutilDisableBgmPlayback()");
+	cellSysutil.warning("cellSysutilDisableBgmPlayback()");
 
 	// TODO
 	g_bgm_playback_enabled = false;
@@ -267,7 +267,7 @@ s32 cellSysutilDisableBgmPlayback()
 
 s32 cellSysutilDisableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> param)
 {
-	cellSysutil.Warning("cellSysutilDisableBgmPlaybackEx(param=*0x%x)", param);
+	cellSysutil.warning("cellSysutilDisableBgmPlaybackEx(param=*0x%x)", param);
 
 	// TODO
 	g_bgm_playback_enabled = false;
@@ -277,7 +277,7 @@ s32 cellSysutilDisableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> pa
 
 s32 cellSysutilGetBgmPlaybackStatus(vm::ptr<CellSysutilBgmPlaybackStatus> status)
 {
-	cellSysutil.Warning("cellSysutilGetBgmPlaybackStatus(status=*0x%x)", status);
+	cellSysutil.warning("cellSysutilGetBgmPlaybackStatus(status=*0x%x)", status);
 
 	// TODO
 	status->playerState = CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP;
@@ -291,7 +291,7 @@ s32 cellSysutilGetBgmPlaybackStatus(vm::ptr<CellSysutilBgmPlaybackStatus> status
 
 s32 cellSysutilGetBgmPlaybackStatus2(vm::ptr<CellSysutilBgmPlaybackStatus2> status2)
 {
-	cellSysutil.Warning("cellSysutilGetBgmPlaybackStatus2(status2=*0x%x)", status2);
+	cellSysutil.warning("cellSysutilGetBgmPlaybackStatus2(status2=*0x%x)", status2);
 
 	// TODO
 	status2->playerState = CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP;

rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp

@@ -19,7 +19,7 @@ enum
 
 s32 cellSysutilApGetRequiredMemSize()
 {
-	cellSysutilAp.Log("cellSysutilApGetRequiredMemSize()");
+	cellSysutilAp.trace("cellSysutilApGetRequiredMemSize()");
 	return 1024*1024; // Return 1 MB as required size
 }
 

rpcs3/Emu/SysCalls/Modules/cellSysutilAvc2.cpp

@@ -131,7 +131,7 @@ s32 cellSysutilAvc2GetSpeakerVolumeLevel()
 
 s32 cellSysutilAvc2IsCameraAttached(vm::ptr<u8> status)
 {
-	cellSysutilAvc2.Todo("cellSysutilAvc2IsCameraAttached()");
+	cellSysutilAvc2.todo("cellSysutilAvc2IsCameraAttached()");
 
 	if (rpcs3::config.io.camera.value() == io_camera_state::null)
 	{
@@ -178,7 +178,7 @@ s32 cellSysutilAvc2GetWindowShowStatus()
 
 s32 cellSysutilAvc2InitParam(u16 version, vm::ptr<CellSysutilAvc2InitParam> option)
 {
-	cellSysutilAvc2.Warning("cellSysutilAvc2InitParam(version=%d, option=*0x%x)", version, option);
+	cellSysutilAvc2.warning("cellSysutilAvc2InitParam(version=%d, option=*0x%x)", version, option);
 
 	if (version >= 110)
 	{
@@ -186,7 +186,7 @@ s32 cellSysutilAvc2InitParam(u16 version, vm::ptr<CellSysutilAvc2InitParam> opti
 		// Other versions shouldn't differ by too much, if at all - they most likely differ in other functions.
 		if (version != 140)
 		{
-			cellSysutilAvc2.Todo("cellSysutilAvc2InitParam(): Older/newer version %d used, might cause problems.", version);
+			cellSysutilAvc2.todo("cellSysutilAvc2InitParam(): Older/newer version %d used, might cause problems.", version);
 		}
 
 		option->avc_init_param_version = version;
@@ -207,17 +207,17 @@ s32 cellSysutilAvc2InitParam(u16 version, vm::ptr<CellSysutilAvc2InitParam> opti
 			}
 			else
 			{
-				cellSysutilAvc2.Error("Unknown frame mode 0x%x", option->video_param.frame_mode);
+				cellSysutilAvc2.error("Unknown frame mode 0x%x", option->video_param.frame_mode);
 			}
 		}
 		else
 		{
-			cellSysutilAvc2.Error("Unknown media type 0x%x", option->media_type);
+			cellSysutilAvc2.error("Unknown media type 0x%x", option->media_type);
 		}
 	}
 	else
 	{
-		cellSysutilAvc2.Error("cellSysutilAvc2InitParam(): Unknown version %d used, please report this to a developer.", version);
+		cellSysutilAvc2.error("cellSysutilAvc2InitParam(): Unknown version %d used, please report this to a developer.", version);
 	}
 
 	return CELL_OK;

rpcs3/Emu/SysCalls/Modules/cellSysutilMisc.cpp

@@ -19,7 +19,7 @@ enum
 
 s32 cellSysutilGetLicenseArea()
 {
-	cellSysutilMisc.Warning("cellSysutilGetLicenseArea()");
+	cellSysutilMisc.warning("cellSysutilGetLicenseArea()");
 
 	switch (const char region = Emu.GetTitleID().at(2))
 	{
@@ -29,7 +29,7 @@ s32 cellSysutilGetLicenseArea()
 	case 'H': return CELL_SYSUTIL_LICENSE_AREA_H;
 	case 'K': return CELL_SYSUTIL_LICENSE_AREA_K;
 	case 'A': return CELL_SYSUTIL_LICENSE_AREA_C;
-	default: cellSysutilMisc.Todo("Unknown license area: %s", Emu.GetTitleID().c_str()); return CELL_SYSUTIL_LICENSE_AREA_OTHER;
+	default: cellSysutilMisc.todo("Unknown license area: %s", Emu.GetTitleID().c_str()); return CELL_SYSUTIL_LICENSE_AREA_OTHER;
 	}
 }
 

rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp

@@ -8,14 +8,14 @@ extern Module<> cellUsbd;
 
 s32 cellUsbdInit()
 {
-	cellUsbd.Warning("cellUsbdInit()");
+	cellUsbd.warning("cellUsbdInit()");
 
 	return CELL_OK;
 }
 
 s32 cellUsbdEnd()
 {
-	cellUsbd.Warning("cellUsbdEnd()");
+	cellUsbd.warning("cellUsbdEnd()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp

@@ -11,7 +11,7 @@ extern Module<> cellUserInfo;
 
 s32 cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
 {
-	cellUserInfo.Warning("cellUserInfoGetStat(id=%d, stat=*0x%x)", id, stat);
+	cellUserInfo.warning("cellUserInfoGetStat(id=%d, stat=*0x%x)", id, stat);
 
 	if (id > CELL_SYSUTIL_USERID_MAX)
 		return CELL_USERINFO_ERROR_NOUSER;
@@ -63,7 +63,7 @@ s32 cellUserInfoEnableOverlay()
 
 s32 cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserList> listBuf, vm::ptr<u32> currentUserId)
 {
-	cellUserInfo.Warning("cellUserInfoGetList(listNum=*0x%x, listBuf=*0x%x, currentUserId=*0x%x)", listNum, listBuf, currentUserId);
+	cellUserInfo.warning("cellUserInfoGetList(listNum=*0x%x, listBuf=*0x%x, currentUserId=*0x%x)", listNum, listBuf, currentUserId);
 
 	// If only listNum is NULL, an error will be returned
 	if (listBuf && !listNum)

rpcs3/Emu/SysCalls/Modules/cellVdec.cpp

@@ -123,7 +123,7 @@ next:
 		VdecTask task;
 		if (!vdec.job.peek(task, 0, &vdec.is_closed))
 		{
-			if (Emu.IsStopped()) cellVdec.Warning("vdecRead() aborted");
+			if (Emu.IsStopped()) cellVdec.warning("vdecRead() aborted");
 			return 0;
 		}
 
@@ -156,7 +156,7 @@ next:
 		
 		default:
 		{
-			cellVdec.Error("vdecRead(): unknown task (%d)", task.type);
+			cellVdec.error("vdecRead(): unknown task (%d)", task.type);
 			Emu.Pause();
 			return -1;
 		}
@@ -188,9 +188,9 @@ u32 vdecQueryAttr(s32 type, u32 profile, u32 spec_addr /* may be 0 */, vm::ptr<C
 {
 	switch (type) // TODO: check profile levels
 	{
-	case CELL_VDEC_CODEC_TYPE_AVC: cellVdec.Warning("cellVdecQueryAttr: AVC (profile=%d)", profile); break;
+	case CELL_VDEC_CODEC_TYPE_AVC: cellVdec.warning("cellVdecQueryAttr: AVC (profile=%d)", profile); break;
-	case CELL_VDEC_CODEC_TYPE_MPEG2: cellVdec.Warning("cellVdecQueryAttr: MPEG2 (profile=%d)", profile); break;
+	case CELL_VDEC_CODEC_TYPE_MPEG2: cellVdec.warning("cellVdecQueryAttr: MPEG2 (profile=%d)", profile); break;
-	case CELL_VDEC_CODEC_TYPE_DIVX: cellVdec.Warning("cellVdecQueryAttr: DivX (profile=%d)", profile); break;
+	case CELL_VDEC_CODEC_TYPE_DIVX: cellVdec.warning("cellVdecQueryAttr: DivX (profile=%d)", profile); break;
 	default: return CELL_VDEC_ERROR_ARG;
 	}
 
@@ -235,7 +235,7 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 			case vdecStartSeq:
 			{
 				// TODO: reset data
-				cellVdec.Warning("vdecStartSeq:");
+				cellVdec.warning("vdecStartSeq:");
 
 				vdec.reader = {};
 				vdec.frc_set = 0;
@@ -246,7 +246,7 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 			case vdecEndSeq:
 			{
 				// TODO: finalize
-				cellVdec.Warning("vdecEndSeq:");
+				cellVdec.warning("vdecEndSeq:");
 
 				vdec.cbFunc(*vdec.vdecCb, vdec.id, CELL_VDEC_MSG_TYPE_SEQDONE, CELL_OK, vdec.cbArg);
 
@@ -349,7 +349,7 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 				{
 					if (Emu.IsStopped() || vdec.is_closed)
 					{
-						if (Emu.IsStopped()) cellVdec.Warning("vdecDecodeAu: aborted");
+						if (Emu.IsStopped()) cellVdec.warning("vdecDecodeAu: aborted");
 						break;
 					}
 
@@ -393,7 +393,7 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 					{
 						if (decode < 0)
 						{
-							cellVdec.Error("vdecDecodeAu: AU decoding error(0x%x)", decode);
+							cellVdec.error("vdecDecodeAu: AU decoding error(0x%x)", decode);
 						}
 						if (!got_picture && vdec.reader.size == 0) break; // video end?
 					}
@@ -518,7 +518,7 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 
 			case vdecSetFrameRate:
 			{
-				cellVdec.Warning("vdecSetFrameRate(0x%x)", task.frc);
+				cellVdec.warning("vdecSetFrameRate(0x%x)", task.frc);
 				vdec.frc_set = task.frc;
 				break;
 			}
@@ -544,21 +544,21 @@ void vdecOpen(u32 vdec_id) // TODO: call from the constructor
 
 s32 cellVdecQueryAttr(vm::cptr<CellVdecType> type, vm::ptr<CellVdecAttr> attr)
 {
-	cellVdec.Warning("cellVdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
+	cellVdec.warning("cellVdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, 0, attr);
 }
 
 s32 cellVdecQueryAttrEx(vm::cptr<CellVdecTypeEx> type, vm::ptr<CellVdecAttr> attr)
 {
-	cellVdec.Warning("cellVdecQueryAttrEx(type=*0x%x, attr=*0x%x)", type, attr);
+	cellVdec.warning("cellVdecQueryAttrEx(type=*0x%x, attr=*0x%x)", type, attr);
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, type->codecSpecificInfo_addr, attr);
 }
 
 s32 cellVdecOpen(vm::cptr<CellVdecType> type, vm::cptr<CellVdecResource> res, vm::cptr<CellVdecCb> cb, vm::ptr<u32> handle)
 {
-	cellVdec.Warning("cellVdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellVdec.warning("cellVdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	vdecOpen(*handle = idm::make<VideoDecoder>(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
@@ -567,7 +567,7 @@ s32 cellVdecOpen(vm::cptr<CellVdecType> type, vm::cptr<CellVdecResource> res, vm
 
 s32 cellVdecOpenEx(vm::cptr<CellVdecTypeEx> type, vm::cptr<CellVdecResourceEx> res, vm::cptr<CellVdecCb> cb, vm::ptr<u32> handle)
 {
-	cellVdec.Warning("cellVdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
+	cellVdec.warning("cellVdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
 
 	vdecOpen(*handle = idm::make<VideoDecoder>(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
@@ -576,7 +576,7 @@ s32 cellVdecOpenEx(vm::cptr<CellVdecTypeEx> type, vm::cptr<CellVdecResourceEx> r
 
 s32 cellVdecClose(u32 handle)
 {
-	cellVdec.Warning("cellVdecClose(handle=0x%x)", handle);
+	cellVdec.warning("cellVdecClose(handle=0x%x)", handle);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -602,7 +602,7 @@ s32 cellVdecClose(u32 handle)
 
 s32 cellVdecStartSeq(u32 handle)
 {
-	cellVdec.Log("cellVdecStartSeq(handle=0x%x)", handle);
+	cellVdec.trace("cellVdecStartSeq(handle=0x%x)", handle);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -617,7 +617,7 @@ s32 cellVdecStartSeq(u32 handle)
 
 s32 cellVdecEndSeq(u32 handle)
 {
-	cellVdec.Warning("cellVdecEndSeq(handle=0x%x)", handle);
+	cellVdec.warning("cellVdecEndSeq(handle=0x%x)", handle);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -632,7 +632,7 @@ s32 cellVdecEndSeq(u32 handle)
 
 s32 cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::cptr<CellVdecAuInfo> auInfo)
 {
-	cellVdec.Log("cellVdecDecodeAu(handle=0x%x, mode=%d, auInfo=*0x%x)", handle, mode, auInfo);
+	cellVdec.trace("cellVdecDecodeAu(handle=0x%x, mode=%d, auInfo=*0x%x)", handle, mode, auInfo);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -662,7 +662,7 @@ s32 cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, vm::cptr<CellVdecAuInf
 
 s32 cellVdecGetPicture(u32 handle, vm::cptr<CellVdecPicFormat> format, vm::ptr<u8> outBuff)
 {
-	cellVdec.Log("cellVdecGetPicture(handle=0x%x, format=*0x%x, outBuff=*0x%x)", handle, format, outBuff);
+	cellVdec.trace("cellVdecGetPicture(handle=0x%x, format=*0x%x, outBuff=*0x%x)", handle, format, outBuff);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -769,7 +769,7 @@ s32 cellVdecGetPicture(u32 handle, vm::cptr<CellVdecPicFormat> format, vm::ptr<u
 
 s32 cellVdecGetPictureExt(u32 handle, vm::cptr<CellVdecPicFormat2> format2, vm::ptr<u8> outBuff, u32 arg4)
 {
-	cellVdec.Warning("cellVdecGetPictureExt(handle=0x%x, format2=*0x%x, outBuff=*0x%x, arg4=*0x%x)", handle, format2, outBuff, arg4);
+	cellVdec.warning("cellVdecGetPictureExt(handle=0x%x, format2=*0x%x, outBuff=*0x%x, arg4=*0x%x)", handle, format2, outBuff, arg4);
 
 	if (arg4 || format2->unk0 || format2->unk1)
 	{
@@ -786,7 +786,7 @@ s32 cellVdecGetPictureExt(u32 handle, vm::cptr<CellVdecPicFormat2> format2, vm::
 
 s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 {
-	cellVdec.Log("cellVdecGetPicItem(handle=0x%x, picItem=**0x%x)", handle, picItem);
+	cellVdec.trace("cellVdecGetPicItem(handle=0x%x, picItem=**0x%x)", handle, picItem);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 
@@ -841,7 +841,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 		case AV_PICTURE_TYPE_I: avc->pictureType[0] = CELL_VDEC_AVC_PCT_I; break;
 		case AV_PICTURE_TYPE_P: avc->pictureType[0] = CELL_VDEC_AVC_PCT_P; break;
 		case AV_PICTURE_TYPE_B: avc->pictureType[0] = CELL_VDEC_AVC_PCT_B; break;
-		default: cellVdec.Error("cellVdecGetPicItem(AVC): unknown pict_type value (0x%x)", frame.pict_type);
+		default: cellVdec.error("cellVdecGetPicItem(AVC): unknown pict_type value (0x%x)", frame.pict_type);
 		}
 		avc->pictureType[1] = CELL_VDEC_AVC_PCT_UNKNOWN; // ???
 		avc->idrPictureFlag = false; // ???
@@ -872,7 +872,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 		case CELL_VDEC_FRC_50: avc->frameRateCode = CELL_VDEC_AVC_FRC_50; break;
 		case CELL_VDEC_FRC_60000DIV1001: avc->frameRateCode = CELL_VDEC_AVC_FRC_60000DIV1001; break;
 		case CELL_VDEC_FRC_60: avc->frameRateCode = CELL_VDEC_AVC_FRC_60; break;
-		default: cellVdec.Error("cellVdecGetPicItem(AVC): unknown frc value (0x%x)", vf.frc);
+		default: cellVdec.error("cellVdecGetPicItem(AVC): unknown frc value (0x%x)", vf.frc);
 		}
 
 		avc->fixed_frame_rate_flag = true;
@@ -893,7 +893,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 		case AV_PICTURE_TYPE_I: dvx->pictureType = CELL_VDEC_DIVX_VCT_I; break;
 		case AV_PICTURE_TYPE_P: dvx->pictureType = CELL_VDEC_DIVX_VCT_P; break;
 		case AV_PICTURE_TYPE_B: dvx->pictureType = CELL_VDEC_DIVX_VCT_B; break;
-		default: cellVdec.Error("cellVdecGetPicItem(DivX): unknown pict_type value (0x%x)", frame.pict_type);
+		default: cellVdec.error("cellVdecGetPicItem(DivX): unknown pict_type value (0x%x)", frame.pict_type);
 		}
 		dvx->horizontalSize = frame.width;
 		dvx->verticalSize = frame.height;
@@ -915,7 +915,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 		case CELL_VDEC_FRC_50: dvx->frameRateCode = CELL_VDEC_DIVX_FRC_50; break;
 		case CELL_VDEC_FRC_60000DIV1001: dvx->frameRateCode = CELL_VDEC_DIVX_FRC_60000DIV1001; break;
 		case CELL_VDEC_FRC_60: dvx->frameRateCode = CELL_VDEC_DIVX_FRC_60; break;
-		default: cellVdec.Error("cellVdecGetPicItem(DivX): unknown frc value (0x%x)", vf.frc);
+		default: cellVdec.error("cellVdecGetPicItem(DivX): unknown frc value (0x%x)", vf.frc);
 		}
 	}
 	else if (vdec->type == CELL_VDEC_CODEC_TYPE_MPEG2)
@@ -931,7 +931,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
 
 s32 cellVdecSetFrameRate(u32 handle, CellVdecFrameRate frc)
 {
-	cellVdec.Log("cellVdecSetFrameRate(handle=0x%x, frc=0x%x)", handle, frc);
+	cellVdec.trace("cellVdecSetFrameRate(handle=0x%x, frc=0x%x)", handle, frc);
 
 	const auto vdec = idm::get<VideoDecoder>(handle);
 

rpcs3/Emu/SysCalls/Modules/cellVideoOut.cpp

@@ -11,7 +11,7 @@ extern Module<> cellSysutil;
 
 s32 cellVideoOutGetState(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutState> state)
 {
-	cellSysutil.Log("cellVideoOutGetState(videoOut=%d, deviceIndex=%d, state=*0x%x)", videoOut, deviceIndex, state);
+	cellSysutil.trace("cellVideoOutGetState(videoOut=%d, deviceIndex=%d, state=*0x%x)", videoOut, deviceIndex, state);
 
 	if (deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND;
 
@@ -37,7 +37,7 @@ s32 cellVideoOutGetState(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutStat
 
 s32 cellVideoOutGetResolution(u32 resolutionId, vm::ptr<CellVideoOutResolution> resolution)
 {
-	cellSysutil.Log("cellVideoOutGetResolution(resolutionId=%d, resolution=*0x%x)", resolutionId, resolution);
+	cellSysutil.trace("cellVideoOutGetResolution(resolutionId=%d, resolution=*0x%x)", resolutionId, resolution);
 
 	u32 num = ResolutionIdToNum(resolutionId);
 	if (!num)
@@ -51,7 +51,7 @@ s32 cellVideoOutGetResolution(u32 resolutionId, vm::ptr<CellVideoOutResolution>
 
 s32 cellVideoOutConfigure(u32 videoOut, vm::ptr<CellVideoOutConfiguration> config, vm::ptr<CellVideoOutOption> option, u32 waitForEvent)
 {
-	cellSysutil.Warning("cellVideoOutConfigure(videoOut=%d, config=*0x%x, option=*0x%x, waitForEvent=%d)", videoOut, config, option, waitForEvent);
+	cellSysutil.warning("cellVideoOutConfigure(videoOut=%d, config=*0x%x, option=*0x%x, waitForEvent=%d)", videoOut, config, option, waitForEvent);
 
 	switch (videoOut)
 	{
@@ -84,7 +84,7 @@ s32 cellVideoOutConfigure(u32 videoOut, vm::ptr<CellVideoOutConfiguration> confi
 
 s32 cellVideoOutGetConfiguration(u32 videoOut, vm::ptr<CellVideoOutConfiguration> config, vm::ptr<CellVideoOutOption> option)
 {
-	cellSysutil.Warning("cellVideoOutGetConfiguration(videoOut=%d, config=*0x%x, option=*0x%x)", videoOut, config, option);
+	cellSysutil.warning("cellVideoOutGetConfiguration(videoOut=%d, config=*0x%x, option=*0x%x)", videoOut, config, option);
 
 	if (option) *option = {};
 	*config = {};
@@ -109,7 +109,7 @@ s32 cellVideoOutGetConfiguration(u32 videoOut, vm::ptr<CellVideoOutConfiguration
 
 s32 cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutDeviceInfo> info)
 {
-	cellSysutil.Warning("cellVideoOutGetDeviceInfo(videoOut=%d, deviceIndex=%d, info=*0x%x)", videoOut, deviceIndex, info);
+	cellSysutil.warning("cellVideoOutGetDeviceInfo(videoOut=%d, deviceIndex=%d, info=*0x%x)", videoOut, deviceIndex, info);
 
 	if (deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND;
 
@@ -140,7 +140,7 @@ s32 cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOu
 
 s32 cellVideoOutGetNumberOfDevice(u32 videoOut)
 {
-	cellSysutil.Warning("cellVideoOutGetNumberOfDevice(videoOut=%d)", videoOut);
+	cellSysutil.warning("cellVideoOutGetNumberOfDevice(videoOut=%d)", videoOut);
 
 	switch (videoOut)
 	{
@@ -153,7 +153,7 @@ s32 cellVideoOutGetNumberOfDevice(u32 videoOut)
 
 s32 cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId, u32 aspect, u32 option)
 {
-	cellSysutil.Warning("cellVideoOutGetResolutionAvailability(videoOut=%d, resolutionId=0x%x, aspect=%d, option=%d)", videoOut, resolutionId, aspect, option);
+	cellSysutil.warning("cellVideoOutGetResolutionAvailability(videoOut=%d, resolutionId=0x%x, aspect=%d, option=%d)", videoOut, resolutionId, aspect, option);
 
 	if (!rpcs3::config.rsx._3dtv.value() && (resolutionId == CELL_VIDEO_OUT_RESOLUTION_720_3D_FRAME_PACKING || resolutionId == CELL_VIDEO_OUT_RESOLUTION_1024x720_3D_FRAME_PACKING ||
 		resolutionId == CELL_VIDEO_OUT_RESOLUTION_960x720_3D_FRAME_PACKING || resolutionId == CELL_VIDEO_OUT_RESOLUTION_800x720_3D_FRAME_PACKING ||

rpcs3/Emu/SysCalls/Modules/cellVpost.cpp

@@ -15,7 +15,7 @@ extern Module<> cellVpost;
 
 s32 cellVpostQueryAttr(vm::cptr<CellVpostCfgParam> cfgParam, vm::ptr<CellVpostAttr> attr)
 {
-	cellVpost.Warning("cellVpostQueryAttr(cfgParam=*0x%x, attr=*0x%x)", cfgParam, attr);
+	cellVpost.warning("cellVpostQueryAttr(cfgParam=*0x%x, attr=*0x%x)", cfgParam, attr);
 
 	// TODO: check cfgParam and output values
 
@@ -29,7 +29,7 @@ s32 cellVpostQueryAttr(vm::cptr<CellVpostCfgParam> cfgParam, vm::ptr<CellVpostAt
 
 s32 cellVpostOpen(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostResource> resource, vm::ptr<u32> handle)
 {
-	cellVpost.Warning("cellVpostOpen(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
+	cellVpost.warning("cellVpostOpen(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
 
 	// TODO: check values
 	*handle = idm::make<VpostInstance>(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV);
@@ -38,7 +38,7 @@ s32 cellVpostOpen(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostResour
 
 s32 cellVpostOpenEx(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostResourceEx> resource, vm::ptr<u32> handle)
 {
-	cellVpost.Warning("cellVpostOpenEx(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
+	cellVpost.warning("cellVpostOpenEx(cfgParam=*0x%x, resource=*0x%x, handle=*0x%x)", cfgParam, resource, handle);
 
 	// TODO: check values
 	*handle = idm::make<VpostInstance>(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV);
@@ -47,7 +47,7 @@ s32 cellVpostOpenEx(vm::cptr<CellVpostCfgParam> cfgParam, vm::cptr<CellVpostReso
 
 s32 cellVpostClose(u32 handle)
 {
-	cellVpost.Warning("cellVpostClose(handle=0x%x)", handle);
+	cellVpost.warning("cellVpostClose(handle=0x%x)", handle);
 
 	const auto vpost = idm::get<VpostInstance>(handle);
 
@@ -62,7 +62,7 @@ s32 cellVpostClose(u32 handle)
 
 s32 cellVpostExec(u32 handle, vm::cptr<u8> inPicBuff, vm::cptr<CellVpostCtrlParam> ctrlParam, vm::ptr<u8> outPicBuff, vm::ptr<CellVpostPictureInfo> picInfo)
 {
-	cellVpost.Log("cellVpostExec(handle=0x%x, inPicBuff=*0x%x, ctrlParam=*0x%x, outPicBuff=*0x%x, picInfo=*0x%x)", handle, inPicBuff, ctrlParam, outPicBuff, picInfo);
+	cellVpost.trace("cellVpostExec(handle=0x%x, inPicBuff=*0x%x, ctrlParam=*0x%x, outPicBuff=*0x%x, picInfo=*0x%x)", handle, inPicBuff, ctrlParam, outPicBuff, picInfo);
 
 	const auto vpost = idm::get<VpostInstance>(handle);
 
@@ -77,15 +77,15 @@ s32 cellVpostExec(u32 handle, vm::cptr<u8> inPicBuff, vm::cptr<CellVpostCtrlPara
 	u32 oh = ctrlParam->outHeight;
 
 	//ctrlParam->inWindow; // ignored
-	if (ctrlParam->inWindow.x) cellVpost.Notice("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
+	if (ctrlParam->inWindow.x) cellVpost.notice("*** inWindow.x = %d", (u32)ctrlParam->inWindow.x);
-	if (ctrlParam->inWindow.y) cellVpost.Notice("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
+	if (ctrlParam->inWindow.y) cellVpost.notice("*** inWindow.y = %d", (u32)ctrlParam->inWindow.y);
-	if (ctrlParam->inWindow.width != w) cellVpost.Notice("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
+	if (ctrlParam->inWindow.width != w) cellVpost.notice("*** inWindow.width = %d", (u32)ctrlParam->inWindow.width);
-	if (ctrlParam->inWindow.height != h) cellVpost.Notice("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
+	if (ctrlParam->inWindow.height != h) cellVpost.notice("*** inWindow.height = %d", (u32)ctrlParam->inWindow.height);
 	//ctrlParam->outWindow; // ignored
-	if (ctrlParam->outWindow.x) cellVpost.Notice("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
+	if (ctrlParam->outWindow.x) cellVpost.notice("*** outWindow.x = %d", (u32)ctrlParam->outWindow.x);
-	if (ctrlParam->outWindow.y) cellVpost.Notice("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
+	if (ctrlParam->outWindow.y) cellVpost.notice("*** outWindow.y = %d", (u32)ctrlParam->outWindow.y);
-	if (ctrlParam->outWindow.width != ow) cellVpost.Notice("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
+	if (ctrlParam->outWindow.width != ow) cellVpost.notice("*** outWindow.width = %d", (u32)ctrlParam->outWindow.width);
-	if (ctrlParam->outWindow.height != oh) cellVpost.Notice("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
+	if (ctrlParam->outWindow.height != oh) cellVpost.notice("*** outWindow.height = %d", (u32)ctrlParam->outWindow.height);
 	//ctrlParam->execType; // ignored
 	//ctrlParam->scalerType; // ignored
 	//ctrlParam->ipcType; // ignored

rpcs3/Emu/SysCalls/Modules/cellWebBrowser.cpp

@@ -183,7 +183,7 @@ s32 cellWebBrowserEstimate()
 
 s32 cellWebBrowserEstimate2(vm::cptr<CellWebBrowserConfig2> config, vm::ptr<u32> memSize)
 {
-	cellSysutil.Warning("cellWebBrowserEstimate2(config=*0x%x, memSize=*0x%x)", config, memSize);
+	cellSysutil.warning("cellWebBrowserEstimate2(config=*0x%x, memSize=*0x%x)", config, memSize);
 
 	// TODO: When cellWebBrowser stuff is implemented, change this to some real
 	// needed memory buffer size.

rpcs3/Emu/SysCalls/Modules/libmixer.cpp

@@ -16,7 +16,7 @@ std::vector<SSPlayer> g_ssp;
 
 s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr, u32 samples)
 {
-	libmixer.Log("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d)", aan_handle, aan_port, offset, addr, samples);
+	libmixer.trace("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d)", aan_handle, aan_port, offset, addr, samples);
 
 	u32 type = aan_port >> 16;
 	u32 port = aan_port & 0xffff;
@@ -37,7 +37,7 @@ s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr
 
 	if (aan_handle != 0x11111111 || samples != 256 || !type || offset != 0)
 	{
-		libmixer.Error("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d): invalid parameters", aan_handle, aan_port, offset, addr, samples);
+		libmixer.error("cellAANAddData(aan_handle=0x%x, aan_port=0x%x, offset=0x%x, addr=*0x%x, samples=%d): invalid parameters", aan_handle, aan_port, offset, addr, samples);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -97,14 +97,14 @@ s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr
 
 s32 cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
 {
-	libmixer.Warning("cellAANConnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
+	libmixer.warning("cellAANConnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
 		receive, receivePortNo, source, sourcePortNo);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (source >= g_ssp.size() || !g_ssp[source].m_created)
 	{
-		libmixer.Error("cellAANConnect(): invalid source (%d)", source);
+		libmixer.error("cellAANConnect(): invalid source (%d)", source);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -115,14 +115,14 @@ s32 cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
 
 s32 cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
 {
-	libmixer.Warning("cellAANDisconnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
+	libmixer.warning("cellAANDisconnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
 		receive, receivePortNo, source, sourcePortNo);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (source >= g_ssp.size() || !g_ssp[source].m_created)
 	{
-		libmixer.Error("cellAANDisconnect(): invalid source (%d)", source);
+		libmixer.error("cellAANDisconnect(): invalid source (%d)", source);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -133,11 +133,11 @@ s32 cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
  
 s32 cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
 {
-	libmixer.Warning("cellSSPlayerCreate(handle=*0x%x, config=*0x%x)", handle, config);
+	libmixer.warning("cellSSPlayerCreate(handle=*0x%x, config=*0x%x)", handle, config);
 
 	if (config->outputMode != 0 || config->channels - 1 >= 2)
 	{
-		libmixer.Error("cellSSPlayerCreate(config.outputMode=%d, config.channels=%d): invalid parameters", config->outputMode, config->channels);
+		libmixer.error("cellSSPlayerCreate(config.outputMode=%d, config.channels=%d): invalid parameters", config->outputMode, config->channels);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -156,13 +156,13 @@ s32 cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
 
 s32 cellSSPlayerRemove(u32 handle)
 {
-	libmixer.Warning("cellSSPlayerRemove(handle=0x%x)", handle);
+	libmixer.warning("cellSSPlayerRemove(handle=0x%x)", handle);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Error("cellSSPlayerRemove(): SSPlayer not found (%d)", handle);
+		libmixer.error("cellSSPlayerRemove(): SSPlayer not found (%d)", handle);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -175,13 +175,13 @@ s32 cellSSPlayerRemove(u32 handle)
 
 s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm::ptr<CellSSPlayerCommonParam> commonInfo)
 {
-	libmixer.Warning("cellSSPlayerSetWave(handle=0x%x, waveInfo=*0x%x, commonInfo=*0x%x)", handle, waveInfo, commonInfo);
+	libmixer.warning("cellSSPlayerSetWave(handle=0x%x, waveInfo=*0x%x, commonInfo=*0x%x)", handle, waveInfo, commonInfo);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Error("cellSSPlayerSetWave(): SSPlayer not found (%d)", handle);
+		libmixer.error("cellSSPlayerSetWave(): SSPlayer not found (%d)", handle);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -198,13 +198,13 @@ s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm:
 
 s32 cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer.Warning("cellSSPlayerPlay(handle=0x%x, info=*0x%x)", handle, info);
+	libmixer.warning("cellSSPlayerPlay(handle=0x%x, info=*0x%x)", handle, info);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Error("cellSSPlayerPlay(): SSPlayer not found (%d)", handle);
+		libmixer.error("cellSSPlayerPlay(): SSPlayer not found (%d)", handle);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -222,13 +222,13 @@ s32 cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 
 s32 cellSSPlayerStop(u32 handle, u32 mode)
 {
-	libmixer.Warning("cellSSPlayerStop(handle=0x%x, mode=0x%x)", handle, mode);
+	libmixer.warning("cellSSPlayerStop(handle=0x%x, mode=0x%x)", handle, mode);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Error("cellSSPlayerStop(): SSPlayer not found (%d)", handle);
+		libmixer.error("cellSSPlayerStop(): SSPlayer not found (%d)", handle);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -241,13 +241,13 @@ s32 cellSSPlayerStop(u32 handle, u32 mode)
 
 s32 cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer.Warning("cellSSPlayerSetParam(handle=0x%x, info=*0x%x)", handle, info);
+	libmixer.warning("cellSSPlayerSetParam(handle=0x%x, info=*0x%x)", handle, info);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Error("cellSSPlayerSetParam(): SSPlayer not found (%d)", handle);
+		libmixer.error("cellSSPlayerSetParam(): SSPlayer not found (%d)", handle);
 		return CELL_LIBMIXER_ERROR_INVALID_PARAMATER;
 	}
 
@@ -264,13 +264,13 @@ s32 cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
  
 s32 cellSSPlayerGetState(u32 handle)
 {
-	libmixer.Warning("cellSSPlayerGetState(handle=0x%x)", handle);
+	libmixer.warning("cellSSPlayerGetState(handle=0x%x)", handle);
 
 	std::lock_guard<std::mutex> lock(g_surmx.mutex);
 
 	if (handle >= g_ssp.size() || !g_ssp[handle].m_created)
 	{
-		libmixer.Warning("cellSSPlayerGetState(): SSPlayer not found (%d)", handle);
+		libmixer.warning("cellSSPlayerGetState(): SSPlayer not found (%d)", handle);
 		return CELL_SSPLAYER_STATE_ERROR;
 	}
 
@@ -284,7 +284,7 @@ s32 cellSSPlayerGetState(u32 handle)
 
 s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 {
-	libmixer.Warning("cellSurMixerCreate(config=*0x%x)", config);
+	libmixer.warning("cellSurMixerCreate(config=*0x%x)", config);
 
 	g_surmx.audio_port = g_audio.open_port();
 
@@ -311,14 +311,14 @@ s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 	port.level = 1.0f;
 	port.level_set.store({ 1.0f, 0.0f });
 
-	libmixer.Warning("*** audio port opened (port=%d)", g_surmx.audio_port);
+	libmixer.warning("*** audio port opened (port=%d)", g_surmx.audio_port);
 
 	g_surmx.mixcount = 0;
 	g_surmx.cb = vm::null;
 
 	g_ssp.clear();
 
-	libmixer.Warning("*** surMixer created (ch1=%d, ch2=%d, ch6=%d, ch8=%d)", config->chStrips1, config->chStrips2, config->chStrips6, config->chStrips8);
+	libmixer.warning("*** surMixer created (ch1=%d, ch2=%d, ch6=%d, ch8=%d)", config->chStrips1, config->chStrips2, config->chStrips6, config->chStrips8);
 
 	const auto ppu = idm::make_ptr<PPUThread>("Surmixer Thread");
 	ppu->prio = 1001;
@@ -455,21 +455,21 @@ s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
 
 s32 cellSurMixerGetAANHandle(vm::ptr<u32> handle)
 {
-	libmixer.Warning("cellSurMixerGetAANHandle(handle=*0x%x) -> %d", handle, 0x11111111);
+	libmixer.warning("cellSurMixerGetAANHandle(handle=*0x%x) -> %d", handle, 0x11111111);
 	*handle = 0x11111111;
 	return CELL_OK;
 }
 
 s32 cellSurMixerChStripGetAANPortNo(vm::ptr<u32> port, u32 type, u32 index)
 {
-	libmixer.Warning("cellSurMixerChStripGetAANPortNo(port=*0x%x, type=0x%x, index=0x%x) -> 0x%x", port, type, index, (type << 16) | index);
+	libmixer.warning("cellSurMixerChStripGetAANPortNo(port=*0x%x, type=0x%x, index=0x%x) -> 0x%x", port, type, index, (type << 16) | index);
 	*port = (type << 16) | index;
 	return CELL_OK;
 }
 
 s32 cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func, vm::ptr<void> arg)
 {
-	libmixer.Warning("cellSurMixerSetNotifyCallback(func=*0x%x, arg=*0x%x)", func, arg);
+	libmixer.warning("cellSurMixerSetNotifyCallback(func=*0x%x, arg=*0x%x)", func, arg);
 
 	if (g_surmx.cb)
 	{
@@ -484,7 +484,7 @@ s32 cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> fu
 
 s32 cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func)
 {
-	libmixer.Warning("cellSurMixerRemoveNotifyCallback(func=*0x%x)", func);
+	libmixer.warning("cellSurMixerRemoveNotifyCallback(func=*0x%x)", func);
 
 	if (g_surmx.cb != func)
 	{
@@ -498,7 +498,7 @@ s32 cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction>
 
 s32 cellSurMixerStart()
 {
-	libmixer.Warning("cellSurMixerStart()");
+	libmixer.warning("cellSurMixerStart()");
 
 	if (g_surmx.audio_port >= AUDIO_PORT_COUNT)
 	{
@@ -512,13 +512,13 @@ s32 cellSurMixerStart()
 
 s32 cellSurMixerSetParameter(u32 param, float value)
 {
-	libmixer.Todo("cellSurMixerSetParameter(param=0x%x, value=%f)", param, value);
+	libmixer.todo("cellSurMixerSetParameter(param=0x%x, value=%f)", param, value);
 	return CELL_OK;
 }
 
 s32 cellSurMixerFinalize()
 {
-	libmixer.Warning("cellSurMixerFinalize()");
+	libmixer.warning("cellSurMixerFinalize()");
 
 	if (g_surmx.audio_port >= AUDIO_PORT_COUNT)
 	{
@@ -534,11 +534,11 @@ s32 cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 sa
 {
 	if (busNo < 8 && samples == 256 && offset == 0)
 	{
-		libmixer.Log("cellSurMixerSurBusAddData(busNo=%d, offset=0x%x, addr=0x%x, samples=%d)", busNo, offset, addr, samples);
+		libmixer.trace("cellSurMixerSurBusAddData(busNo=%d, offset=0x%x, addr=0x%x, samples=%d)", busNo, offset, addr, samples);
 	}
 	else
 	{
-		libmixer.Todo("cellSurMixerSurBusAddData(busNo=%d, offset=0x%x, addr=0x%x, samples=%d)", busNo, offset, addr, samples);
+		libmixer.todo("cellSurMixerSurBusAddData(busNo=%d, offset=0x%x, addr=0x%x, samples=%d)", busNo, offset, addr, samples);
 		return CELL_OK;
 	}
 
@@ -555,13 +555,13 @@ s32 cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 sa
 
 s32 cellSurMixerChStripSetParameter(u32 type, u32 index, vm::ptr<CellSurMixerChStripParam> param)
 {
-	libmixer.Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param=*0x%x)", type, index, param);
+	libmixer.todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param=*0x%x)", type, index, param);
 	return CELL_OK;
 }
 
 s32 cellSurMixerPause(u32 type)
 {
-	libmixer.Warning("cellSurMixerPause(type=%d)", type);
+	libmixer.warning("cellSurMixerPause(type=%d)", type);
 
 	if (g_surmx.audio_port >= AUDIO_PORT_COUNT)
 	{
@@ -575,7 +575,7 @@ s32 cellSurMixerPause(u32 type)
 
 s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
 {
-	libmixer.Log("cellSurMixerGetCurrentBlockTag(tag=*0x%x)", tag);
+	libmixer.trace("cellSurMixerGetCurrentBlockTag(tag=*0x%x)", tag);
 
 	*tag = g_surmx.mixcount;
 	return CELL_OK;
@@ -583,7 +583,7 @@ s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
 
 s32 cellSurMixerGetTimestamp(u64 tag, vm::ptr<u64> stamp)
 {
-	libmixer.Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp=*0x%x)", tag, stamp);
+	libmixer.trace("cellSurMixerGetTimestamp(tag=0x%llx, stamp=*0x%x)", tag, stamp);
 
 	*stamp = g_audio.start_time + (tag) * 256000000 / 48000; // ???
 	return CELL_OK;
@@ -591,25 +591,25 @@ s32 cellSurMixerGetTimestamp(u64 tag, vm::ptr<u64> stamp)
 
 void cellSurMixerBeep(u32 arg)
 {
-	libmixer.Todo("cellSurMixerBeep(arg=%d)", arg);
+	libmixer.todo("cellSurMixerBeep(arg=%d)", arg);
 	return;
 }
 
 float cellSurMixerUtilGetLevelFromDB(float dB)
 {
-	libmixer.Todo("cellSurMixerUtilGetLevelFromDB(dB=%f)", dB);
+	libmixer.todo("cellSurMixerUtilGetLevelFromDB(dB=%f)", dB);
 	throw EXCEPTION("");
 }
 
 float cellSurMixerUtilGetLevelFromDBIndex(s32 index)
 {
-	libmixer.Todo("cellSurMixerUtilGetLevelFromDBIndex(index=%d)", index);
+	libmixer.todo("cellSurMixerUtilGetLevelFromDBIndex(index=%d)", index);
 	throw EXCEPTION("");
 }
 
 float cellSurMixerUtilNoteToRatio(u8 refNote, u8 note)
 {
-	libmixer.Todo("cellSurMixerUtilNoteToRatio(refNote=%d, note=%d)", refNote, note);
+	libmixer.todo("cellSurMixerUtilNoteToRatio(refNote=%d, note=%d)", refNote, note);
 	throw EXCEPTION("");
 }
 

rpcs3/Emu/SysCalls/Modules/libsynth2.cpp

@@ -6,100 +6,100 @@
 
 s32 cellSoundSynth2Config(s16 param, s32 value)
 {
-	libsynth2.Todo("cellSoundSynth2Config(param=%d, value=%d)", param, value);
+	libsynth2.todo("cellSoundSynth2Config(param=%d, value=%d)", param, value);
 	return CELL_OK;
 }
 
 s32 cellSoundSynth2Init(s16 flag)
 {
-	libsynth2.Todo("cellSoundSynth2Init(flag=%d)", flag);
+	libsynth2.todo("cellSoundSynth2Init(flag=%d)", flag);
 	return CELL_OK;
 }
 
 s32 cellSoundSynth2Exit()
 {
-	libsynth2.Todo("cellSoundSynth2Exit()");
+	libsynth2.todo("cellSoundSynth2Exit()");
 	return CELL_OK;
 }
 
 void cellSoundSynth2SetParam(u16 reg, u16 value)
 {
-	libsynth2.Todo("cellSoundSynth2SetParam(register=0x%x, value=0x%x)", reg, value);
+	libsynth2.todo("cellSoundSynth2SetParam(register=0x%x, value=0x%x)", reg, value);
 }
 
 u16 cellSoundSynth2GetParam(u16 reg)
 {
-	libsynth2.Todo("cellSoundSynth2GetParam(register=0x%x)", reg);
+	libsynth2.todo("cellSoundSynth2GetParam(register=0x%x)", reg);
 	throw EXCEPTION("");
 }
 
 void cellSoundSynth2SetSwitch(u16 reg, u32 value)
 {
-	libsynth2.Todo("cellSoundSynth2SetSwitch(register=0x%x, value=0x%x)", reg, value);
+	libsynth2.todo("cellSoundSynth2SetSwitch(register=0x%x, value=0x%x)", reg, value);
 }
 
 u32 cellSoundSynth2GetSwitch(u16 reg)
 {
-	libsynth2.Todo("cellSoundSynth2GetSwitch(register=0x%x)", reg);
+	libsynth2.todo("cellSoundSynth2GetSwitch(register=0x%x)", reg);
 	throw EXCEPTION("");
 }
 
 s32 cellSoundSynth2SetAddr(u16 reg, u32 value)
 {
-	libsynth2.Todo("cellSoundSynth2SetAddr(register=0x%x, value=0x%x)", reg, value);
+	libsynth2.todo("cellSoundSynth2SetAddr(register=0x%x, value=0x%x)", reg, value);
 	return CELL_OK;
 }
 
 u32 cellSoundSynth2GetAddr(u16 reg)
 {
-	libsynth2.Todo("cellSoundSynth2GetAddr(register=0x%x)", reg);
+	libsynth2.todo("cellSoundSynth2GetAddr(register=0x%x)", reg);
 	throw EXCEPTION("");
 }
 
 s32 cellSoundSynth2SetEffectAttr(s16 bus, vm::ptr<CellSoundSynth2EffectAttr> attr)
 {
-	libsynth2.Todo("cellSoundSynth2SetEffectAttr(bus=%d, attr=*0x%x)", bus, attr);
+	libsynth2.todo("cellSoundSynth2SetEffectAttr(bus=%d, attr=*0x%x)", bus, attr);
 	return CELL_OK;
 }
 
 s32 cellSoundSynth2SetEffectMode(s16 bus, vm::ptr<CellSoundSynth2EffectAttr> attr)
 {
-	libsynth2.Todo("cellSoundSynth2SetEffectMode(bus=%d, attr=*0x%x)", bus, attr);
+	libsynth2.todo("cellSoundSynth2SetEffectMode(bus=%d, attr=*0x%x)", bus, attr);
 	return CELL_OK;
 }
 
 void cellSoundSynth2SetCoreAttr(u16 entry, u16 value)
 {
-	libsynth2.Todo("cellSoundSynth2SetCoreAttr(entry=0x%x, value=0x%x)", entry, value);
+	libsynth2.todo("cellSoundSynth2SetCoreAttr(entry=0x%x, value=0x%x)", entry, value);
 }
 
 s32 cellSoundSynth2Generate(u16 samples, vm::ptr<f32> Lout, vm::ptr<f32> Rout, vm::ptr<f32> Ls, vm::ptr<f32> Rs)
 {
-	libsynth2.Todo("cellSoundSynth2Generate(samples=0x%x, Lout=*0x%x, Rout=*0x%x, Ls=*0x%x, Rs=*0x%x)", samples, Lout, Rout, Ls, Rs);
+	libsynth2.todo("cellSoundSynth2Generate(samples=0x%x, Lout=*0x%x, Rout=*0x%x, Ls=*0x%x, Rs=*0x%x)", samples, Lout, Rout, Ls, Rs);
 	return CELL_OK;
 }
 
 s32 cellSoundSynth2VoiceTrans(s16 channel, u16 mode, vm::ptr<u8> m_addr, u32 s_addr, u32 size)
 {
-	libsynth2.Todo("cellSoundSynth2VoiceTrans(channel=%d, mode=0x%x, m_addr=*0x%x, s_addr=0x%x, size=0x%x)", channel, mode, m_addr, s_addr, size);
+	libsynth2.todo("cellSoundSynth2VoiceTrans(channel=%d, mode=0x%x, m_addr=*0x%x, s_addr=0x%x, size=0x%x)", channel, mode, m_addr, s_addr, size);
 	return CELL_OK;
 }
 
 s32 cellSoundSynth2VoiceTransStatus(s16 channel, s16 flag)
 {
-	libsynth2.Todo("cellSoundSynth2VoiceTransStatus(channel=%d, flag=%d)", channel, flag);
+	libsynth2.todo("cellSoundSynth2VoiceTransStatus(channel=%d, flag=%d)", channel, flag);
 	return CELL_OK;
 }
 
 u16 cellSoundSynth2Note2Pitch(u16 center_note, u16 center_fine, u16 note, s16 fine)
 {
-	libsynth2.Todo("cellSoundSynth2Note2Pitch(center_note=0x%x, center_fine=0x%x, note=0x%x, fine=%d)", center_note, center_fine, note, fine);
+	libsynth2.todo("cellSoundSynth2Note2Pitch(center_note=0x%x, center_fine=0x%x, note=0x%x, fine=%d)", center_note, center_fine, note, fine);
 	throw EXCEPTION("");
 }
 
 u16 cellSoundSynth2Pitch2Note(u16 center_note, u16 center_fine, u16 pitch)
 {
-	libsynth2.Todo("cellSoundSynth2Pitch2Note(center_note=0x%x, center_fine=0x%x, pitch=0x%x)", center_note, center_fine, pitch);
+	libsynth2.todo("cellSoundSynth2Pitch2Note(center_note=0x%x, center_fine=0x%x, pitch=0x%x)", center_note, center_fine, pitch);
 	throw EXCEPTION("");
 }
 

rpcs3/Emu/SysCalls/Modules/sceNp.cpp

@@ -14,7 +14,7 @@ extern Module<> sceNp;
 
 s32 sceNpInit(u32 poolsize, vm::ptr<void> poolptr)
 {
-	sceNp.Warning("sceNpInit(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
+	sceNp.warning("sceNpInit(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
 
 	if (poolsize == 0)
 	{
@@ -35,7 +35,7 @@ s32 sceNpInit(u32 poolsize, vm::ptr<void> poolptr)
 
 s32 sceNpTerm()
 {
-	sceNp.Warning("sceNpTerm()");
+	sceNp.warning("sceNpTerm()");
 
 	return CELL_OK;
 }
@@ -44,7 +44,7 @@ s32 npDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
 	if (!Emu.GetVFS().ExistsFile(drm_path.get_ptr()))
 	{
-		sceNp.Warning("npDrmIsAvailable(): '%s' not found", drm_path.get_ptr());
+		sceNp.warning("npDrmIsAvailable(): '%s' not found", drm_path.get_ptr());
 		return CELL_ENOENT;
 	}
 
@@ -60,8 +60,8 @@ s32 npDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 		}
 	}
 
-	sceNp.Warning("npDrmIsAvailable(): Found DRM license file at %s", drm_path.get_ptr());
+	sceNp.warning("npDrmIsAvailable(): Found DRM license file at %s", drm_path.get_ptr());
-	sceNp.Warning("npDrmIsAvailable(): Using k_licensee 0x%s", k_licensee_str.c_str());
+	sceNp.warning("npDrmIsAvailable(): Using k_licensee 0x%s", k_licensee_str.c_str());
 
 	// Set the necessary file paths.
 	std::string drm_file_name = fmt::AfterLast(drm_path.get_ptr(), '/');
@@ -87,7 +87,7 @@ s32 npDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 
 	if (rap_path.back() == '/')
 	{
-		sceNp.Warning("npDrmIsAvailable(): Can't find RAP file for '%s' (titleID='%s')", drm_path.get_ptr(), titleID);
+		sceNp.warning("npDrmIsAvailable(): Can't find RAP file for '%s' (titleID='%s')", drm_path.get_ptr(), titleID);
 	}
 
 	// Decrypt this EDAT using the supplied k_licensee and matching RAP file.
@@ -108,28 +108,28 @@ s32 npDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 
 s32 sceNpDrmIsAvailable(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
-	sceNp.Warning("sceNpDrmIsAvailable(k_licensee=*0x%x, drm_path=*0x%x)", k_licensee_addr, drm_path);
+	sceNp.warning("sceNpDrmIsAvailable(k_licensee=*0x%x, drm_path=*0x%x)", k_licensee_addr, drm_path);
 
 	return npDrmIsAvailable(k_licensee_addr, drm_path);
 }
 
 s32 sceNpDrmIsAvailable2(u32 k_licensee_addr, vm::cptr<char> drm_path)
 {
-	sceNp.Warning("sceNpDrmIsAvailable2(k_licensee=*0x%x, drm_path=*0x%x)", k_licensee_addr, drm_path);
+	sceNp.warning("sceNpDrmIsAvailable2(k_licensee=*0x%x, drm_path=*0x%x)", k_licensee_addr, drm_path);
 
 	return npDrmIsAvailable(k_licensee_addr, drm_path);
 }
 
 s32 sceNpDrmVerifyUpgradeLicense(vm::cptr<char> content_id)
 {
-	sceNp.Todo("sceNpDrmVerifyUpgradeLicense(content_id=*0x%x)", content_id);
+	sceNp.todo("sceNpDrmVerifyUpgradeLicense(content_id=*0x%x)", content_id);
 
 	return CELL_OK;
 }
 
 s32 sceNpDrmVerifyUpgradeLicense2(vm::cptr<char> content_id)
 {
-	sceNp.Todo("sceNpDrmVerifyUpgradeLicense2(content_id=*0x%x)", content_id);
+	sceNp.todo("sceNpDrmVerifyUpgradeLicense2(content_id=*0x%x)", content_id);
 
 	return CELL_OK;
 }
@@ -142,7 +142,7 @@ s32 sceNpDrmExecuteGamePurchase()
 
 s32 sceNpDrmGetTimelimit(vm::ptr<const char> path, vm::ptr<u64> time_remain)
 {
-	sceNp.Warning("sceNpDrmGetTimelimit(path=*0x%x, time_remain=*0x%x)", path, time_remain);
+	sceNp.warning("sceNpDrmGetTimelimit(path=*0x%x, time_remain=*0x%x)", path, time_remain);
 
 	*time_remain = 0x7FFFFFFFFFFFFFFFULL;
 
@@ -151,7 +151,7 @@ s32 sceNpDrmGetTimelimit(vm::ptr<const char> path, vm::ptr<u64> time_remain)
 
 s32 sceNpDrmProcessExitSpawn(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
-	sceNp.Warning("sceNpDrmProcessExitSpawn() -> sys_game_process_exitspawn");
+	sceNp.warning("sceNpDrmProcessExitSpawn() -> sys_game_process_exitspawn");
 
 	sys_game_process_exitspawn(path, argv_addr, envp_addr, data_addr, data_size, prio, flags);
 
@@ -160,7 +160,7 @@ s32 sceNpDrmProcessExitSpawn(vm::cptr<char> path, u32 argv_addr, u32 envp_addr,
 
 s32 sceNpDrmProcessExitSpawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_addr, u32 data_addr, u32 data_size, u32 prio, u64 flags)
 {
-	sceNp.Warning("sceNpDrmProcessExitSpawn2() -> sys_game_process_exitspawn2");
+	sceNp.warning("sceNpDrmProcessExitSpawn2() -> sys_game_process_exitspawn2");
 
 	sys_game_process_exitspawn2(path, argv_addr, envp_addr, data_addr, data_size, prio, flags);
 
@@ -259,7 +259,7 @@ s32 sceNpBasicAddFriend()
 
 s32 sceNpBasicGetFriendListEntryCount(vm::ptr<u32> count)
 {
-	sceNp.Warning("sceNpBasicGetFriendListEntryCount(count=*0x%x)", count);
+	sceNp.warning("sceNpBasicGetFriendListEntryCount(count=*0x%x)", count);
 
 	// TODO: Check if there are any friends
 	*count = 0;
@@ -311,7 +311,7 @@ s32 sceNpBasicAddPlayersHistoryAsync()
 
 s32 sceNpBasicGetPlayersHistoryEntryCount(u32 options, vm::ptr<u32> count)
 {
-	sceNp.Todo("sceNpBasicGetPlayersHistoryEntryCount(options=%d, count=*0x%x)", options, count);
+	sceNp.todo("sceNpBasicGetPlayersHistoryEntryCount(options=%d, count=*0x%x)", options, count);
 
 	return CELL_OK;
 }
@@ -330,7 +330,7 @@ s32 sceNpBasicAddBlockListEntry()
 
 s32 sceNpBasicGetBlockListEntryCount(u32 count)
 {
-	sceNp.Todo("sceNpBasicGetBlockListEntryCount(count=%d)", count);
+	sceNp.todo("sceNpBasicGetBlockListEntryCount(count=%d)", count);
 
 	return CELL_OK;
 }
@@ -343,14 +343,14 @@ s32 sceNpBasicGetBlockListEntry()
 
 s32 sceNpBasicGetMessageAttachmentEntryCount(vm::ptr<u32> count)
 {
-	sceNp.Todo("sceNpBasicGetMessageAttachmentEntryCount(count=*0x%x)", count);
+	sceNp.todo("sceNpBasicGetMessageAttachmentEntryCount(count=*0x%x)", count);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetMessageAttachmentEntry(u32 index, vm::ptr<SceNpUserInfo> from)
 {
-	sceNp.Todo("sceNpBasicGetMessageAttachmentEntry(index=%d, from=*0x%x)", index, from);
+	sceNp.todo("sceNpBasicGetMessageAttachmentEntry(index=%d, from=*0x%x)", index, from);
 
 	return CELL_OK;
 }
@@ -369,35 +369,35 @@ s32 sceNpBasicGetCustomInvitationEntry()
 
 s32 sceNpBasicGetMatchingInvitationEntryCount(vm::ptr<u32> count)
 {
-	sceNp.Todo("sceNpBasicGetMatchingInvitationEntryCount(count=*0x%x)", count);
+	sceNp.todo("sceNpBasicGetMatchingInvitationEntryCount(count=*0x%x)", count);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetMatchingInvitationEntry(u32 index, vm::ptr<SceNpUserInfo> from)
 {
-	sceNp.Todo("sceNpBasicGetMatchingInvitationEntry(index=%d, from=*0x%x)", index, from);
+	sceNp.todo("sceNpBasicGetMatchingInvitationEntry(index=%d, from=*0x%x)", index, from);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetClanMessageEntryCount(vm::ptr<u32> count)
 {
-	sceNp.Todo("sceNpBasicGetClanMessageEntryCount(count=*0x%x)", count);
+	sceNp.todo("sceNpBasicGetClanMessageEntryCount(count=*0x%x)", count);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetClanMessageEntry(u32 index, vm::ptr<SceNpUserInfo> from)
 {
-	sceNp.Todo("sceNpBasicGetClanMessageEntry(index=%d, from=*0x%x)", index, from);
+	sceNp.todo("sceNpBasicGetClanMessageEntry(index=%d, from=*0x%x)", index, from);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetMessageEntryCount(u32 type, vm::ptr<u32> count)
 {
-	sceNp.Warning("sceNpBasicGetMessageEntryCount(type=%d, count=*0x%x)", type, count);
+	sceNp.warning("sceNpBasicGetMessageEntryCount(type=%d, count=*0x%x)", type, count);
 
 	// TODO: Check if there are messages
 	*count = 0;
@@ -407,14 +407,14 @@ s32 sceNpBasicGetMessageEntryCount(u32 type, vm::ptr<u32> count)
 
 s32 sceNpBasicGetMessageEntry(u32 type, u32 index, vm::ptr<SceNpUserInfo> from)
 {
-	sceNp.Todo("sceNpBasicGetMessageEntry(type=%d, index=%d, from=*0x%x)", type, index, from);
+	sceNp.todo("sceNpBasicGetMessageEntry(type=%d, index=%d, from=*0x%x)", type, index, from);
 
 	return CELL_OK;
 }
 
 s32 sceNpBasicGetEvent(vm::ptr<s32> event, vm::ptr<SceNpUserInfo> from, vm::ptr<s32> data, vm::ptr<u32> size)
 {
-	sceNp.Warning("sceNpBasicGetEvent(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size);
+	sceNp.warning("sceNpBasicGetEvent(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size);
 
 	// TODO: Check for other error and pass other events
 	*event = SCE_NP_BASIC_EVENT_OFFLINE;
@@ -676,14 +676,14 @@ s32 sceNpFriendlistAbortGui()
 
 s32 sceNpLookupInit()
 {
-	sceNp.Warning("sceNpLookupInit()");
+	sceNp.warning("sceNpLookupInit()");
 
 	return CELL_OK;
 }
 
 s32 sceNpLookupTerm()
 {
-	sceNp.Warning("sceNpLookupTerm()");
+	sceNp.warning("sceNpLookupTerm()");
 
 	return CELL_OK;
 }
@@ -823,7 +823,7 @@ s32 sceNpManagerUnregisterCallback()
 
 s32 sceNpManagerGetStatus(vm::ptr<u32> status)
 {
-	sceNp.Warning("sceNpManagerGetStatus(status=*0x%x)", status);
+	sceNp.warning("sceNpManagerGetStatus(status=*0x%x)", status);
 
 	// TODO: Support different statuses
 	*status = SCE_NP_MANAGER_STATUS_OFFLINE;
@@ -881,7 +881,7 @@ s32 sceNpManagerGetAccountAge()
 
 s32 sceNpManagerGetContentRatingFlag(vm::ptr<u32> isRestricted, vm::ptr<u32> age)
 {
-	sceNp.Warning("sceNpManagerGetContentRatingFlag(isRestricted=*0x%x, age=*0x%x)", isRestricted, age);
+	sceNp.warning("sceNpManagerGetContentRatingFlag(isRestricted=*0x%x, age=*0x%x)", isRestricted, age);
 
 	// TODO: read user's parental control information
 	*isRestricted = 0;
@@ -1108,14 +1108,14 @@ s32 sceNpProfileAbortGui()
 
 s32 sceNpScoreInit()
 {
-	sceNp.Warning("sceNpScoreInit()");
+	sceNp.warning("sceNpScoreInit()");
 
 	return CELL_OK;
 }
 
 s32 sceNpScoreTerm()
 {
-	sceNp.Warning("sceNpScoreTerm()");
+	sceNp.warning("sceNpScoreTerm()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sceNp2.cpp

@@ -9,7 +9,7 @@ extern Module<> sceNp2;
 
 s32 sceNp2Init(u32 poolsize, vm::ptr<void> poolptr)
 {
-	sceNp2.Warning("sceNp2Init(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
+	sceNp2.warning("sceNp2Init(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
 
 	if (poolsize == 0)
 	{
@@ -30,14 +30,14 @@ s32 sceNp2Init(u32 poolsize, vm::ptr<void> poolptr)
 
 s32 sceNpMatching2Init(u32 poolsize, s32 priority)
 {
-	sceNp2.Todo("sceNpMatching2Init(poolsize=0x%x, priority=%d)", poolsize, priority);
+	sceNp2.todo("sceNpMatching2Init(poolsize=0x%x, priority=%d)", poolsize, priority);
 
 	return CELL_OK;
 }
 
 s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr<SceNpMatching2UtilityInitParam> param)
 {
-	sceNp2.Todo("sceNpMatching2Init2(poolsize=0x%x, priority=%d, param=*0x%x)", poolsize, priority, param);
+	sceNp2.todo("sceNpMatching2Init2(poolsize=0x%x, priority=%d, param=*0x%x)", poolsize, priority, param);
 
 	// TODO:
 	// 1. Create an internal thread
@@ -49,21 +49,21 @@ s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr<SceNpMatching2Utilit
 
 s32 sceNp2Term()
 {
-	sceNp2.Warning("sceNp2Term()");
+	sceNp2.warning("sceNp2Term()");
 
 	return CELL_OK;
 }
 
 s32 sceNpMatching2Term(PPUThread& ppu)
 {
-	sceNp2.Warning("sceNpMatching2Term()");
+	sceNp2.warning("sceNpMatching2Term()");
 
 	return CELL_OK;
 }
 
 s32 sceNpMatching2Term2()
 {
-	sceNp2.Warning("sceNpMatching2Term2()");
+	sceNp2.warning("sceNpMatching2Term2()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp

@@ -10,7 +10,7 @@ extern Module<> sceNpClans;
 
 s32 sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicationPassphrase> passphrase, vm::ptr<void> pool, vm::ptr<u32> poolSize, u32 flags)
 {
-	sceNpClans.Warning("sceNpClansInit(commId=*0x%x, passphrase=*0x%x, pool=*0x%x, poolSize=*0x%x, flags=0x%x)", commId, passphrase, pool, poolSize, flags);
+	sceNpClans.warning("sceNpClansInit(commId=*0x%x, passphrase=*0x%x, pool=*0x%x, poolSize=*0x%x, flags=0x%x)", commId, passphrase, pool, poolSize, flags);
 
 	if (flags != 0)
 	{
@@ -22,14 +22,14 @@ s32 sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicat
 
 s32 sceNpClansTerm()
 {
-	sceNpClans.Warning("sceNpClansTerm()");
+	sceNpClans.warning("sceNpClansTerm()");
 
 	return CELL_OK;
 }
 
 s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle, u64 flags)
 {
-	sceNpClans.Todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags);
+	sceNpClans.todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags);
 
 	if (flags != 0)
 	{

rpcs3/Emu/SysCalls/Modules/sceNpCommerce2.cpp

@@ -20,14 +20,14 @@ s32 sceNpCommerce2GetStoreBrowseUserdata()
 
 s32 sceNpCommerce2Init()
 {
-	sceNpCommerce2.Warning("sceNpCommerce2Init()");
+	sceNpCommerce2.warning("sceNpCommerce2Init()");
 
 	return CELL_OK;
 }
 
 s32 sceNpCommerce2Term()
 {
-	sceNpCommerce2.Warning("sceNpCommerce2Term()");
+	sceNpCommerce2.warning("sceNpCommerce2Term()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sceNpSns.cpp

@@ -7,7 +7,7 @@ extern Module<> sceNpSns;
 
 s32 sceNpSnsFbInit(vm::ptr<const SceNpSnsFbInitParams> params)
 {
-	sceNpSns.Todo("sceNpSnsFbInit(params=*0x%x)", params);
+	sceNpSns.todo("sceNpSnsFbInit(params=*0x%x)", params);
 
 	// TODO: Use the initialization parameters somewhere
 
@@ -16,7 +16,7 @@ s32 sceNpSnsFbInit(vm::ptr<const SceNpSnsFbInitParams> params)
 
 s32 sceNpSnsFbTerm()
 {
-	sceNpSns.Warning("sceNpSnsFbTerm()");
+	sceNpSns.warning("sceNpSnsFbTerm()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp

@@ -33,21 +33,21 @@ struct trophy_handle_t
 // Functions
 s32 sceNpTrophyInit(vm::ptr<void> pool, u32 poolSize, u32 containerId, u64 options)
 {
-	sceNpTrophy.Warning("sceNpTrophyInit(pool=*0x%x, poolSize=0x%x, containerId=0x%x, options=0x%llx)", pool, poolSize, containerId, options);
+	sceNpTrophy.warning("sceNpTrophyInit(pool=*0x%x, poolSize=0x%x, containerId=0x%x, options=0x%llx)", pool, poolSize, containerId, options);
 
 	return CELL_OK;
 }
 
 s32 sceNpTrophyTerm()
 {
-	sceNpTrophy.Warning("sceNpTrophyTerm()");
+	sceNpTrophy.warning("sceNpTrophyTerm()");
 
 	return CELL_OK;
 }
 
 s32 sceNpTrophyCreateHandle(vm::ptr<u32> handle)
 {
-	sceNpTrophy.Warning("sceNpTrophyCreateHandle(handle=*0x%x)", handle);
+	sceNpTrophy.warning("sceNpTrophyCreateHandle(handle=*0x%x)", handle);
 
 	if (!handle)
 	{
@@ -61,7 +61,7 @@ s32 sceNpTrophyCreateHandle(vm::ptr<u32> handle)
 
 s32 sceNpTrophyDestroyHandle(u32 handle)
 {
-	sceNpTrophy.Warning("sceNpTrophyDestroyHandle(handle=0x%x)", handle);
+	sceNpTrophy.warning("sceNpTrophyDestroyHandle(handle=0x%x)", handle);
 
 	const auto hndl = idm::get<trophy_handle_t>(handle);
 
@@ -77,7 +77,7 @@ s32 sceNpTrophyDestroyHandle(u32 handle)
 
 s32 sceNpTrophyAbortHandle(u32 handle)
 {
-	sceNpTrophy.Todo("sceNpTrophyAbortHandle(handle=0x%x)", handle);
+	sceNpTrophy.todo("sceNpTrophyAbortHandle(handle=0x%x)", handle);
 
 	const auto hndl = idm::get<trophy_handle_t>(handle);
 
@@ -91,7 +91,7 @@ s32 sceNpTrophyAbortHandle(u32 handle)
 
 s32 sceNpTrophyCreateContext(vm::ptr<u32> context, vm::cptr<SceNpCommunicationId> commId, vm::cptr<SceNpCommunicationSignature> commSign, u64 options)
 {
-	sceNpTrophy.Warning("sceNpTrophyCreateContext(context=*0x%x, commId=*0x%x, commSign=*0x%x, options=0x%llx)", context, commId, commSign, options);
+	sceNpTrophy.warning("sceNpTrophyCreateContext(context=*0x%x, commId=*0x%x, commSign=*0x%x, options=0x%llx)", context, commId, commSign, options);
 
 	// rough checks for further fmt::format call
 	if (commId->term || commId->num > 99)
@@ -124,7 +124,7 @@ s32 sceNpTrophyCreateContext(vm::ptr<u32> context, vm::cptr<SceNpCommunicationId
 
 s32 sceNpTrophyDestroyContext(u32 context)
 {
-	sceNpTrophy.Warning("sceNpTrophyDestroyContext(context=0x%x)", context);
+	sceNpTrophy.warning("sceNpTrophyDestroyContext(context=0x%x)", context);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -140,13 +140,13 @@ s32 sceNpTrophyDestroyContext(u32 context)
 
 s32 sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr<SceNpTrophyStatusCallback> statusCb, vm::ptr<u32> arg, u64 options)
 {
-	sceNpTrophy.Error("sceNpTrophyRegisterContext(context=0x%x, handle=0x%x, statusCb=*0x%x, arg=*0x%x, options=0x%llx)", context, handle, statusCb, arg, options);
+	sceNpTrophy.error("sceNpTrophyRegisterContext(context=0x%x, handle=0x%x, statusCb=*0x%x, arg=*0x%x, options=0x%llx)", context, handle, statusCb, arg, options);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
 	if (!ctxt)
 	{
-		sceNpTrophy.Error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT");
+		sceNpTrophy.error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT");
 		return SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT;
 	}
 
@@ -154,14 +154,14 @@ s32 sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr<
 
 	if (!hndl)
 	{
-		sceNpTrophy.Error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE");
+		sceNpTrophy.error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE");
 		return SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE;
 	}
 
 	TRPLoader trp(*ctxt->trp_stream);
 	if (!trp.LoadHeader())
 	{
-		sceNpTrophy.Error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE");
+		sceNpTrophy.error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE");
 		return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
 	}
 
@@ -201,7 +201,7 @@ s32 sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr<
 	std::string trophyPath = "/dev_hdd0/home/00000001/trophy/" + ctxt->trp_name;
 	if (!trp.Install(trophyPath))
 	{
-		sceNpTrophy.Error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE");
+		sceNpTrophy.error("sceNpTrophyRegisterContext(): SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE");
 		return SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE;
 	}
 	
@@ -220,7 +220,7 @@ s32 sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr<
 
 s32 sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, vm::ptr<u64> reqspace, u64 options)
 {
-	sceNpTrophy.Todo("sceNpTrophyGetRequiredDiskSpace(context=0x%x, handle=0x%x, reqspace=*0x%x, options=0x%llx)", context, handle, reqspace, options);
+	sceNpTrophy.todo("sceNpTrophyGetRequiredDiskSpace(context=0x%x, handle=0x%x, reqspace=*0x%x, options=0x%llx)", context, handle, reqspace, options);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -244,14 +244,14 @@ s32 sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, vm::ptr<u64> reqspa
 
 s32 sceNpTrophySetSoundLevel(u32 context, u32 handle, u32 level, u64 options)
 {
-	sceNpTrophy.Todo("sceNpTrophySetSoundLevel(context=0x%x, handle=0x%x, level=%d, options=0x%llx)", context, handle, level, options);
+	sceNpTrophy.todo("sceNpTrophySetSoundLevel(context=0x%x, handle=0x%x, level=%d, options=0x%llx)", context, handle, level, options);
 
 	return CELL_OK;
 }
 
 s32 sceNpTrophyGetGameInfo(u32 context, u32 handle, vm::ptr<SceNpTrophyGameDetails> details, vm::ptr<SceNpTrophyGameData> data)
 {
-	sceNpTrophy.Error("sceNpTrophyGetGameInfo(context=0x%x, handle=0x%x, details=*0x%x, data=*0x%x)", context, handle, details, data);
+	sceNpTrophy.error("sceNpTrophyGetGameInfo(context=0x%x, handle=0x%x, details=*0x%x, data=*0x%x)", context, handle, details, data);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -312,7 +312,7 @@ s32 sceNpTrophyGetGameInfo(u32 context, u32 handle, vm::ptr<SceNpTrophyGameDetai
 
 s32 sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::ptr<u32> platinumId)
 {
-	sceNpTrophy.Error("sceNpTrophyUnlockTrophy(context=0x%x, handle=0x%x, trophyId=%d, platinumId=*0x%x)", context, handle, trophyId, platinumId);
+	sceNpTrophy.error("sceNpTrophyUnlockTrophy(context=0x%x, handle=0x%x, trophyId=%d, platinumId=*0x%x)", context, handle, trophyId, platinumId);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -343,7 +343,7 @@ s32 sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::ptr<u32>
 
 s32 sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, vm::ptr<SceNpTrophyFlagArray> flags, vm::ptr<u32> count)
 {
-	sceNpTrophy.Error("sceNpTrophyGetTrophyUnlockState(context=0x%x, handle=0x%x, flags=*0x%x, count=*0x%x)", context, handle, flags, count);
+	sceNpTrophy.error("sceNpTrophyGetTrophyUnlockState(context=0x%x, handle=0x%x, flags=*0x%x, count=*0x%x)", context, handle, flags, count);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -362,7 +362,7 @@ s32 sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, vm::ptr<SceNpTrophy
 	u32 count_ = ctxt->tropusr->GetTrophiesCount();
 	*count = count_;
 	if (count_ > 128)
-		sceNpTrophy.Error("sceNpTrophyGetTrophyUnlockState: More than 128 trophies detected!");
+		sceNpTrophy.error("sceNpTrophyGetTrophyUnlockState: More than 128 trophies detected!");
 
 	// Pack up to 128 bools in u32 flag_bits[4]
 	for (u32 id = 0; id < count_; id++)
@@ -378,7 +378,7 @@ s32 sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, vm::ptr<SceNpTrophy
 
 s32 sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceNpTrophyDetails> details, vm::ptr<SceNpTrophyData> data)
 {
-	sceNpTrophy.Warning("sceNpTrophyGetTrophyInfo(context=0x%x, handle=0x%x, trophyId=%d, details=*0x%x, data=*0x%x)", context, handle, trophyId, details, data);
+	sceNpTrophy.warning("sceNpTrophyGetTrophyInfo(context=0x%x, handle=0x%x, trophyId=%d, details=*0x%x, data=*0x%x)", context, handle, trophyId, details, data);
 
 	const auto ctxt = idm::get<trophy_context_t>(context);
 
@@ -435,21 +435,21 @@ s32 sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceN
 
 s32 sceNpTrophyGetGameProgress(u32 context, u32 handle, vm::ptr<s32> percentage)
 {
-	sceNpTrophy.Todo("sceNpTrophyGetGameProgress(context=0x%x, handle=0x%x, percentage=*0x%x)", context, handle, percentage);
+	sceNpTrophy.todo("sceNpTrophyGetGameProgress(context=0x%x, handle=0x%x, percentage=*0x%x)", context, handle, percentage);
 
 	return CELL_OK;
 }
 
 s32 sceNpTrophyGetGameIcon(u32 context, u32 handle, vm::ptr<void> buffer, vm::ptr<u32> size)
 {
-	sceNpTrophy.Todo("sceNpTrophyGetGameIcon(context=0x%x, handle=0x%x, buffer=*0x%x, size=*0x%x)", context, handle, buffer, size);
+	sceNpTrophy.todo("sceNpTrophyGetGameIcon(context=0x%x, handle=0x%x, buffer=*0x%x, size=*0x%x)", context, handle, buffer, size);
 
 	return CELL_OK;
 }
 
 s32 sceNpTrophyGetTrophyIcon(u32 context, u32 handle, s32 trophyId, vm::ptr<void> buffer, vm::ptr<u32> size)
 {
-	sceNpTrophy.Todo("sceNpTrophyGetTrophyIcon(context=0x%x, handle=0x%x, trophyId=%d, buffer=*0x%x, size=*0x%x)", context, handle, trophyId, buffer, size);
+	sceNpTrophy.todo("sceNpTrophyGetTrophyIcon(context=0x%x, handle=0x%x, trophyId=%d, buffer=*0x%x, size=*0x%x)", context, handle, trophyId, buffer, size);
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sceNpTus.cpp

@@ -9,14 +9,14 @@ extern Module<> sceNpTus;
 
 s32 sceNpTusInit()
 {
-	sceNpTus.Warning("sceNpTusInit()");
+	sceNpTus.warning("sceNpTusInit()");
 
 	return CELL_OK;
 }
 
 s32 sceNpTusTerm()
 {
-	sceNpTus.Warning("sceNpTusTerm()");
+	sceNpTus.warning("sceNpTusTerm()");
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -21,7 +21,7 @@ std::array<std::atomic<u32>, TLS_MAX> g_tls_owners;
 
 void sys_initialize_tls()
 {
-	sysPrxForUser.Log("sys_initialize_tls()");
+	sysPrxForUser.trace("sys_initialize_tls()");
 }
 
 u32 ppu_get_tls(u32 thread)
@@ -79,33 +79,33 @@ void ppu_free_tls(u32 thread)
 
 s64 sys_time_get_system_time()
 {
-	sysPrxForUser.Log("sys_time_get_system_time()");
+	sysPrxForUser.trace("sys_time_get_system_time()");
 
 	return get_system_time();
 }
 
 s64 _sys_process_atexitspawn()
 {
-	sysPrxForUser.Log("_sys_process_atexitspawn()");
+	sysPrxForUser.trace("_sys_process_atexitspawn()");
 	return CELL_OK;
 }
 
 s64 _sys_process_at_Exitspawn()
 {
-	sysPrxForUser.Log("_sys_process_at_Exitspawn");
+	sysPrxForUser.trace("_sys_process_at_Exitspawn");
 	return CELL_OK;
 }
 
 s32 sys_interrupt_thread_disestablish(PPUThread& ppu, u32 ih)
 {
-	sysPrxForUser.Todo("sys_interrupt_thread_disestablish(ih=0x%x)", ih);
+	sysPrxForUser.todo("sys_interrupt_thread_disestablish(ih=0x%x)", ih);
 
 	return _sys_interrupt_thread_disestablish(ppu, ih, vm::var<u64>{});
 }
 
 s32 sys_process_is_stack(u32 p)
 {
-	sysPrxForUser.Log("sys_process_is_stack(p=0x%x)", p);
+	sysPrxForUser.trace("sys_process_is_stack(p=0x%x)", p);
 
 	// prx: compare high 4 bits with "0xD"
 	return (p >> 28) == 0xD;
@@ -113,7 +113,7 @@ s32 sys_process_is_stack(u32 p)
 
 s32 sys_process_get_paramsfo(vm::ptr<char> buffer)
 {
-	sysPrxForUser.Warning("sys_process_get_paramsfo(buffer=*0x%x)", buffer);
+	sysPrxForUser.warning("sys_process_get_paramsfo(buffer=*0x%x)", buffer);
 
 	// prx: load some data (0x40 bytes) previously set by _sys_process_get_paramsfo syscall
 	return _sys_process_get_paramsfo(buffer);
@@ -121,7 +121,7 @@ s32 sys_process_get_paramsfo(vm::ptr<char> buffer)
 
 s32 sys_get_random_number(vm::ptr<u8> addr, u64 size)
 {
-	sysPrxForUser.Warning("sys_get_random_number(addr=*0x%x, size=%d)", addr, size);
+	sysPrxForUser.warning("sys_get_random_number(addr=*0x%x, size=%d)", addr, size);
 
 	if (size > 4096)
 		size = 4096;
@@ -146,9 +146,9 @@ s32 console_putc()
 
 s32 console_write(vm::ptr<char> data, u32 len)
 {
-	sysPrxForUser.Warning("console_write(data=*0x%x, len=%d)", data, len);
+	sysPrxForUser.warning("console_write(data=*0x%x, len=%d)", data, len);
 
-	LOG_NOTICE(TTY, { data.get_ptr(), len });
+	_log::g_tty_file.log({ data.get_ptr(), len });
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sys_game.cpp

@@ -20,14 +20,14 @@ void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_add
 		start_pos += to.length();
 	}
 
-	sysPrxForUser.Todo("sys_game_process_exitspawn()");
+	sysPrxForUser.todo("sys_game_process_exitspawn()");
-	sysPrxForUser.Warning("path: %s", _path.c_str());
+	sysPrxForUser.warning("path: %s", _path.c_str());
-	sysPrxForUser.Warning("argv: 0x%x", argv_addr);
+	sysPrxForUser.warning("argv: 0x%x", argv_addr);
-	sysPrxForUser.Warning("envp: 0x%x", envp_addr);
+	sysPrxForUser.warning("envp: 0x%x", envp_addr);
-	sysPrxForUser.Warning("data: 0x%x", data_addr);
+	sysPrxForUser.warning("data: 0x%x", data_addr);
-	sysPrxForUser.Warning("data_size: 0x%x", data_size);
+	sysPrxForUser.warning("data_size: 0x%x", data_size);
-	sysPrxForUser.Warning("prio: %d", prio);
+	sysPrxForUser.warning("prio: %d", prio);
-	sysPrxForUser.Warning("flags: %d", flags);
+	sysPrxForUser.warning("flags: %d", flags);
 
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
@@ -43,7 +43,7 @@ void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_add
 
 		for (auto &arg : argv)
 		{
-			sysPrxForUser.Log("argument: %s", arg.c_str());
+			sysPrxForUser.trace("argument: %s", arg.c_str());
 		}
 	}
 
@@ -58,7 +58,7 @@ void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_add
 
 		for (auto &en : env)
 		{
-			sysPrxForUser.Log("env_argument: %s", en.c_str());
+			sysPrxForUser.trace("env_argument: %s", en.c_str());
 		}
 	}
 
@@ -68,7 +68,7 @@ void sys_game_process_exitspawn(vm::cptr<char> path, u32 argv_addr, u32 envp_add
 	// then kill the current process
 
 	Emu.Pause();
-	sysPrxForUser.Success("Process finished");
+	sysPrxForUser.success("Process finished");
 
 	Emu.CallAfter([=]()
 	{
@@ -96,14 +96,14 @@ void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_ad
 		start_pos += to.length();
 	}
 
-	sysPrxForUser.Warning("sys_game_process_exitspawn2()");
+	sysPrxForUser.warning("sys_game_process_exitspawn2()");
-	sysPrxForUser.Warning("path: %s", _path.c_str());
+	sysPrxForUser.warning("path: %s", _path.c_str());
-	sysPrxForUser.Warning("argv: 0x%x", argv_addr);
+	sysPrxForUser.warning("argv: 0x%x", argv_addr);
-	sysPrxForUser.Warning("envp: 0x%x", envp_addr);
+	sysPrxForUser.warning("envp: 0x%x", envp_addr);
-	sysPrxForUser.Warning("data: 0x%x", data_addr);
+	sysPrxForUser.warning("data: 0x%x", data_addr);
-	sysPrxForUser.Warning("data_size: 0x%x", data_size);
+	sysPrxForUser.warning("data_size: 0x%x", data_size);
-	sysPrxForUser.Warning("prio: %d", prio);
+	sysPrxForUser.warning("prio: %d", prio);
-	sysPrxForUser.Warning("flags: %d", flags);
+	sysPrxForUser.warning("flags: %d", flags);
 
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
@@ -119,7 +119,7 @@ void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_ad
 
 		for (auto &arg : argv)
 		{
-			sysPrxForUser.Log("argument: %s", arg.c_str());
+			sysPrxForUser.trace("argument: %s", arg.c_str());
 		}
 	}
 
@@ -134,7 +134,7 @@ void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_ad
 
 		for (auto &en : env)
 		{
-			sysPrxForUser.Log("env_argument: %s", en.c_str());
+			sysPrxForUser.trace("env_argument: %s", en.c_str());
 		}
 	}
 
@@ -144,7 +144,7 @@ void sys_game_process_exitspawn2(vm::cptr<char> path, u32 argv_addr, u32 envp_ad
 	// then kill the current process
 
 	Emu.Pause();
-	sysPrxForUser.Success("Process finished");
+	sysPrxForUser.success("Process finished");
 
 	Emu.CallAfter([=]()
 	{

rpcs3/Emu/SysCalls/Modules/sys_heap.cpp

@@ -20,14 +20,14 @@ struct HeapInfo
 
 u32 _sys_heap_create_heap(vm::cptr<char> name, u32 arg2, u32 arg3, u32 arg4)
 {
-	sysPrxForUser.Warning("_sys_heap_create_heap(name=*0x%x, arg2=0x%x, arg3=0x%x, arg4=0x%x)", name, arg2, arg3, arg4);
+	sysPrxForUser.warning("_sys_heap_create_heap(name=*0x%x, arg2=0x%x, arg3=0x%x, arg4=0x%x)", name, arg2, arg3, arg4);
 
 	return idm::make<HeapInfo>(name.get_ptr());
 }
 
 s32 _sys_heap_delete_heap(u32 heap)
 {
-	sysPrxForUser.Warning("_sys_heap_delete_heap(heap=0x%x)", heap);
+	sysPrxForUser.warning("_sys_heap_delete_heap(heap=0x%x)", heap);
 
 	idm::remove<HeapInfo>(heap);
 
@@ -36,21 +36,21 @@ s32 _sys_heap_delete_heap(u32 heap)
 
 u32 _sys_heap_malloc(u32 heap, u32 size)
 {
-	sysPrxForUser.Warning("_sys_heap_malloc(heap=0x%x, size=0x%x)", heap, size);
+	sysPrxForUser.warning("_sys_heap_malloc(heap=0x%x, size=0x%x)", heap, size);
 
 	return vm::alloc(size, vm::main);
 }
 
 u32 _sys_heap_memalign(u32 heap, u32 align, u32 size)
 {
-	sysPrxForUser.Warning("_sys_heap_memalign(heap=0x%x, align=0x%x, size=0x%x)", heap, align, size);
+	sysPrxForUser.warning("_sys_heap_memalign(heap=0x%x, align=0x%x, size=0x%x)", heap, align, size);
 
 	return vm::alloc(size, vm::main, std::max<u32>(align, 4096));
 }
 
 s32 _sys_heap_free(u32 heap, u32 addr)
 {
-	sysPrxForUser.Warning("_sys_heap_free(heap=0x%x, addr=0x%x)", heap, addr);
+	sysPrxForUser.warning("_sys_heap_free(heap=0x%x, addr=0x%x)", heap, addr);
 
 	vm::dealloc(addr, vm::main);
 

rpcs3/Emu/SysCalls/Modules/sys_libc.cpp

@@ -153,7 +153,7 @@ namespace sys_libc_func
 {
 	void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 	{
-		sys_libc.Log("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
+		sys_libc.trace("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
 
 		::memcpy(dst.get_ptr(), src.get_ptr(), size);
 	}
@@ -163,7 +163,7 @@ extern Module<> sysPrxForUser;
 
 vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size)
 {
-	sysPrxForUser.Log("_sys_memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
+	sysPrxForUser.trace("_sys_memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
 
 	memset(dst.get_ptr(), value, size);
 
@@ -172,7 +172,7 @@ vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size)
 
 vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 {
-	sysPrxForUser.Log("_sys_memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
+	sysPrxForUser.trace("_sys_memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
 
 	memcpy(dst.get_ptr(), src.get_ptr(), size);
 
@@ -181,7 +181,7 @@ vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 
 s32 _sys_memcmp(vm::cptr<void> buf1, vm::cptr<void> buf2, u32 size)
 {
-	sysPrxForUser.Log("_sys_memcmp(buf1=*0x%x, buf2=*0x%x, size=%d)", buf1, buf2, size);
+	sysPrxForUser.trace("_sys_memcmp(buf1=*0x%x, buf2=*0x%x, size=%d)", buf1, buf2, size);
 
 	return memcmp(buf1.get_ptr(), buf2.get_ptr(), size);
 }
@@ -198,28 +198,28 @@ s32 _sys_memmove()
 
 s64 _sys_strlen(vm::cptr<char> str)
 {
-	sysPrxForUser.Log("_sys_strlen(str=*0x%x)", str);
+	sysPrxForUser.trace("_sys_strlen(str=*0x%x)", str);
 
 	return strlen(str.get_ptr());
 }
 
 s32 _sys_strcmp(vm::cptr<char> str1, vm::cptr<char> str2)
 {
-	sysPrxForUser.Log("_sys_strcmp(str1=*0x%x, str2=*0x%x)", str1, str2);
+	sysPrxForUser.trace("_sys_strcmp(str1=*0x%x, str2=*0x%x)", str1, str2);
 
 	return strcmp(str1.get_ptr(), str2.get_ptr());
 }
 
 s32 _sys_strncmp(vm::cptr<char> str1, vm::cptr<char> str2, s32 max)
 {
-	sysPrxForUser.Log("_sys_strncmp(str1=*0x%x, str2=*0x%x, max=%d)", str1, str2, max);
+	sysPrxForUser.trace("_sys_strncmp(str1=*0x%x, str2=*0x%x, max=%d)", str1, str2, max);
 
 	return strncmp(str1.get_ptr(), str2.get_ptr(), max);
 }
 
 vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::cptr<char> source)
 {
-	sysPrxForUser.Log("_sys_strcat(dest=*0x%x, source=*0x%x)", dest, source);
+	sysPrxForUser.trace("_sys_strcat(dest=*0x%x, source=*0x%x)", dest, source);
 
 	if (strcat(dest.get_ptr(), source.get_ptr()) != dest.get_ptr())
 	{
@@ -231,14 +231,14 @@ vm::ptr<char> _sys_strcat(vm::ptr<char> dest, vm::cptr<char> source)
 
 vm::cptr<char> _sys_strchr(vm::cptr<char> str, s32 ch)
 {
-	sysPrxForUser.Log("_sys_strchr(str=*0x%x, ch=0x%x)", str, ch);
+	sysPrxForUser.trace("_sys_strchr(str=*0x%x, ch=0x%x)", str, ch);
 
 	return vm::cptr<char>::make(vm::get_addr(strchr(str.get_ptr(), ch)));
 }
 
 vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
 {
-	sysPrxForUser.Log("_sys_strncat(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
+	sysPrxForUser.trace("_sys_strncat(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
 
 	if (strncat(dest.get_ptr(), source.get_ptr(), len) != dest.get_ptr())
 	{
@@ -250,7 +250,7 @@ vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
 
 vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::cptr<char> source)
 {
-	sysPrxForUser.Log("_sys_strcpy(dest=*0x%x, source=*0x%x)", dest, source);
+	sysPrxForUser.trace("_sys_strcpy(dest=*0x%x, source=*0x%x)", dest, source);
 
 	if (strcpy(dest.get_ptr(), source.get_ptr()) != dest.get_ptr())
 	{
@@ -262,7 +262,7 @@ vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::cptr<char> source)
 
 vm::ptr<char> _sys_strncpy(vm::ptr<char> dest, vm::cptr<char> source, u32 len)
 {
-	sysPrxForUser.Log("_sys_strncpy(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
+	sysPrxForUser.trace("_sys_strncpy(dest=*0x%x, source=*0x%x, len=%d)", dest, source, len);
 
 	if (!dest || !source)
 	{
@@ -299,21 +299,21 @@ s32 _sys_toupper()
 
 u32 _sys_malloc(u32 size)
 {
-	sysPrxForUser.Warning("_sys_malloc(size=0x%x)", size);
+	sysPrxForUser.warning("_sys_malloc(size=0x%x)", size);
 
 	return vm::alloc(size, vm::main);
 }
 
 u32 _sys_memalign(u32 align, u32 size)
 {
-	sysPrxForUser.Warning("_sys_memalign(align=0x%x, size=0x%x)", align, size);
+	sysPrxForUser.warning("_sys_memalign(align=0x%x, size=0x%x)", align, size);
 
 	return vm::alloc(size, vm::main, std::max<u32>(align, 4096));
 }
 
 s32 _sys_free(u32 addr)
 {
-	sysPrxForUser.Warning("_sys_free(addr=0x%x)", addr);
+	sysPrxForUser.warning("_sys_free(addr=0x%x)", addr);
 
 	vm::dealloc(addr, vm::main);
 
@@ -322,11 +322,11 @@ s32 _sys_free(u32 addr)
 
 s32 _sys_snprintf(PPUThread& ppu, vm::ptr<char> dst, u32 count, vm::cptr<char> fmt, ppu_va_args_t va_args)
 {
-	sysPrxForUser.Warning("_sys_snprintf(dst=*0x%x, count=%d, fmt=*0x%x, ...)", dst, count, fmt);
+	sysPrxForUser.warning("_sys_snprintf(dst=*0x%x, count=%d, fmt=*0x%x, ...)", dst, count, fmt);
 
 	std::string result = ps3_fmt(ppu, fmt, va_args.g_count, va_args.f_count, va_args.v_count);
 
-	sysPrxForUser.Warning("*** '%s' -> '%s'", fmt.get_ptr(), result);
+	sysPrxForUser.warning("*** '%s' -> '%s'", fmt.get_ptr(), result);
 
 	if (!count)
 	{
@@ -344,10 +344,9 @@ s32 _sys_snprintf(PPUThread& ppu, vm::ptr<char> dst, u32 count, vm::cptr<char> f
 
 s32 _sys_printf(PPUThread& ppu, vm::cptr<char> fmt, ppu_va_args_t va_args)
 {
-	sysPrxForUser.Warning("_sys_printf(fmt=*0x%x, ...)", fmt);
+	sysPrxForUser.warning("_sys_printf(fmt=*0x%x, ...)", fmt);
-	std::string result = ps3_fmt(ppu, fmt, va_args.g_count, va_args.f_count, va_args.v_count);
 
-	LOG_ERROR(TTY, result);
+	_log::g_tty_file.log(ps3_fmt(ppu, fmt, va_args.g_count, va_args.f_count, va_args.v_count));
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/sys_lwcond_.cpp

@@ -13,7 +13,7 @@ extern Module<> sysPrxForUser;
 
 s32 sys_lwcond_create(vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr)
 {
-	sysPrxForUser.Warning("sys_lwcond_create(lwcond=*0x%x, lwmutex=*0x%x, attr=*0x%x)", lwcond, lwmutex, attr);
+	sysPrxForUser.warning("sys_lwcond_create(lwcond=*0x%x, lwmutex=*0x%x, attr=*0x%x)", lwcond, lwmutex, attr);
 
 	lwcond->lwcond_queue = idm::make<lv2_lwcond_t>(reinterpret_cast<u64&>(attr->name));
 	lwcond->lwmutex = lwmutex;
@@ -23,7 +23,7 @@ s32 sys_lwcond_create(vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmut
 
 s32 sys_lwcond_destroy(vm::ptr<sys_lwcond_t> lwcond)
 {
-	sysPrxForUser.Log("sys_lwcond_destroy(lwcond=*0x%x)", lwcond);
+	sysPrxForUser.trace("sys_lwcond_destroy(lwcond=*0x%x)", lwcond);
 
 	const s32 res = _sys_lwcond_destroy(lwcond->lwcond_queue);
 
@@ -37,7 +37,7 @@ s32 sys_lwcond_destroy(vm::ptr<sys_lwcond_t> lwcond)
 
 s32 sys_lwcond_signal(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond)
 {
-	sysPrxForUser.Log("sys_lwcond_signal(lwcond=*0x%x)", lwcond);
+	sysPrxForUser.trace("sys_lwcond_signal(lwcond=*0x%x)", lwcond);
 
 	const vm::ptr<sys_lwmutex_t> lwmutex = lwcond->lwmutex;
 
@@ -95,7 +95,7 @@ s32 sys_lwcond_signal(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond)
 
 s32 sys_lwcond_signal_all(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond)
 {
-	sysPrxForUser.Log("sys_lwcond_signal_all(lwcond=*0x%x)", lwcond);
+	sysPrxForUser.trace("sys_lwcond_signal_all(lwcond=*0x%x)", lwcond);
 
 	const vm::ptr<sys_lwmutex_t> lwmutex = lwcond->lwmutex;
 
@@ -152,7 +152,7 @@ s32 sys_lwcond_signal_all(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond)
 
 s32 sys_lwcond_signal_to(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond, u32 ppu_thread_id)
 {
-	sysPrxForUser.Log("sys_lwcond_signal_to(lwcond=*0x%x, ppu_thread_id=0x%x)", lwcond, ppu_thread_id);
+	sysPrxForUser.trace("sys_lwcond_signal_to(lwcond=*0x%x, ppu_thread_id=0x%x)", lwcond, ppu_thread_id);
 
 	const vm::ptr<sys_lwmutex_t> lwmutex = lwcond->lwmutex;
 
@@ -210,7 +210,7 @@ s32 sys_lwcond_signal_to(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond, u32 ppu_t
 
 s32 sys_lwcond_wait(PPUThread& ppu, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
 {
-	sysPrxForUser.Log("sys_lwcond_wait(lwcond=*0x%x, timeout=0x%llx)", lwcond, timeout);
+	sysPrxForUser.trace("sys_lwcond_wait(lwcond=*0x%x, timeout=0x%llx)", lwcond, timeout);
 
 	const be_t<u32> tid = ppu.get_id();
 

rpcs3/Emu/SysCalls/Modules/sys_lwmutex_.cpp

@@ -12,13 +12,13 @@ extern Module<> sysPrxForUser;
 
 s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr)
 {
-	sysPrxForUser.Warning("sys_lwmutex_create(lwmutex=*0x%x, attr=*0x%x)", lwmutex, attr);
+	sysPrxForUser.warning("sys_lwmutex_create(lwmutex=*0x%x, attr=*0x%x)", lwmutex, attr);
 
 	const bool recursive = attr->recursive == SYS_SYNC_RECURSIVE;
 
 	if (!recursive && attr->recursive != SYS_SYNC_NOT_RECURSIVE)
 	{
-		sysPrxForUser.Error("sys_lwmutex_create(): invalid recursive attribute (0x%x)", attr->recursive);
+		sysPrxForUser.error("sys_lwmutex_create(): invalid recursive attribute (0x%x)", attr->recursive);
 		return CELL_EINVAL;
 	}
 
@@ -29,7 +29,7 @@ s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attri
 	case SYS_SYNC_FIFO: break;
 	case SYS_SYNC_RETRY: break;
 	case SYS_SYNC_PRIORITY: break;
-	default: sysPrxForUser.Error("sys_lwmutex_create(): invalid protocol (0x%x)", protocol); return CELL_EINVAL;
+	default: sysPrxForUser.error("sys_lwmutex_create(): invalid protocol (0x%x)", protocol); return CELL_EINVAL;
 	}
 
 	lwmutex->lock_var.store({ lwmutex_free, 0 });
@@ -42,7 +42,7 @@ s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attri
 
 s32 sys_lwmutex_destroy(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sysPrxForUser.Log("sys_lwmutex_destroy(lwmutex=*0x%x)", lwmutex);
+	sysPrxForUser.trace("sys_lwmutex_destroy(lwmutex=*0x%x)", lwmutex);
 
 	// check to prevent recursive locking in the next call
 	if (lwmutex->vars.owner.load() == ppu.get_id())
@@ -73,7 +73,7 @@ s32 sys_lwmutex_destroy(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex)
 
 s32 sys_lwmutex_lock(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout)
 {
-	sysPrxForUser.Log("sys_lwmutex_lock(lwmutex=*0x%x, timeout=0x%llx)", lwmutex, timeout);
+	sysPrxForUser.trace("sys_lwmutex_lock(lwmutex=*0x%x, timeout=0x%llx)", lwmutex, timeout);
 
 	const be_t<u32> tid = ppu.get_id();
 
@@ -167,7 +167,7 @@ s32 sys_lwmutex_lock(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
 
 s32 sys_lwmutex_trylock(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sysPrxForUser.Log("sys_lwmutex_trylock(lwmutex=*0x%x)", lwmutex);
+	sysPrxForUser.trace("sys_lwmutex_trylock(lwmutex=*0x%x)", lwmutex);
 
 	const be_t<u32> tid = ppu.get_id();
 
@@ -234,7 +234,7 @@ s32 sys_lwmutex_trylock(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex)
 
 s32 sys_lwmutex_unlock(PPUThread& ppu, vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sysPrxForUser.Log("sys_lwmutex_unlock(lwmutex=*0x%x)", lwmutex);
+	sysPrxForUser.trace("sys_lwmutex_unlock(lwmutex=*0x%x)", lwmutex);
 
 	const be_t<u32> tid = ppu.get_id();
 

rpcs3/Emu/SysCalls/Modules/sys_mempool.cpp

@@ -26,7 +26,7 @@ s32 sys_mempool_allocate_block()
 
 s32 sys_mempool_create(vm::ptr<sys_mempool_t> mempool, vm::ptr<void> chunk, const u64 chunk_size, const u64 block_size, const u64 ralignment)
 {
-	sysPrxForUser.Warning("sys_mempool_create(mempool=*0x%x, chunk=*0x%x, chunk_size=%d, block_size=%d, ralignment=%d)", mempool, chunk, chunk_size, block_size, ralignment);
+	sysPrxForUser.warning("sys_mempool_create(mempool=*0x%x, chunk=*0x%x, chunk_size=%d, block_size=%d, ralignment=%d)", mempool, chunk, chunk_size, block_size, ralignment);
 
 	if (block_size > chunk_size)
 	{
@@ -74,14 +74,14 @@ s32 sys_mempool_create(vm::ptr<sys_mempool_t> mempool, vm::ptr<void> chunk, cons
 
 void sys_mempool_destroy(sys_mempool_t mempool)
 {
-	sysPrxForUser.Warning("sys_mempool_destroy(mempool=%d)", mempool);
+	sysPrxForUser.warning("sys_mempool_destroy(mempool=%d)", mempool);
 
 	idm::remove<memory_pool_t>(mempool);
 }
 
 s32 sys_mempool_free_block(sys_mempool_t mempool, vm::ptr<void> block)
 {
-	sysPrxForUser.Warning("sys_mempool_free_block(mempool=%d, block=*0x%x)", mempool, block);
+	sysPrxForUser.warning("sys_mempool_free_block(mempool=%d, block=*0x%x)", mempool, block);
 
 	auto memory_pool = idm::get<memory_pool_t>(mempool);
 	if (!memory_pool)
@@ -100,7 +100,7 @@ s32 sys_mempool_free_block(sys_mempool_t mempool, vm::ptr<void> block)
 
 u64 sys_mempool_get_count(sys_mempool_t mempool)
 {
-	sysPrxForUser.Warning("sys_mempool_get_count(mempool=%d)", mempool);
+	sysPrxForUser.warning("sys_mempool_get_count(mempool=%d)", mempool);
 
 	auto memory_pool = idm::get<memory_pool_t>(mempool);
 	if (!memory_pool)
@@ -113,7 +113,7 @@ u64 sys_mempool_get_count(sys_mempool_t mempool)
 
 vm::ptr<void> sys_mempool_try_allocate_block(sys_mempool_t mempool)
 {
-	sysPrxForUser.Warning("sys_mempool_try_allocate_block(mempool=%d)", mempool);
+	sysPrxForUser.warning("sys_mempool_try_allocate_block(mempool=%d)", mempool);
 
 	auto memory_pool = idm::get<memory_pool_t>(mempool);
 

rpcs3/Emu/SysCalls/Modules/sys_net.cpp

@@ -104,7 +104,7 @@ void copy_fdset(fd_set* set, vm::ptr<sys_net::fd_set> src)
 				if (src->fds_bits[i] & (1 << bit))
 				{
 					u32 sock = (i << 5) | bit;
-					//libnet.Error("setting: fd %d", sock);
+					//libnet.error("setting: fd %d", sock);
 					FD_SET(g_socketMap[sock], set);
 				}
 			}
@@ -154,7 +154,7 @@ namespace sys_net
 	// Functions
 	s32 accept(s32 s, vm::ptr<sockaddr> addr, vm::ptr<u32> paddrlen)
 	{
-		libnet.Warning("accept(s=%d, family=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
+		libnet.warning("accept(s=%d, family=*0x%x, paddrlen=*0x%x)", s, addr, paddrlen);
 		s = g_socketMap[s];
 
 		if (!addr) {
@@ -176,14 +176,14 @@ namespace sys_net
 
 	s32 bind(s32 s, vm::cptr<sockaddr> addr, u32 addrlen)
 	{
-		libnet.Warning("bind(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
+		libnet.warning("bind(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
 		s = g_socketMap[s];
 
 		::sockaddr_in saddr;
 		memcpy(&saddr, addr.get_ptr(), sizeof(::sockaddr_in));
 		saddr.sin_family = addr->sa_family;
 		const char *ipaddr = ::inet_ntoa(saddr.sin_addr);
-		libnet.Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
+		libnet.warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
 		s32 ret = ::bind(s, (const ::sockaddr*)&saddr, addrlen);
 		get_errno() = getLastError();
 
@@ -192,14 +192,14 @@ namespace sys_net
 
 	s32 connect(s32 s, vm::ptr<sockaddr> addr, u32 addrlen)
 	{
-		libnet.Warning("connect(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
+		libnet.warning("connect(s=%d, family=*0x%x, addrlen=%d)", s, addr, addrlen);
 		s = g_socketMap[s];
 
 		::sockaddr_in saddr;
 		memcpy(&saddr, addr.get_ptr(), sizeof(::sockaddr_in));
 		saddr.sin_family = addr->sa_family;
 		const char *ipaddr = ::inet_ntoa(saddr.sin_addr);
-		libnet.Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
+		libnet.warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
 		s32 ret = ::connect(s, (const ::sockaddr*)&saddr, addrlen);
 		get_errno() = getLastError();
 
@@ -238,7 +238,7 @@ namespace sys_net
 
 	u32 inet_addr(vm::cptr<char> cp)
 	{
-		libnet.Warning("inet_addr(cp=*0x%x)", cp);
+		libnet.warning("inet_addr(cp=*0x%x)", cp);
 		return htonl(::inet_addr(cp.get_ptr())); // return a big-endian IP address (WTF? function should return LITTLE-ENDIAN value)
 	}
 
@@ -280,7 +280,7 @@ namespace sys_net
 
 	vm::cptr<char> inet_ntop(s32 af, vm::ptr<void> src, vm::ptr<char> dst, u32 size)
 	{
-		libnet.Warning("inet_ntop(af=%d, src=*0x%x, dst=*0x%x, size=%d)", af, src, dst, size);
+		libnet.warning("inet_ntop(af=%d, src=*0x%x, dst=*0x%x, size=%d)", af, src, dst, size);
 		const char* result = ::inet_ntop(af, src.get_ptr(), dst.get_ptr(), size);
 
 		if (result == nullptr)
@@ -293,13 +293,13 @@ namespace sys_net
 
 	s32 inet_pton(s32 af, vm::cptr<char> src, vm::ptr<char> dst)
 	{
-		libnet.Warning("inet_pton(af=%d, src=*0x%x, dst=*0x%x)", af, src, dst);
+		libnet.warning("inet_pton(af=%d, src=*0x%x, dst=*0x%x)", af, src, dst);
 		return ::inet_pton(af, src.get_ptr(), dst.get_ptr());
 	}
 
 	s32 listen(s32 s, s32 backlog)
 	{
-		libnet.Warning("listen(s=%d, backlog=%d)", s, backlog);
+		libnet.warning("listen(s=%d, backlog=%d)", s, backlog);
 		s = g_socketMap[s];
 		s32 ret = ::listen(s, backlog);
 		get_errno() = getLastError();
@@ -309,7 +309,7 @@ namespace sys_net
 
 	s32 recv(s32 s, vm::ptr<char> buf, u32 len, s32 flags)
 	{
-		libnet.Warning("recv(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
+		libnet.warning("recv(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
 		s = g_socketMap[s];
 
 		s32 ret = ::recv(s, buf.get_ptr(), len, flags);
@@ -320,7 +320,7 @@ namespace sys_net
 
 	s32 recvfrom(s32 s, vm::ptr<char> buf, u32 len, s32 flags, vm::ptr<sockaddr> addr, vm::ptr<u32> paddrlen)
 	{
-		libnet.Warning("recvfrom(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, paddrlen=*0x%x)", s, buf, len, flags, addr, paddrlen);
+		libnet.warning("recvfrom(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, paddrlen=*0x%x)", s, buf, len, flags, addr, paddrlen);
 		s = g_socketMap[s];
 
 		::sockaddr _addr;
@@ -342,7 +342,7 @@ namespace sys_net
 
 	s32 send(s32 s, vm::cptr<char> buf, u32 len, s32 flags)
 	{
-		libnet.Warning("send(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
+		libnet.warning("send(s=%d, buf=*0x%x, len=%d, flags=0x%x)", s, buf, len, flags);
 		s = g_socketMap[s];
 
 		s32 ret = ::send(s, buf.get_ptr(), len, flags);
@@ -359,7 +359,7 @@ namespace sys_net
 
 	s32 sendto(s32 s, vm::cptr<char> buf, u32 len, s32 flags, vm::ptr<sockaddr> addr, u32 addrlen)
 	{
-		libnet.Warning("sendto(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, addrlen=%d)", s, buf, len, flags, addr, addrlen);
+		libnet.warning("sendto(s=%d, buf=*0x%x, len=%d, flags=0x%x, addr=*0x%x, addrlen=%d)", s, buf, len, flags, addr, addrlen);
 		s = g_socketMap[s];
 
 		::sockaddr _addr;
@@ -373,7 +373,7 @@ namespace sys_net
 
 	s32 setsockopt(s32 s, s32 level, s32 optname, vm::cptr<char> optval, u32 optlen)
 	{
-		libnet.Warning("socket(s=%d, level=%d, optname=%d, optval=*0x%x, optlen=%d)", s, level, optname, optval, optlen);
+		libnet.warning("socket(s=%d, level=%d, optname=%d, optval=*0x%x, optlen=%d)", s, level, optname, optval, optlen);
 		s = g_socketMap[s];
 
 		s32 ret = ::setsockopt(s, level, optname, optval.get_ptr(), optlen);
@@ -384,7 +384,7 @@ namespace sys_net
 
 	s32 shutdown(s32 s, s32 how)
 	{
-		libnet.Warning("shutdown(s=%d, how=%d)", s, how);
+		libnet.warning("shutdown(s=%d, how=%d)", s, how);
 		s = g_socketMap[s];
 
 		s32 ret = ::shutdown(s, how);
@@ -395,7 +395,7 @@ namespace sys_net
 
 	s32 socket(s32 family, s32 type, s32 protocol)
 	{
-		libnet.Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
+		libnet.warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
 
 		s32 sock = ::socket(family, type, protocol);
 		get_errno() = getLastError();
@@ -406,7 +406,7 @@ namespace sys_net
 
 	s32 socketclose(s32 s)
 	{
-		libnet.Warning("socket(s=%d)", s);
+		libnet.warning("socket(s=%d)", s);
 		s = g_socketMap[s];
 
 #ifdef _WIN32
@@ -426,7 +426,7 @@ namespace sys_net
 
 	s32 socketselect(s32 nfds, vm::ptr<fd_set> readfds, vm::ptr<fd_set> writefds, vm::ptr<fd_set> exceptfds, vm::ptr<timeval> timeout)
 	{
-		libnet.Warning("socketselect(nfds=%d, readfds=*0x%x, writefds=*0x%x, exceptfds=*0x%x, timeout=*0x%x)", nfds, readfds, writefds, exceptfds, timeout);
+		libnet.warning("socketselect(nfds=%d, readfds=*0x%x, writefds=*0x%x, exceptfds=*0x%x, timeout=*0x%x)", nfds, readfds, writefds, exceptfds, timeout);
 
 		::timeval _timeout;
 
@@ -436,7 +436,7 @@ namespace sys_net
 			_timeout.tv_usec = timeout->tv_usec;
 		}
 
-		//libnet.Error("timeval: %d . %d", _timeout.tv_sec, _timeout.tv_usec);
+		//libnet.error("timeval: %d . %d", _timeout.tv_sec, _timeout.tv_usec);
 
 		::fd_set _readfds;
 		::fd_set _writefds;
@@ -452,7 +452,7 @@ namespace sys_net
 
 		if (getLastError() >= 0)
 		{
-			libnet.Error("socketselect(): error %d", getLastError());
+			libnet.error("socketselect(): error %d", getLastError());
 		}
 
 		//return ret;
@@ -461,7 +461,7 @@ namespace sys_net
 
 	s32 sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter_t> param)
 	{
-		libnet.Warning("sys_net_initialize_network_ex(param=*0x%x)", param);
+		libnet.warning("sys_net_initialize_network_ex(param=*0x%x)", param);
 
 #ifdef _WIN32
 		WSADATA wsaData;
@@ -527,7 +527,7 @@ namespace sys_net
 
 	vm::ptr<s32> _sys_net_errno_loc()
 	{
-		libnet.Warning("_sys_net_errno_loc()");
+		libnet.warning("_sys_net_errno_loc()");
 
 		return get_errno().ptr();
 	}
@@ -594,7 +594,7 @@ namespace sys_net
 
 	s32 sys_net_finalize_network()
 	{
-		libnet.Warning("sys_net_initialize_network_ex()");
+		libnet.warning("sys_net_initialize_network_ex()");
 
 #ifdef _WIN32
 		WSACleanup();

rpcs3/Emu/SysCalls/Modules/sys_ppu_thread_.cpp

@@ -10,7 +10,7 @@ extern Module<> sysPrxForUser;
 
 s32 sys_ppu_thread_create(vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname)
 {
-	sysPrxForUser.Warning("sys_ppu_thread_create(thread_id=*0x%x, entry=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname=*0x%x)", thread_id, entry, arg, prio, stacksize, flags, threadname);
+	sysPrxForUser.warning("sys_ppu_thread_create(thread_id=*0x%x, entry=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname=*0x%x)", thread_id, entry, arg, prio, stacksize, flags, threadname);
 
 	// (allocate TLS)
 	// (return CELL_ENOMEM if failed)
@@ -28,7 +28,7 @@ s32 sys_ppu_thread_create(vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio,
 
 s32 sys_ppu_thread_get_id(PPUThread& ppu, vm::ptr<u64> thread_id)
 {
-	sysPrxForUser.Log("sys_ppu_thread_get_id(thread_id=*0x%x)", thread_id);
+	sysPrxForUser.trace("sys_ppu_thread_get_id(thread_id=*0x%x)", thread_id);
 
 	*thread_id = ppu.get_id();
 
@@ -37,7 +37,7 @@ s32 sys_ppu_thread_get_id(PPUThread& ppu, vm::ptr<u64> thread_id)
 
 void sys_ppu_thread_exit(PPUThread& ppu, u64 val)
 {
-	sysPrxForUser.Log("sys_ppu_thread_exit(val=0x%llx)", val);
+	sysPrxForUser.trace("sys_ppu_thread_exit(val=0x%llx)", val);
 
 	// (call registered atexit functions)
 	// (deallocate TLS)
@@ -57,7 +57,7 @@ std::mutex g_once_mutex;
 
 void sys_ppu_thread_once(PPUThread& ppu, vm::ptr<atomic_be_t<u32>> once_ctrl, vm::ptr<void()> init)
 {
-	sysPrxForUser.Warning("sys_ppu_thread_once(once_ctrl=*0x%x, init=*0x%x)", once_ctrl, init);
+	sysPrxForUser.warning("sys_ppu_thread_once(once_ctrl=*0x%x, init=*0x%x)", once_ctrl, init);
 
 	std::lock_guard<std::mutex> lock(g_once_mutex);
 

rpcs3/Emu/SysCalls/Modules/sys_prx_.cpp

@@ -10,7 +10,7 @@ extern Module<> sysPrxForUser;
 
 s64 sys_prx_exitspawn_with_level()
 {
-	sysPrxForUser.Log("sys_prx_exitspawn_with_level()");
+	sysPrxForUser.trace("sys_prx_exitspawn_with_level()");
 	return CELL_OK;
 }
 

rpcs3/Emu/SysCalls/Modules/sys_spinlock.cpp

@@ -9,14 +9,14 @@ extern Module<> sysPrxForUser;
 
 void sys_spinlock_initialize(vm::ptr<atomic_be_t<u32>> lock)
 {
-	sysPrxForUser.Log("sys_spinlock_initialize(lock=*0x%x)", lock);
+	sysPrxForUser.trace("sys_spinlock_initialize(lock=*0x%x)", lock);
 
 	lock->exchange(0);
 }
 
 void sys_spinlock_lock(PPUThread& ppu, vm::ptr<atomic_be_t<u32>> lock)
 {
-	sysPrxForUser.Log("sys_spinlock_lock(lock=*0x%x)", lock);
+	sysPrxForUser.trace("sys_spinlock_lock(lock=*0x%x)", lock);
 
 	// prx: exchange with 0xabadcafe, repeat until exchanged with 0
 	vm::wait_op(ppu, lock.addr(), 4, WRAP_EXPR(!lock->exchange(0xabadcafe)));
@@ -24,7 +24,7 @@ void sys_spinlock_lock(PPUThread& ppu, vm::ptr<atomic_be_t<u32>> lock)
 
 s32 sys_spinlock_trylock(vm::ptr<atomic_be_t<u32>> lock)
 {
-	sysPrxForUser.Log("sys_spinlock_trylock(lock=*0x%x)", lock);
+	sysPrxForUser.trace("sys_spinlock_trylock(lock=*0x%x)", lock);
 
 	if (lock->exchange(0xabadcafe))
 	{
@@ -36,7 +36,7 @@ s32 sys_spinlock_trylock(vm::ptr<atomic_be_t<u32>> lock)
 
 void sys_spinlock_unlock(vm::ptr<atomic_be_t<u32>> lock)
 {
-	sysPrxForUser.Log("sys_spinlock_unlock(lock=*0x%x)", lock);
+	sysPrxForUser.trace("sys_spinlock_unlock(lock=*0x%x)", lock);
 
 	lock->exchange(0);
 

rpcs3/Emu/SysCalls/Modules/sys_spu_.cpp

@@ -20,39 +20,39 @@ spu_printf_cb_t g_spu_printf_dtcb;
 
 s32 sys_spu_elf_get_information(u32 elf_img, vm::ptr<u32> entry, vm::ptr<s32> nseg)
 {
-	sysPrxForUser.Todo("sys_spu_elf_get_information(elf_img=0x%x, entry=*0x%x, nseg=*0x%x)", elf_img, entry, nseg);
+	sysPrxForUser.todo("sys_spu_elf_get_information(elf_img=0x%x, entry=*0x%x, nseg=*0x%x)", elf_img, entry, nseg);
 	return CELL_OK;
 }
 
 s32 sys_spu_elf_get_segments(u32 elf_img, vm::ptr<sys_spu_segment> segments, s32 nseg)
 {
-	sysPrxForUser.Todo("sys_spu_elf_get_segments(elf_img=0x%x, segments=*0x%x, nseg=0x%x)", elf_img, segments, nseg);
+	sysPrxForUser.todo("sys_spu_elf_get_segments(elf_img=0x%x, segments=*0x%x, nseg=0x%x)", elf_img, segments, nseg);
 	return CELL_OK;
 }
 
 s32 sys_spu_image_import(vm::ptr<sys_spu_image> img, u32 src, u32 type)
 {
-	sysPrxForUser.Warning("sys_spu_image_import(img=*0x%x, src=0x%x, type=%d)", img, src, type);
+	sysPrxForUser.warning("sys_spu_image_import(img=*0x%x, src=0x%x, type=%d)", img, src, type);
 
 	return spu_image_import(*img, src, type);
 }
 
 s32 sys_spu_image_close(vm::ptr<sys_spu_image> img)
 {
-	sysPrxForUser.Todo("sys_spu_image_close(img=*0x%x)", img);
+	sysPrxForUser.todo("sys_spu_image_close(img=*0x%x)", img);
 
 	return CELL_OK;
 }
 
 s32 sys_raw_spu_load(s32 id, vm::cptr<char> path, vm::ptr<u32> entry)
 {
-	sysPrxForUser.Warning("sys_raw_spu_load(id=%d, path=*0x%x, entry=*0x%x)", id, path, entry);
+	sysPrxForUser.warning("sys_raw_spu_load(id=%d, path=*0x%x, entry=*0x%x)", id, path, entry);
-	sysPrxForUser.Warning("*** path = '%s'", path.get_ptr());
+	sysPrxForUser.warning("*** path = '%s'", path.get_ptr());
 
 	vfsFile f(path.get_ptr());
 	if (!f.IsOpened())
 	{
-		sysPrxForUser.Error("sys_raw_spu_load error: '%s' not found!", path.get_ptr());
+		sysPrxForUser.error("sys_raw_spu_load error: '%s' not found!", path.get_ptr());
 		return CELL_ENOENT;
 	}
 
@@ -61,7 +61,7 @@ s32 sys_raw_spu_load(s32 id, vm::cptr<char> path, vm::ptr<u32> entry)
 
 	if (hdr.CheckMagic())
 	{
-		sysPrxForUser.Error("sys_raw_spu_load error: '%s' is encrypted! Decrypt SELF and try again.", path.get_ptr());
+		sysPrxForUser.error("sys_raw_spu_load error: '%s' is encrypted! Decrypt SELF and try again.", path.get_ptr());
 		Emu.Pause();
 		return CELL_ENOENT;
 	}
@@ -78,7 +78,7 @@ s32 sys_raw_spu_load(s32 id, vm::cptr<char> path, vm::ptr<u32> entry)
 
 s32 sys_raw_spu_image_load(PPUThread& ppu, s32 id, vm::ptr<sys_spu_image> img)
 {
-	sysPrxForUser.Warning("sys_raw_spu_image_load(id=%d, img=*0x%x)", id, img);
+	sysPrxForUser.warning("sys_raw_spu_image_load(id=%d, img=*0x%x)", id, img);
 
 	// TODO: use segment info
 
@@ -92,15 +92,15 @@ s32 sys_raw_spu_image_load(PPUThread& ppu, s32 id, vm::ptr<sys_spu_image> img)
 
 	const auto stamp2 = get_system_time();
 
-	sysPrxForUser.Error("memcpy() latency: %lldus", (stamp1 - stamp0));
+	sysPrxForUser.error("memcpy() latency: %lldus", (stamp1 - stamp0));
-	sysPrxForUser.Error("MMIO latency: %lldus", (stamp2 - stamp1));
+	sysPrxForUser.error("MMIO latency: %lldus", (stamp2 - stamp1));
 
 	return CELL_OK;
 }
 
 s32 _sys_spu_printf_initialize(spu_printf_cb_t agcb, spu_printf_cb_t dgcb, spu_printf_cb_t atcb, spu_printf_cb_t dtcb)
 {
-	sysPrxForUser.Warning("_sys_spu_printf_initialize(agcb=*0x%x, dgcb=*0x%x, atcb=*0x%x, dtcb=*0x%x)", agcb, dgcb, atcb, dtcb);
+	sysPrxForUser.warning("_sys_spu_printf_initialize(agcb=*0x%x, dgcb=*0x%x, atcb=*0x%x, dtcb=*0x%x)", agcb, dgcb, atcb, dtcb);
 
 	// register callbacks
 	g_spu_printf_agcb = agcb;
@@ -113,7 +113,7 @@ s32 _sys_spu_printf_initialize(spu_printf_cb_t agcb, spu_printf_cb_t dgcb, spu_p
 
 s32 _sys_spu_printf_finalize()
 {
-	sysPrxForUser.Warning("_sys_spu_printf_finalize()");
+	sysPrxForUser.warning("_sys_spu_printf_finalize()");
 
 	g_spu_printf_agcb = vm::null;
 	g_spu_printf_dgcb = vm::null;
@@ -125,7 +125,7 @@ s32 _sys_spu_printf_finalize()
 
 s32 _sys_spu_printf_attach_group(PPUThread& ppu, u32 group)
 {
-	sysPrxForUser.Warning("_sys_spu_printf_attach_group(group=0x%x)", group);
+	sysPrxForUser.warning("_sys_spu_printf_attach_group(group=0x%x)", group);
 
 	if (!g_spu_printf_agcb)
 	{
@@ -137,7 +137,7 @@ s32 _sys_spu_printf_attach_group(PPUThread& ppu, u32 group)
 
 s32 _sys_spu_printf_detach_group(PPUThread& ppu, u32 group)
 {
-	sysPrxForUser.Warning("_sys_spu_printf_detach_group(group=0x%x)", group);
+	sysPrxForUser.warning("_sys_spu_printf_detach_group(group=0x%x)", group);
 
 	if (!g_spu_printf_dgcb)
 	{
@@ -149,7 +149,7 @@ s32 _sys_spu_printf_detach_group(PPUThread& ppu, u32 group)
 
 s32 _sys_spu_printf_attach_thread(PPUThread& ppu, u32 thread)
 {
-	sysPrxForUser.Warning("_sys_spu_printf_attach_thread(thread=0x%x)", thread);
+	sysPrxForUser.warning("_sys_spu_printf_attach_thread(thread=0x%x)", thread);
 
 	if (!g_spu_printf_atcb)
 	{
@@ -161,7 +161,7 @@ s32 _sys_spu_printf_attach_thread(PPUThread& ppu, u32 thread)
 
 s32 _sys_spu_printf_detach_thread(PPUThread& ppu, u32 thread)
 {
-	sysPrxForUser.Warning("_sys_spu_printf_detach_thread(thread=0x%x)", thread);
+	sysPrxForUser.warning("_sys_spu_printf_detach_thread(thread=0x%x)", thread);
 
 	if (!g_spu_printf_dtcb)
 	{

rpcs3/Emu/SysCalls/SysCalls.cpp

@@ -36,7 +36,7 @@
 void null_func(PPUThread& ppu)
 {
 	const u64 code = ppu.GPR[11];
-	LOG_ERROR(HLE, "Unimplemented syscall %lld: %s -> CELL_OK", code, get_ps3_function_name(~code));
+	LOG_TODO(HLE, "Unimplemented syscall %lld: %s -> CELL_OK", code, get_ps3_function_name(~code));
 	ppu.GPR[3] = 0;
 }
 
@@ -900,17 +900,11 @@ void execute_syscall_by_index(PPUThread& ppu, u64 code)
 	auto last_code = ppu.hle_code;
 	ppu.hle_code = ~code;
 
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(PPU, "Syscall %lld called: %s", code, get_ps3_function_name(~code));
-	{
-		LOG_NOTICE(PPU, "Syscall %lld called: %s", code, get_ps3_function_name(~code));
-	}
 
 	g_sc_table[code](ppu);
 
-	if (rpcs3::config.misc.log.hle_logging.value())
+	LOG_TRACE(PPU, "Syscall %lld finished: %s -> 0x%llx", code, get_ps3_function_name(~code), ppu.GPR[3]);
-	{
-		LOG_NOTICE(PPU, "Syscall %lld finished: %s -> 0x%llx", code, get_ps3_function_name(~code), ppu.GPR[3]);
-	}
 
 	ppu.hle_code = last_code;
 }

rpcs3/Emu/SysCalls/SysCalls.h

@@ -1,23 +1,13 @@
 #pragma once
 
 #include "ErrorCodes.h"
-#include "LogBase.h"
 
-class SysCallBase : public LogBase
+struct SysCallBase : public _log::channel
 {
-private:
-	std::string m_module_name;
-
-public:
 	SysCallBase(const std::string& name)
-		: m_module_name(name)
+		: _log::channel(name, _log::level::notice)
 	{
 	}
-
-	virtual const std::string& GetName() const override
-	{
-		return m_module_name;
-	}
 };
 
 void execute_syscall_by_index(class PPUThread& ppu, u64 code);

rpcs3/Emu/SysCalls/lv2/sys_cond.cpp

@@ -35,7 +35,7 @@ void lv2_cond_t::notify(lv2_lock_t& lv2_lock, sleep_queue_t::value_type& thread)
 
 s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute_t> attr)
 {
-	sys_cond.Warning("sys_cond_create(cond_id=*0x%x, mutex_id=0x%x, attr=*0x%x)", cond_id, mutex_id, attr);
+	sys_cond.warning("sys_cond_create(cond_id=*0x%x, mutex_id=0x%x, attr=*0x%x)", cond_id, mutex_id, attr);
 
 	LV2_LOCK;
 
@@ -48,7 +48,7 @@ s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribu
 
 	if (attr->pshared != SYS_SYNC_NOT_PROCESS_SHARED || attr->ipc_key || attr->flags)
 	{
-		sys_cond.Error("sys_cond_create(): unknown attributes (pshared=0x%x, ipc_key=0x%llx, flags=0x%x)", attr->pshared, attr->ipc_key, attr->flags);
+		sys_cond.error("sys_cond_create(): unknown attributes (pshared=0x%x, ipc_key=0x%llx, flags=0x%x)", attr->pshared, attr->ipc_key, attr->flags);
 		return CELL_EINVAL;
 	}
 
@@ -64,7 +64,7 @@ s32 sys_cond_create(vm::ptr<u32> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribu
 
 s32 sys_cond_destroy(u32 cond_id)
 {
-	sys_cond.Warning("sys_cond_destroy(cond_id=0x%x)", cond_id);
+	sys_cond.warning("sys_cond_destroy(cond_id=0x%x)", cond_id);
 
 	LV2_LOCK;
 
@@ -92,7 +92,7 @@ s32 sys_cond_destroy(u32 cond_id)
 
 s32 sys_cond_signal(u32 cond_id)
 {
-	sys_cond.Log("sys_cond_signal(cond_id=0x%x)", cond_id);
+	sys_cond.trace("sys_cond_signal(cond_id=0x%x)", cond_id);
 
 	LV2_LOCK;
 
@@ -115,7 +115,7 @@ s32 sys_cond_signal(u32 cond_id)
 
 s32 sys_cond_signal_all(u32 cond_id)
 {
-	sys_cond.Log("sys_cond_signal_all(cond_id=0x%x)", cond_id);
+	sys_cond.trace("sys_cond_signal_all(cond_id=0x%x)", cond_id);
 
 	LV2_LOCK;
 
@@ -139,7 +139,7 @@ s32 sys_cond_signal_all(u32 cond_id)
 
 s32 sys_cond_signal_to(u32 cond_id, u32 thread_id)
 {
-	sys_cond.Log("sys_cond_signal_to(cond_id=0x%x, thread_id=0x%x)", cond_id, thread_id);
+	sys_cond.trace("sys_cond_signal_to(cond_id=0x%x, thread_id=0x%x)", cond_id, thread_id);
 
 	LV2_LOCK;
 
@@ -170,7 +170,7 @@ s32 sys_cond_signal_to(u32 cond_id, u32 thread_id)
 
 s32 sys_cond_wait(PPUThread& ppu, u32 cond_id, u64 timeout)
 {
-	sys_cond.Log("sys_cond_wait(cond_id=0x%x, timeout=%lld)", cond_id, timeout);
+	sys_cond.trace("sys_cond_wait(cond_id=0x%x, timeout=%lld)", cond_id, timeout);
 
 	const u64 start_time = get_system_time();