xenia-canary/src/xenia/kernel/xobject.h

358 lines
10 KiB
C++

/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_KERNEL_XOBJECT_H_
#define XENIA_KERNEL_XOBJECT_H_
#include <algorithm>
#include <atomic>
#include <cstddef>
#include <string>
#include "xenia/base/threading.h"
#include "xenia/memory.h"
#include "xenia/xbox.h"
namespace xe {
class ByteStream;
class Emulator;
} // namespace xe
namespace xe {
namespace kernel {
class KernelState;
template <typename T>
class object_ref;
// http://www.nirsoft.net/kernel_struct/vista/DISPATCHER_HEADER.html
typedef struct {
struct {
uint8_t type;
union {
uint8_t abandoned;
uint8_t absolute;
uint8_t npx_irql;
uint8_t signalling;
};
union {
uint8_t size;
uint8_t hand;
};
union {
uint8_t inserted;
uint8_t debug_active;
uint8_t dpc_active;
};
};
xe::be<uint32_t> signal_state;
xe::be<uint32_t> wait_list_flink;
xe::be<uint32_t> wait_list_blink;
} X_DISPATCH_HEADER;
static_assert_size(X_DISPATCH_HEADER, 0x10);
// http://www.nirsoft.net/kernel_struct/vista/OBJECT_HEADER.html
struct X_OBJECT_HEADER {
xe::be<uint32_t> pointer_count;
union {
xe::be<uint32_t> handle_count;
xe::be<uint32_t> next_to_free;
};
uint8_t name_info_offset;
uint8_t handle_info_offset;
uint8_t quota_info_offset;
uint8_t flags;
union {
xe::be<uint32_t> object_create_info; // X_OBJECT_CREATE_INFORMATION
xe::be<uint32_t> quota_block_charged;
};
xe::be<uint32_t> object_type_ptr; // -0x8 POBJECT_TYPE
xe::be<uint32_t> unk_04; // -0x4
// Object lives after this header.
// (There's actually a body field here which is the object itself)
};
// http://www.nirsoft.net/kernel_struct/vista/OBJECT_CREATE_INFORMATION.html
struct X_OBJECT_CREATE_INFORMATION {
xe::be<uint32_t> attributes; // 0x0
xe::be<uint32_t> root_directory_ptr; // 0x4
xe::be<uint32_t> parse_context_ptr; // 0x8
xe::be<uint32_t> probe_mode; // 0xC
xe::be<uint32_t> paged_pool_charge; // 0x10
xe::be<uint32_t> non_paged_pool_charge; // 0x14
xe::be<uint32_t> security_descriptor_charge; // 0x18
xe::be<uint32_t> security_descriptor; // 0x1C
xe::be<uint32_t> security_qos_ptr; // 0x20
// Security QoS here (SECURITY_QUALITY_OF_SERVICE) too!
};
struct X_OBJECT_TYPE {
xe::be<uint32_t> constructor; // 0x0
xe::be<uint32_t> destructor; // 0x4
xe::be<uint32_t> unk_08; // 0x8
xe::be<uint32_t> unk_0C; // 0xC
xe::be<uint32_t> unk_10; // 0x10
xe::be<uint32_t> unk_14; // 0x14 probably offset from ntobject to keobject
xe::be<uint32_t> pool_tag; // 0x18
};
class XObject {
public:
enum Type {
kTypeUndefined,
kTypeEnumerator,
kTypeEvent,
kTypeFile,
kTypeIOCompletion,
kTypeModule,
kTypeMutant,
kTypeNotifyListener,
kTypeSemaphore,
kTypeSession,
kTypeSocket,
kTypeThread,
kTypeTimer,
};
XObject(Type type);
XObject(KernelState* kernel_state, Type type);
virtual ~XObject();
Emulator* emulator() const;
KernelState* kernel_state() const;
Memory* memory() const;
Type type();
// Returns the primary handle of this object.
X_HANDLE handle() const { return handles_[0]; }
// Returns all associated handles with this object.
std::vector<X_HANDLE> handles() const { return handles_; }
std::vector<X_HANDLE>& handles() { return handles_; }
const std::string& name() const { return name_; }
uint32_t guest_object() const { return guest_object_ptr_; }
// Has this object been created for use by the host?
// Host objects are persisted through reloads/etc.
bool is_host_object() const { return host_object_; }
void set_host_object(bool host_object) { host_object_ = host_object; }
template <typename T>
T* guest_object() {
return memory()->TranslateVirtual<T*>(guest_object_ptr_);
}
void RetainHandle();
bool ReleaseHandle();
void Retain();
void Release();
X_STATUS Delete();
virtual bool Save(ByteStream* stream) { return false; }
static object_ref<XObject> Restore(KernelState* kernel_state, Type type,
ByteStream* stream);
// Reference()
// Dereference()
void SetAttributes(uint32_t obj_attributes_ptr);
X_STATUS Wait(uint32_t wait_reason, uint32_t processor_mode,
uint32_t alertable, uint64_t* opt_timeout);
static X_STATUS SignalAndWait(XObject* signal_object, XObject* wait_object,
uint32_t wait_reason, uint32_t processor_mode,
uint32_t alertable, uint64_t* opt_timeout);
static X_STATUS WaitMultiple(uint32_t count, XObject** objects,
uint32_t wait_type, uint32_t wait_reason,
uint32_t processor_mode, uint32_t alertable,
uint64_t* opt_timeout);
static object_ref<XObject> GetNativeObject(KernelState* kernel_state,
void* native_ptr,
int32_t as_type = -1);
template <typename T>
static object_ref<T> GetNativeObject(KernelState* kernel_state,
void* native_ptr, int32_t as_type = -1);
protected:
bool SaveObject(ByteStream* stream);
bool RestoreObject(ByteStream* stream);
// Called on successful wait.
virtual void WaitCallback() {}
virtual xe::threading::WaitHandle* GetWaitHandle() { return nullptr; }
// Creates the kernel object for guest code to use. Typically not needed.
uint8_t* CreateNative(uint32_t size);
void SetNativePointer(uint32_t native_ptr, bool uninitialized = false);
template <typename T>
T* CreateNative() {
return reinterpret_cast<T*>(CreateNative(sizeof(T)));
}
// Stash native pointer into X_DISPATCH_HEADER
static void StashHandle(X_DISPATCH_HEADER* header, uint32_t handle) {
header->wait_list_flink = 'XEN\0';
header->wait_list_blink = handle;
}
static uint32_t TimeoutTicksToMs(int64_t timeout_ticks);
KernelState* kernel_state_;
// Host objects are persisted through resets/etc.
bool host_object_ = false;
private:
std::atomic<int32_t> pointer_ref_count_;
Type type_;
std::vector<X_HANDLE> handles_;
std::string name_; // May be zero length.
// Guest pointer for kernel object. Remember: X_OBJECT_HEADER precedes this
// if we allocated it!
uint32_t guest_object_ptr_ = 0;
bool allocated_guest_object_ = false;
};
template <typename T>
class object_ref {
public:
object_ref() noexcept : value_(nullptr) {}
object_ref(std::nullptr_t) noexcept // NOLINT(runtime/explicit)
: value_(nullptr) {}
object_ref& operator=(std::nullptr_t) noexcept {
reset();
return (*this);
}
explicit object_ref(T* value) noexcept : value_(value) {
// Assumes retained on call.
}
explicit object_ref(const object_ref& right) noexcept {
reset(right.get());
if (value_) value_->Retain();
}
template <class V, class = typename std::enable_if<
std::is_convertible<V*, T*>::value, void>::type>
object_ref(const object_ref<V>& right) noexcept {
reset(right.get());
if (value_) value_->Retain();
}
object_ref(object_ref&& right) noexcept : value_(right.release()) {}
object_ref& operator=(object_ref&& right) noexcept {
object_ref(std::move(right)).swap(*this);
return (*this);
}
template <typename V>
object_ref& operator=(object_ref<V>&& right) noexcept {
object_ref(std::move(right)).swap(*this);
return (*this);
}
object_ref& operator=(const object_ref& right) noexcept {
object_ref(right).swap(*this); // NOLINT(runtime/explicit): misrecognized?
return (*this);
}
template <typename V>
object_ref& operator=(const object_ref<V>& right) noexcept {
object_ref(right).swap(*this); // NOLINT(runtime/explicit): misrecognized?
return (*this);
}
void swap(object_ref& right) noexcept { std::swap(value_, right.value_); }
~object_ref() noexcept {
if (value_) {
value_->Release();
value_ = nullptr;
}
}
typename std::add_lvalue_reference<T>::type operator*() const {
return (*get());
}
T* operator->() const noexcept {
return std::pointer_traits<T*>::pointer_to(**this);
}
T* get() const noexcept { return value_; }
template <typename V>
V* get() const noexcept {
return reinterpret_cast<V*>(value_);
}
explicit operator bool() const noexcept { return value_ != nullptr; }
T* release() noexcept {
T* value = value_;
value_ = nullptr;
return value;
}
void reset() noexcept { object_ref().swap(*this); }
void reset(T* value) noexcept { object_ref(value).swap(*this); }
inline bool operator==(const T* right) noexcept { return value_ == right; }
private:
T* value_ = nullptr;
};
template <class _Ty>
bool operator==(const object_ref<_Ty>& _Left, std::nullptr_t) noexcept {
return (_Left.get() == reinterpret_cast<_Ty*>(0));
}
template <class _Ty>
bool operator==(std::nullptr_t, const object_ref<_Ty>& _Right) noexcept {
return (reinterpret_cast<_Ty*>(0) == _Right.get());
}
template <class _Ty>
bool operator!=(const object_ref<_Ty>& _Left, std::nullptr_t _Right) noexcept {
return (!(_Left == _Right));
}
template <class _Ty>
bool operator!=(std::nullptr_t _Left, const object_ref<_Ty>& _Right) noexcept {
return (!(_Left == _Right));
}
template <typename T>
object_ref<T> retain_object(T* ptr) {
if (ptr) ptr->Retain();
return object_ref<T>(ptr);
}
template <typename T>
object_ref<T> XObject::GetNativeObject(KernelState* kernel_state,
void* native_ptr, int32_t as_type) {
return object_ref<T>(reinterpret_cast<T*>(
GetNativeObject(kernel_state, native_ptr, as_type).release()));
}
} // namespace kernel
} // namespace xe
#endif // XENIA_KERNEL_XOBJECT_H_