2015-05-03 20:01:16 -07:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <bitset>
|
2015-06-21 07:44:11 -07:00
|
|
|
#include <cstddef>
|
2015-07-12 14:10:37 -07:00
|
|
|
#include <memory>
|
2015-06-21 07:44:11 -07:00
|
|
|
#include <string>
|
2018-01-01 11:38:34 -08:00
|
|
|
#include <vector>
|
2015-05-03 20:01:16 -07:00
|
|
|
#include <boost/container/static_vector.hpp>
|
2015-05-08 13:53:19 -07:00
|
|
|
#include "common/bit_field.h"
|
|
|
|
#include "common/common_types.h"
|
2018-08-01 19:40:00 -07:00
|
|
|
#include "core/hle/kernel/object.h"
|
2018-01-09 21:58:25 -08:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2015-07-17 19:19:16 -07:00
|
|
|
#include "core/hle/kernel/vm_manager.h"
|
2015-05-03 20:01:16 -07:00
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2015-05-08 14:12:25 -07:00
|
|
|
struct AddressMapping {
|
2015-05-08 12:51:48 -07:00
|
|
|
// Address and size must be page-aligned
|
2015-05-03 20:01:16 -07:00
|
|
|
VAddr address;
|
2017-12-29 10:27:58 -08:00
|
|
|
u64 size;
|
2017-05-05 23:11:06 -07:00
|
|
|
bool read_only;
|
2015-05-08 12:51:48 -07:00
|
|
|
bool unk_flag;
|
2015-05-03 20:01:16 -07:00
|
|
|
};
|
|
|
|
|
2015-05-08 13:53:19 -07:00
|
|
|
enum class MemoryRegion : u16 {
|
2015-05-03 20:01:16 -07:00
|
|
|
APPLICATION = 1,
|
|
|
|
SYSTEM = 2,
|
|
|
|
BASE = 3,
|
|
|
|
};
|
|
|
|
|
2015-05-08 13:53:19 -07:00
|
|
|
union ProcessFlags {
|
|
|
|
u16 raw;
|
|
|
|
|
2016-09-17 17:38:01 -07:00
|
|
|
BitField<0, 1, u16>
|
|
|
|
allow_debug; ///< Allows other processes to attach to and debug this process.
|
|
|
|
BitField<1, 1, u16> force_debug; ///< Allows this process to attach to processes even if they
|
|
|
|
/// don't have allow_debug set.
|
|
|
|
BitField<2, 1, u16> allow_nonalphanum;
|
|
|
|
BitField<3, 1, u16> shared_page_writable; ///< Shared page is mapped with write permissions.
|
|
|
|
BitField<4, 1, u16> privileged_priority; ///< Can use priority levels higher than 24.
|
|
|
|
BitField<5, 1, u16> allow_main_args;
|
|
|
|
BitField<6, 1, u16> shared_device_mem;
|
|
|
|
BitField<7, 1, u16> runnable_on_sleep;
|
|
|
|
BitField<8, 4, MemoryRegion>
|
|
|
|
memory_region; ///< Default region for memory allocations for this process
|
2015-05-08 13:53:19 -07:00
|
|
|
BitField<12, 1, u16> loaded_high; ///< Application loaded high (not at 0x00100000).
|
|
|
|
};
|
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
enum class ProcessStatus { Created, Running, Exited };
|
|
|
|
|
2015-05-12 13:25:15 -07:00
|
|
|
class ResourceLimit;
|
2015-07-09 18:52:15 -07:00
|
|
|
|
|
|
|
struct CodeSet final : public Object {
|
2018-08-03 11:33:59 -07:00
|
|
|
struct Segment {
|
|
|
|
size_t offset = 0;
|
|
|
|
VAddr addr = 0;
|
|
|
|
u32 size = 0;
|
|
|
|
};
|
|
|
|
|
2018-02-27 07:22:15 -08:00
|
|
|
static SharedPtr<CodeSet> Create(std::string name);
|
2015-07-09 18:52:15 -07:00
|
|
|
|
2016-09-17 17:38:01 -07:00
|
|
|
std::string GetTypeName() const override {
|
|
|
|
return "CodeSet";
|
|
|
|
}
|
|
|
|
std::string GetName() const override {
|
|
|
|
return name;
|
|
|
|
}
|
2015-07-09 18:52:15 -07:00
|
|
|
|
|
|
|
static const HandleType HANDLE_TYPE = HandleType::CodeSet;
|
2016-09-17 17:38:01 -07:00
|
|
|
HandleType GetHandleType() const override {
|
|
|
|
return HANDLE_TYPE;
|
|
|
|
}
|
2015-07-09 18:52:15 -07:00
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
Segment& CodeSegment() {
|
|
|
|
return segments[0];
|
|
|
|
}
|
2015-07-09 18:52:15 -07:00
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
const Segment& CodeSegment() const {
|
|
|
|
return segments[0];
|
|
|
|
}
|
2015-07-09 18:52:15 -07:00
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
Segment& RODataSegment() {
|
|
|
|
return segments[1];
|
|
|
|
}
|
2015-07-09 18:52:15 -07:00
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
const Segment& RODataSegment() const {
|
|
|
|
return segments[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
Segment& DataSegment() {
|
|
|
|
return segments[2];
|
|
|
|
}
|
|
|
|
|
|
|
|
const Segment& DataSegment() const {
|
|
|
|
return segments[2];
|
|
|
|
}
|
|
|
|
|
|
|
|
std::shared_ptr<std::vector<u8>> memory;
|
2017-09-24 08:12:16 -07:00
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
Segment segments[3];
|
2015-07-09 18:52:15 -07:00
|
|
|
VAddr entrypoint;
|
|
|
|
|
2018-08-03 11:33:59 -07:00
|
|
|
/// Name of the process
|
|
|
|
std::string name;
|
|
|
|
|
2015-07-09 18:52:15 -07:00
|
|
|
private:
|
|
|
|
CodeSet();
|
|
|
|
~CodeSet() override;
|
|
|
|
};
|
2015-05-12 13:25:15 -07:00
|
|
|
|
2015-05-03 20:01:16 -07:00
|
|
|
class Process final : public Object {
|
|
|
|
public:
|
2018-03-13 14:49:59 -07:00
|
|
|
static SharedPtr<Process> Create(std::string&& name);
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2016-09-17 17:38:01 -07:00
|
|
|
std::string GetTypeName() const override {
|
|
|
|
return "Process";
|
|
|
|
}
|
|
|
|
std::string GetName() const override {
|
2017-09-30 11:15:09 -07:00
|
|
|
return name;
|
2016-09-17 17:38:01 -07:00
|
|
|
}
|
2015-05-03 20:01:16 -07:00
|
|
|
|
|
|
|
static const HandleType HANDLE_TYPE = HandleType::Process;
|
2016-09-17 17:38:01 -07:00
|
|
|
HandleType GetHandleType() const override {
|
|
|
|
return HANDLE_TYPE;
|
|
|
|
}
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2015-05-11 07:15:10 -07:00
|
|
|
static u32 next_process_id;
|
|
|
|
|
2018-02-27 07:22:15 -08:00
|
|
|
/// Title ID corresponding to the process
|
|
|
|
u64 program_id;
|
|
|
|
|
2015-05-12 13:25:15 -07:00
|
|
|
/// Resource limit descriptor for this process
|
|
|
|
SharedPtr<ResourceLimit> resource_limit;
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2015-05-08 14:11:06 -07:00
|
|
|
/// The process may only call SVCs which have the corresponding bit set.
|
2015-05-03 20:01:16 -07:00
|
|
|
std::bitset<0x80> svc_access_mask;
|
2015-05-08 14:11:06 -07:00
|
|
|
/// Maximum size of the handle table for the process.
|
2015-05-03 20:01:16 -07:00
|
|
|
unsigned int handle_table_size = 0x200;
|
2015-05-08 14:11:06 -07:00
|
|
|
/// Special memory ranges mapped into this processes address space. This is used to give
|
|
|
|
/// processes access to specific I/O regions and device memory.
|
2015-05-08 14:12:25 -07:00
|
|
|
boost::container::static_vector<AddressMapping, 8> address_mappings;
|
2015-05-08 13:53:19 -07:00
|
|
|
ProcessFlags flags;
|
2015-07-19 11:18:57 -07:00
|
|
|
/// Kernel compatibility version for this process
|
|
|
|
u16 kernel_version = 0;
|
2016-04-17 12:01:40 -07:00
|
|
|
/// The default CPU for this process, threads are scheduled on this cpu by default.
|
|
|
|
u8 ideal_processor = 0;
|
2018-01-09 21:58:25 -08:00
|
|
|
/// Bitmask of allowed CPUs that this process' threads can run on. TODO(Subv): Actually parse
|
|
|
|
/// this value from the process header.
|
|
|
|
u32 allowed_processor_mask = THREADPROCESSORID_DEFAULT_MASK;
|
2018-01-16 14:06:45 -08:00
|
|
|
u32 allowed_thread_priority_mask = 0xFFFFFFFF;
|
|
|
|
u32 is_virtual_address_memory_enabled = 0;
|
2018-01-01 11:38:34 -08:00
|
|
|
/// Current status of the process
|
|
|
|
ProcessStatus status;
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2015-05-11 07:15:10 -07:00
|
|
|
/// The id of this process
|
|
|
|
u32 process_id = next_process_id++;
|
|
|
|
|
2015-05-08 14:11:06 -07:00
|
|
|
/**
|
|
|
|
* Parses a list of kernel capability descriptors (as found in the ExHeader) and applies them
|
|
|
|
* to this process.
|
|
|
|
*/
|
2015-05-03 20:01:16 -07:00
|
|
|
void ParseKernelCaps(const u32* kernel_caps, size_t len);
|
2015-05-08 14:11:06 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Applies address space changes and launches the process main thread.
|
|
|
|
*/
|
2017-09-30 11:15:09 -07:00
|
|
|
void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size);
|
2015-05-03 20:01:16 -07:00
|
|
|
|
2017-09-24 08:12:16 -07:00
|
|
|
void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
|
|
|
|
|
2015-07-17 19:19:16 -07:00
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Memory Management
|
|
|
|
|
|
|
|
VMManager vm_manager;
|
|
|
|
|
|
|
|
// Memory used to back the allocations in the regular heap. A single vector is used to cover
|
|
|
|
// the entire virtual address space extents that bound the allocations, including any holes.
|
|
|
|
// This makes deallocation and reallocation of holes fast and keeps process memory contiguous
|
|
|
|
// in the emulator address space, allowing Memory::GetPointer to be reasonably safe.
|
|
|
|
std::shared_ptr<std::vector<u8>> heap_memory;
|
2015-08-05 17:39:53 -07:00
|
|
|
|
2018-08-02 20:37:44 -07:00
|
|
|
// The left/right bounds of the address space covered by heap_memory.
|
|
|
|
VAddr heap_start = 0;
|
|
|
|
VAddr heap_end = 0;
|
|
|
|
u64 heap_used = 0;
|
2015-07-17 19:19:16 -07:00
|
|
|
|
2016-04-19 15:12:48 -07:00
|
|
|
/// The Thread Local Storage area is allocated as processes create threads,
|
|
|
|
/// each TLS area is 0x200 bytes, so one page (0x1000) is split up in 8 parts, and each part
|
2016-09-17 17:38:01 -07:00
|
|
|
/// holds the TLS for a specific thread. This vector contains which parts are in use for each
|
|
|
|
/// page as a bitmask.
|
2016-04-19 15:12:48 -07:00
|
|
|
/// This vector will grow as more pages are allocated for new threads.
|
|
|
|
std::vector<std::bitset<8>> tls_slots;
|
2015-07-17 19:19:16 -07:00
|
|
|
|
2017-09-30 11:15:09 -07:00
|
|
|
std::string name;
|
|
|
|
|
2017-12-29 10:27:58 -08:00
|
|
|
ResultVal<VAddr> HeapAllocate(VAddr target, u64 size, VMAPermission perms);
|
2015-07-17 19:19:16 -07:00
|
|
|
ResultCode HeapFree(VAddr target, u32 size);
|
|
|
|
|
2017-12-28 18:35:49 -08:00
|
|
|
ResultCode MirrorMemory(VAddr dst_addr, VAddr src_addr, u64 size);
|
|
|
|
|
2017-12-31 12:22:49 -08:00
|
|
|
ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, u64 size);
|
|
|
|
|
2015-05-03 20:01:16 -07:00
|
|
|
private:
|
|
|
|
Process();
|
|
|
|
~Process() override;
|
|
|
|
};
|
|
|
|
|
2018-01-01 11:38:34 -08:00
|
|
|
void ClearProcessList();
|
|
|
|
|
|
|
|
/// Retrieves a process from the current list of processes.
|
|
|
|
SharedPtr<Process> GetProcessById(u32 process_id);
|
|
|
|
|
|
|
|
} // namespace Kernel
|