citra/src/core/hle/kernel/kernel.h

111 lines
3.5 KiB
C++
Raw Normal View History

2014-05-10 04:11:18 +02:00
// Copyright 2014 Citra Emulator Project / PPSSPP Project
2014-12-17 06:38:14 +01:00
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
2014-05-10 04:11:18 +02:00
#pragma once
#include <string>
#include <boost/smart_ptr/intrusive_ptr.hpp>
2015-05-06 09:06:12 +02:00
#include "common/common_types.h"
2018-10-12 21:47:06 +02:00
#include "core/hle/result.h"
2014-05-10 04:11:18 +02:00
namespace Kernel {
class AddressArbiter;
2018-10-11 21:48:16 +02:00
class Event;
2018-10-11 22:00:09 +02:00
class Mutex;
2018-10-12 21:21:32 +02:00
class CodeSet;
2018-10-12 21:33:36 +02:00
class Process;
2018-10-12 21:47:06 +02:00
class Thread;
2018-10-12 22:12:08 +02:00
class Semaphore;
2018-10-12 22:26:23 +02:00
class Timer;
2018-10-13 01:00:16 +02:00
class ClientPort;
class ServerPort;
2018-10-11 21:48:16 +02:00
enum class ResetType {
OneShot,
Sticky,
Pulse,
};
template <typename T>
using SharedPtr = boost::intrusive_ptr<T>;
2018-10-11 20:49:52 +02:00
class KernelSystem {
public:
explicit KernelSystem(u32 system_mode);
~KernelSystem();
/**
* Creates an address arbiter.
*
* @param name Optional name used for debugging.
* @returns The created AddressArbiter.
*/
SharedPtr<AddressArbiter> CreateAddressArbiter(std::string name = "Unknown");
2018-10-11 21:48:16 +02:00
/**
* Creates an event
* @param reset_type ResetType describing how to create event
* @param name Optional name of event
*/
SharedPtr<Event> CreateEvent(ResetType reset_type, std::string name = "Unknown");
2018-10-11 22:00:09 +02:00
/**
* Creates a mutex.
* @param initial_locked Specifies if the mutex should be locked initially
* @param name Optional name of mutex
* @return Pointer to new Mutex object
*/
SharedPtr<Mutex> CreateMutex(bool initial_locked, std::string name = "Unknown");
2018-10-12 21:21:32 +02:00
SharedPtr<CodeSet> CreateCodeSet(std::string name, u64 program_id);
2018-10-12 21:33:36 +02:00
SharedPtr<Process> CreateProcess(SharedPtr<CodeSet> code_set);
2018-10-12 21:47:06 +02:00
/**
* Creates and returns a new thread. The new thread is immediately scheduled
* @param name The friendly name desired for the thread
* @param entry_point The address at which the thread should start execution
* @param priority The thread's priority
* @param arg User data to pass to the thread
* @param processor_id The ID(s) of the processors on which the thread is desired to be run
* @param stack_top The address of the thread's stack top
* @param owner_process The parent process for the thread
* @return A shared pointer to the newly created thread
*/
ResultVal<SharedPtr<Thread>> CreateThread(std::string name, VAddr entry_point, u32 priority,
u32 arg, s32 processor_id, VAddr stack_top,
SharedPtr<Process> owner_process);
2018-10-12 22:12:08 +02:00
/**
* Creates a semaphore.
* @param initial_count Number of slots reserved for other threads
* @param max_count Maximum number of slots the semaphore can have
* @param name Optional name of semaphore
* @return The created semaphore
*/
ResultVal<SharedPtr<Semaphore>> CreateSemaphore(s32 initial_count, s32 max_count,
std::string name = "Unknown");
2018-10-12 22:26:23 +02:00
/**
* Creates a timer
* @param reset_type ResetType describing how to create the timer
* @param name Optional name of timer
* @return The created Timer
*/
SharedPtr<Timer> CreateTimer(ResetType reset_type, std::string name = "Unknown");
2018-10-13 01:00:16 +02:00
/**
* Creates a pair of ServerPort and an associated ClientPort.
*
* @param max_sessions Maximum number of sessions to the port
* @param name Optional name of the ports
* @return The created port tuple
*/
std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(
u32 max_sessions, std::string name = "UnknownPort");
2018-10-11 20:49:52 +02:00
};
} // namespace Kernel