dymok93 / ktl Goto Github PK

Kernel Template Library: STL-style containers and tools for Windows kernel space programming

License: MIT License

C++ 97.59% CMake 1.34% Assembly 1.07%

ktl's Introduction

KTL

Kernel Template Library is open-source library providing CRT environment, STL-style containers and RAII tools for Windows Kernel programming.

Status
Features
Installation & Usage
- CMakeLists.txt to build with a pre-built KTL
- Build requirements
Examples
Roadmap for the near future

Status

License	Lines of Code

Features

C Runtime environment
- Exception handling mechanism (now for x64 only)
- Buffer security checks
- C++ Standard compatible termination if execution is run out of control
- Construction and destruction of the non-trivial static objects
- Memory allocation using new and delete
- Filesystem Mini-Filter support routines
C++ Standard Library implementation
- <atomic> (now for x86 and x64 only)
- Optimized, C++ Standard compatible <algorithm> library
- <allocator> with standard allocators for different pool types
- Boost-based implementation of the compressed_pair
- Exceptions objects hierarchy (std::exception analog optimized for use in the kernel)
- Iterators
- MSVC-intrinsic-based coroutines
- Mutexes, events and condition variables based on kernel synchronization primitives with RAII wrappers
- Smart pointers (unique_ptr, shared_ptr and weak_ptr, intrusive_ptr)
- <type_traits>
- <thread> for managing driver-dedicated threads
- <tuple>
- <optional> with constexpr support
- unordered_node_map, unordered_node_set, unordered_flat_map and unordered_flat_set using robin-hood-hashing
- <vector>
- Lock-free queue, node_allocator and some auxiliary algorithms
- fmt as a string formatting library
- Designed in C++17, feel free to build with C++20
CMake
- Building of kernel drivers
- Generating a test-signing certificate
- Driver signing

Complete documentation in progress.

Installation & Usage

You can use KTL directly as driver CMake project subdirectory or link with pre-built KTL binaries applying find_package().

It includes 3 static libraries:

basic_runtime.lib (CRT)
cpp_runtime.lib (C++ tools)
minifilter_runtime.lib (optional Filesystem Mini-Filter support)

CMakeLists.txt to build with a pre-built KTL:

    project(MyDriver CXX)

    find_package(WDK REQUIRED)  # Windows Driver Kit
    find_package(KTL REQUIRED)

    wdk_add_driver(
      ${DRIVER_NAME} minifilter.cpp
        CUSTOM_ENTRY_POINT KtlDriverEntry   # Required for C and C++ Runtime initialization and destruction
		    EXTENDED_CPP_FEATURES               # Exceptions handling enabled
    )
    target_include_directories(
	    ${DRIVER_NAME} PUBLIC
		    ${KTL_INCLUDE_DIR}
		    ${KTL_MODULES_DIR}                  # Lock-Free tools
		    ${KTL_RUNTIME_INCLUDE_DIR}
		    ${CMAKE_INCLUDE_CURRENT_DIR}
    )
    target_link_libraries(
      ${DRIVER_NAME} PRIVATE
        ktl::basic_runtime
        ktl::minifilter_runtime
        ktl::cpp_runtime
    )
    wdk_sign_driver(        # Driver signing (in this example - using given certificate)
	    ${DRIVER_NAME}
		    ${YOUR_CERTIFICATE_NAME}
		    CERTIFICATE_PATH ${YOUR_CERTIFICATE_PATH}
		    TIMESTAMP_SERVER ${YOUR_TIMESTAMP_SERVER} # Default is timestamp.verisign.com
    )

Build requirements:

WDK10
Visual Studio 2019 (not tested on older versions)
CMake 3.0 and higher
FindWDK (used as a Git submodule)

Examples

CoroDriverSample - a simple driver demonstrating the use of C++20 coroutines in kernel mode

Roadmap for the near future

Linked lists and Red-Black-Tree containers
Intrusive containers
Coroutine-compatible async primitives
Exception handling on the x86 platforms

ktl's People

Contributors

Stargazers

Watchers

ktl's Issues

Invalid integral comparison of the memcmp result

https://github.com/DymOK93/KTL/blob/master/include/algorithm.hpp#L372
memcmp() may return any negative or positive values, not only -1 or 1

Implement ktl::variant - analog of std::variant

Including <new_delete.h> into <memory.hpp>

It is required to explicitly include <new_delete.h> into <memory.hpp>

ktl::hash specialization for intrusive_ptr

Use allocator_type::construct() instead of construct_at() in the vector

Runtime library cannot be built for x86

https://github.com/DymOK93/KTL/blob/master/runtime/src/object_management.cpp#L19
__cxx_ctors_begin__ and __cxx_ctors_end__ are x64-specific: https://github.com/DymOK93/KTL/blob/master/runtime/include/crt_runtime.h#L12, https://github.com/DymOK93/KTL/blob/master/runtime/include/crt_runtime.h#L25

There is no basic_winnt_string::starts_with(basic_winnt_string_view)

EOF constexpr variable conflicts with EOF macro

vector::erase(it) shouldn't check it for equality to end()

There may be used assert: https://github.com/DymOK93/KTL/blob/master/include/vector.hpp#L360

It's impossible call emplace() on a ktl::vector of the non-copyable objects due to typos in the ktl::move_if_noexcept

https://github.com/DymOK93/KTL/blob/master/runtime/include/utility_impl.hpp#L27 and https://github.com/DymOK93/KTL/blob/master/runtime/include/utility_impl.hpp#28 was messed up

Thread support library

Managing threads in the kernel in C++ way

Incorrect subtraction in string::find()

https://github.com/DymOK93/KTL/blob/feature_vector/include/string.hpp#L970
If symbol not found traits_type::find() returns nullptr (not a position behind size())

Bug in ktl::basic_winnt_string

As a result, operator = (const wchar_t *) and moving from the string may end up in an inconsistent state: capacity ()> SSO_CH_BUFFER_COUNT (i.e. !is_small()), but m_str.get_first (). Buffer == m_buffer

ktl::opt::details::non_trivial_optional_base<Ty>::~non_trivial_optional_base' cannot be declared with 'constexpr' specifier

Invalid type of the local variable

https://github.com/DymOK93/KTL/blob/master/include/string_algorithm_impl.hpp#L47
There must be pointer of type CharT

Time support library

std::chrono analog with providing access to the kernel clocks

The project urgently needs a good README and documentation

When using FMT_COMPILE for unicode strings, the resulting string is empty

BSOD in __GSHandlerCheck()

__GSHandlerCheck, contrary to the documentation, is added by the compiler to the table of exception handlers and is called even with "/ EHsc". It expects as a parameter a pointer to an object of the _DISPATCHER_CONTEXT structure, the contents of which are different from ktl::crt::exc_engine::dispatcher_constext, which leads to BSOD

Implement ktl::invoke and ktl::invokable_* traits

Add data() function template

Introduce string formatting library

Let's try porting fmtlib into Kernel!

Incorrect name of iterator type

https://github.com/DymOK93/KTL/blob/feature_vector/include/string.hpp#L1060
https://github.com/DymOK93/KTL/blob/feature_vector/include/string.hpp#L1067
RandomAcceccIt instead of the RandomAccessIt

Introduce Red-Black-Tree based containers (map and set)

Invalid call of the internal routine in the basic_winnt_string::pop_back()

https://github.com/DymOK93/KTL/blob/feature_vector/include/string.hpp#L497
basic_winnt_string::pop_back() calls decrease_size() that doesn't take 3 arguments (second argument of this call is duplicate of the first)

Implement ktl::function - analog of std::function

Provide a common way to use kernel thread pools and task queues

Different types of WorkItems
DPC
User-defined pools

Hmm... How about executors?