From 721a669bfb374927292b488b8988e45fdde9190f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Filip=20M=C3=ADka?= <mikafil@zcu.cz>
Date: Sun, 19 Apr 2020 23:55:29 +0200
Subject: [PATCH] Prace na procesu - proces ma vetsinu inicializacnih hodnot
implementovanych jako konstanty
---
msvc/kernel/kernel.vcxproj.filters | 12 +++
src/kernel/NTFS/ntfs_boot.cpp | 2 +-
src/kernel/NTFS/ntfs_io.cpp | 2 +-
src/kernel/disk.cpp | 60 ++++++-----
src/kernel/disk.h | 3 +-
src/kernel/file_system.cpp | 4 +-
src/kernel/file_system.h | 35 ++++---
src/kernel/handle.cpp | 6 +-
src/kernel/handle.h | 21 ++--
src/kernel/kernel.cpp | 60 +++++++----
src/kernel/kernel.h | 14 ++-
src/kernel/process.cpp | 161 ++++++++++++++++++++++++-----
src/kernel/process.h | 134 ++++++++++++++++--------
test/kernel/disk_test.cpp | 3 +-
test/kernel/file_sytem_test.cpp | 13 ++-
test/kernel/process_test.cpp | 8 +-
16 files changed, 377 insertions(+), 161 deletions(-)
diff --git a/msvc/kernel/kernel.vcxproj.filters b/msvc/kernel/kernel.vcxproj.filters
index 01df105..42da386 100644
--- a/msvc/kernel/kernel.vcxproj.filters
+++ b/msvc/kernel/kernel.vcxproj.filters
@@ -81,6 +81,12 @@
<ClInclude Include="..\..\src\kernel\NTFS\ntfs_io.h">
<Filter>Hlavičkové soubory</Filter>
</ClInclude>
+ <ClInclude Include="..\..\src\kernel\handle_item.h">
+ <Filter>Hlavičkové soubory</Filter>
+ </ClInclude>
+ <ClInclude Include="..\..\src\kernel\executor.h">
+ <Filter>Hlavičkové soubory</Filter>
+ </ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\src\kernel\kernel.cpp">
@@ -140,5 +146,11 @@
<ClCompile Include="..\..\src\kernel\NTFS\ntfs_io.cpp">
<Filter>Zdrojové soubory</Filter>
</ClCompile>
+ <ClCompile Include="..\..\src\kernel\handle_item.cpp">
+ <Filter>Zdrojové soubory</Filter>
+ </ClCompile>
+ <ClCompile Include="..\..\src\kernel\executor.cpp">
+ <Filter>Zdrojové soubory</Filter>
+ </ClCompile>
</ItemGroup>
</Project>
\ No newline at end of file
diff --git a/src/kernel/NTFS/ntfs_boot.cpp b/src/kernel/NTFS/ntfs_boot.cpp
index 98aa3c5..93fc63a 100644
--- a/src/kernel/NTFS/ntfs_boot.cpp
+++ b/src/kernel/NTFS/ntfs_boot.cpp
@@ -232,7 +232,7 @@ uint64_t NtfsBoot::write(char* buff, uint32_t len, uint64_t pos, uint32_t c_size
addr.lba_index = pos / c_size;
- kiv_hal::TRegisters regs = RegUtil::empty();
+ kiv_hal::TRegisters regs = mikafil::RegUtil::empty();
regs.rax.h = static_cast<uint8_t>(kiv_hal::NDisk_IO::Write_Sectors);
regs.rax.l = 0;
regs.rdi.r = (uint64_t)(&addr);
diff --git a/src/kernel/NTFS/ntfs_io.cpp b/src/kernel/NTFS/ntfs_io.cpp
index d87ac90..2d3c5b3 100644
--- a/src/kernel/NTFS/ntfs_io.cpp
+++ b/src/kernel/NTFS/ntfs_io.cpp
@@ -2,7 +2,7 @@
#include <iostream>
-NtfsIO::NtfsIO(std::shared_ptr<NtfsDisk> ptr_boot) :
+NtfsIO::NtfsIO(std::shared_ptr<NtfsBoot> ptr_boot) :
boot(ptr_boot)
{
diff --git a/src/kernel/disk.cpp b/src/kernel/disk.cpp
index c6e170e..7102a03 100644
--- a/src/kernel/disk.cpp
+++ b/src/kernel/disk.cpp
@@ -1,90 +1,94 @@
#include "../kernel/disk.h"
#include "../kernel/file.h"
-Disk::Disk(char p_name, uint8_t p_id, kiv_hal::TDrive_Parameters p_prms) : name(p_name), id(p_id), prms(p_prms) {
+mikafil::Disk::Disk(char p_name, uint8_t p_id, kiv_hal::TDrive_Parameters p_prms, uint8_t p_kernel_id) :
+ name(p_name),
+ id(p_id),
+ prms(p_prms),
+ kernel_id(p_kernel_id){
}
-std::shared_ptr<File> Disk::get(Path pth)
+std::shared_ptr<mikafil::File> mikafil::Disk::get(Path pth)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::open(uint32_t fid, int* error)
+std::shared_ptr< mikafil::File> mikafil::Disk::open(uint32_t fid, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::getChild(std::shared_ptr<File> fil, const char* name, int* error)
+std::shared_ptr<mikafil::File>mikafil::Disk::getChild(std::shared_ptr<mikafil::File> fil, const char* name, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::getChild(uint32_t fid, const char* name, int* error)
+std::shared_ptr<mikafil::File> mikafil::Disk::getChild(uint32_t fid, const char* name, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-uint32_t Disk::countChildren(std::shared_ptr<File> fil, int* error)
+uint32_t mikafil::Disk::countChildren(std::shared_ptr<mikafil::File> fil, int* error)
{
return uint32_t();
}
-uint32_t Disk::countChildren(uint32_t fid, int* error)
+uint32_t mikafil::Disk::countChildren(uint32_t fid, int* error)
{
return uint32_t();
}
-bool Disk::deleteFile(uint32_t fid, int* error)
+bool mikafil::Disk::deleteFile(uint32_t fid, int* error)
{
return false;
}
-uint32_t Disk::geChildFileId(uint32_t fid, char* name)
+uint32_t mikafil::Disk::geChildFileId(uint32_t fid, char* name)
{
return uint32_t();
}
-std::shared_ptr<File> Disk::getParent(uint32_t fileId, int* error)
+std::shared_ptr<mikafil::File> mikafil::Disk::getParent(uint32_t fileId, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::getParent(std::shared_ptr<File> fil, int* error)
+std::shared_ptr<mikafil::File> mikafil::Disk::getParent(std::shared_ptr<mikafil::File> fil, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::root()
+std::shared_ptr<mikafil::File> mikafil::Disk::root()
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::make_dir(std::shared_ptr<File> current, const char* name, uint8_t attr, int* error)
+std::shared_ptr<mikafil::File>mikafil::Disk::make_dir(std::shared_ptr<mikafil::File> current, const char* name, uint8_t attr, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-bool Disk::erase(std::shared_ptr<File> file, int* error)
+bool mikafil::Disk::erase(std::shared_ptr<mikafil::File> file, int* error)
{
return false;
}
-bool Disk::erase(uint32_t file_id, int* error)
+bool mikafil::Disk::erase(uint32_t file_id, int* error)
{
return false;
}
-std::shared_ptr<File> Disk::createFile(std::shared_ptr<File> current, const char* name, uint8_t attr, int* error)
+std::shared_ptr<mikafil::File> mikafil::Disk::createFile(std::shared_ptr<mikafil::File> current, const char* name, uint8_t attr, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<File> Disk::createFile(std::shared_ptr<File> current, const char* name, uint8_t attr, uint8_t flags, int* error)
+std::shared_ptr<mikafil::File> mikafil::Disk::createFile(std::shared_ptr<mikafil::File> current, const char* name, uint8_t attr, uint8_t flags, int* error)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-int Disk::path_to_stream(std::ostringstream& stream, uint32_t fid)
+int mikafil::Disk::path_to_stream(std::ostringstream& stream, uint32_t fid)
{
return 0;
}
diff --git a/src/kernel/disk.h b/src/kernel/disk.h
index ef714b8..cb8d0a6 100644
--- a/src/kernel/disk.h
+++ b/src/kernel/disk.h
@@ -31,6 +31,7 @@ namespace mikafil {
public:
const char name;
const uint8_t id;
+ const uint8_t kernel_id;
const kiv_hal::TDrive_Parameters prms;
#ifdef KERNEL_TEST
@@ -38,7 +39,7 @@ namespace mikafil {
#else
public:
#endif
- Disk(char p_name, uint8_t p_id, kiv_hal::TDrive_Parameters p_prms);
+ Disk(char p_name, uint8_t p_id, kiv_hal::TDrive_Parameters p_prms, uint8_t p_kernel_id);
diff --git a/src/kernel/file_system.cpp b/src/kernel/file_system.cpp
index 2742ff6..2e70767 100644
--- a/src/kernel/file_system.cpp
+++ b/src/kernel/file_system.cpp
@@ -7,8 +7,8 @@ mikafil::FileSystem::FileSystem() {
last_name_idx = 0;
}
-char mikafil::FileSystem::add_disk(kiv_hal::TDrive_Parameters prms) {
- std::shared_ptr<mikafil::Disk> p_disk = std::make_shared<mikafil::Disk>(disk_names[last_name_idx], last_name_idx, prms);
+char mikafil::FileSystem::add_disk(kiv_hal::TDrive_Parameters prms, uint8_t idx) {
+ std::shared_ptr<mikafil::Disk> p_disk = std::make_shared<mikafil::Disk>(disk_names[last_name_idx], last_name_idx, prms, idx);
disks.insert(std::pair<char, std::shared_ptr<mikafil::Disk>>(disk_names[last_name_idx], p_disk));
char ret = disk_names[last_name_idx];
last_name_idx++;
diff --git a/src/kernel/file_system.h b/src/kernel/file_system.h
index 6921b4a..fd14693 100644
--- a/src/kernel/file_system.h
+++ b/src/kernel/file_system.h
@@ -13,7 +13,7 @@
#include <vector>
#include <list>
-class Disk;
+
#ifdef KERNEL_EXPORTS
#define KERNEL_API __declspec(dllexport)
@@ -21,31 +21,34 @@ class Disk;
#define KERNEL_API __declspec(dllimport)
#endif
+namespace mikafil {
+ class Disk;
+ class File;
+
+ class KERNEL_API FileSystem
+ {
+ friend class Kernel;
-class KERNEL_API FileSystem
-{
- friend class Kernel;
-
#ifdef KERNEL_TEST
-public:
+ public:
#else
-private:
+ private:
#endif
- FileSystem();
+ FileSystem();
- std::map<char, std::shared_ptr<Disk>> disks;
- const static char* disk_names;
- uint8_t last_name_idx;
+ std::map<char, std::shared_ptr<mikafil::Disk>> disks;
+ const static char* disk_names;
+ uint8_t last_name_idx;
- char add_disk(kiv_hal::TDrive_Parameters prms);
+ char add_disk(kiv_hal::TDrive_Parameters prms, uint8_t idx);
- std::shared_ptr<Disk> get_disk(char name);
- std::shared_ptr<Disk> get_disk(uint8_t id);
- std::shared_ptr<File> getCurrentFile();
+ std::shared_ptr<mikafil::Disk> get_disk(char name);
+ std::shared_ptr<mikafil::Disk> get_disk(uint8_t id);
+ std::shared_ptr<mikafil::File> getCurrentFile();
+ };
};
-
/*
struct disk_item {
diff --git a/src/kernel/handle.cpp b/src/kernel/handle.cpp
index 0616bf5..acf2904 100644
--- a/src/kernel/handle.cpp
+++ b/src/kernel/handle.cpp
@@ -1,6 +1,7 @@
#include "handle.h"
#include "../kernel/conf.h"
#include "../kernel/utils.h"
+#include "../kernel/handle_item.h"
#include <mutex>
#include <random>
#include <iostream>
@@ -10,14 +11,11 @@ using namespace mikafil;
std::mutex Handles_Guard;
-Handle::Handle() {
-
-}
-
mikafil::Handle::Handle() {
}
+
kiv_os::THandle mikafil::Handle::convert(const HANDLE hnd)
{
return convert(hnd, HandleType::Unkonwn);
diff --git a/src/kernel/handle.h b/src/kernel/handle.h
index ca85550..60fc7da 100644
--- a/src/kernel/handle.h
+++ b/src/kernel/handle.h
@@ -2,9 +2,11 @@
#include <Windows.h>
#include <map>
+#include <memory>
#include "../api/api.h"
#include "../api/hal.h"
+#include "../kernel/handle_item.h"
#ifdef KERNEL_EXPORTS
@@ -13,11 +15,11 @@
#define KERNEL_API __declspec(dllimport)
#endif
-//namespace kernel {
+namespace mikafil {
class KERNEL_API Handle
{
friend class Kernel;
-
+
#ifdef KERNEL_TEST
public:
#else
@@ -25,12 +27,15 @@
#endif
Handle();
- static kiv_os::THandle convert(const HANDLE hnd);
- static HANDLE resolve(const kiv_os::THandle hnd);
- static bool remove(const kiv_os::THandle hnd);
- static bool exist(const kiv_os::THandle hnd);
+ kiv_os::THandle convert(const HANDLE hnd);
+ kiv_os::THandle convert(const HANDLE hnd, HandleType type);
+ HANDLE resolve(const kiv_os::THandle hnd);
+ HandleType type(const kiv_os::THandle hnd);
+ bool remove(const kiv_os::THandle hnd);
+ bool exist(const kiv_os::THandle hnd);
- static std::map<kiv_os::THandle, HANDLE> hndls;
+
+ std::map<kiv_os::THandle, std::shared_ptr<mikafil::HandleItem>> hndls;
};
-//}
+};
diff --git a/src/kernel/kernel.cpp b/src/kernel/kernel.cpp
index d339917..719e3d1 100644
--- a/src/kernel/kernel.cpp
+++ b/src/kernel/kernel.cpp
@@ -14,36 +14,29 @@ mikafil::Kernel mikafil::Kernel::krnl = mikafil::Kernel::Kernel();
mikafil::Kernel::Kernel(void)
{
hndl = std::make_unique<mikafil::Handle>();
+ fs = std::make_unique<FileSystem>();
+ initialized = false;
#ifdef KERNEL_TEST
- User_Programs = LoadLibrary(L"../../../../test/data/user.dll");
+ /* pro testovani nahrajeme predem pripravenou knihovnu*/
+ User_Programs = LoadLibraryW(L"../../../../test/data/user.dll");
#else
User_Programs = LoadLibraryW(L"user.dll");
#endif
}
-std::shared_ptr<mikafil::Process> mikafil::Kernel::createProcess(const kiv_hal::TRegisters& regs)
+user_function mikafil::Kernel::getUserFunction(const char* name)
{
- uint16_t parent_pid = 0;
- // upravime registry podle dokumentace v api.h
- kiv_hal::TRegisters reg = RegUtil::clone(regs);
- kiv_os::THandle out = reg.rbx.x;
- reg.rax.r = regs.rbx.r >> 16;
- reg.rbx.x = out;
-
- //vytvorime novy proces, ktery ale nebude zatim spusten
- return mikafil::Process::create(regs, *(hndl.get()), parent_pid);
+ void* handle = GetProcAddress(User_Programs, name);
+ return (user_function)handle;
}
+void mikafil::Kernel::init() {
+ if (initialized)
+ {
+ return;
+ }
-
-
-
-
-void __stdcall Bootstrap_Loader(kiv_hal::TRegisters& context)
-{
- kiv_hal::Set_Interrupt_Handler(kiv_os::System_Int_Number, Sys_Call);
- //v ramci ukazky jeste vypiseme dostupne disky
kiv_hal::TRegisters regs;
for (regs.rdx.l = 0; ; regs.rdx.l++) {
kiv_hal::TDrive_Parameters params;
@@ -71,7 +64,7 @@ void __stdcall Bootstrap_Loader(kiv_hal::TRegisters& context)
//print_str(hexa);
//print_str("\n");
- //fs.add_disk(params, (uint8_t)received.rdx.l);
+ fs->add_disk(params, (uint8_t)regs.rdx.l);
//std::cout << " bps = " << params.bytes_per_sector << " sctors = " << params.absolute_number_of_sectors << std::endl;
}
@@ -79,8 +72,35 @@ void __stdcall Bootstrap_Loader(kiv_hal::TRegisters& context)
if (regs.rdx.l == 255) break;
}
+ initialized = true;
+}
+
+std::shared_ptr<mikafil::Process> mikafil::Kernel::createProcess(const kiv_hal::TRegisters& regs)
+{
+ uint16_t parent_pid = 0;
+ // upravime registry podle dokumentace v api.h
+ kiv_hal::TRegisters reg = RegUtil::clone(regs);
+ kiv_os::THandle out = reg.rbx.x;
+ reg.rax.r = regs.rbx.r >> 16;
+ reg.rbx.x = out;
+
+ //vytvorime novy proces, ktery ale nebude zatim spusten
+ return mikafil::Process::create(regs, *(hndl.get()), parent_pid);
+}
+
+
+
+
+
+
+void __stdcall Bootstrap_Loader(kiv_hal::TRegisters& context)
+{
+ kiv_hal::Set_Interrupt_Handler(kiv_os::System_Int_Number, Sys_Call);
+ //v ramci ukazky jeste vypiseme dostupne disky
+
+ mikafil::Kernel::krnl.init();
//spustime shell - v realnem OS bychom ovsem spousteli login
/*kiv_os::TThread_Proc shell = (kiv_os::TThread_Proc)GetProcAddress(User_Programs, "shell");
diff --git a/src/kernel/kernel.h b/src/kernel/kernel.h
index bb20799..dda33ed 100644
--- a/src/kernel/kernel.h
+++ b/src/kernel/kernel.h
@@ -12,6 +12,8 @@
#include "../kernel/io.h"
#include "../kernel/executor.h"
#include "../kernel/handle.h"
+#include "../kernel/process.h"
+#include "../kernel/file_system.h"
@@ -22,6 +24,8 @@
#endif
+typedef size_t(__stdcall *user_function)(const kiv_hal::TRegisters& regs);
+
void __stdcall Bootstrap_Loader(kiv_hal::TRegisters& context);
@@ -31,6 +35,7 @@ namespace mikafil {
class Handle;
class Process;
+ class FileSystem;
// Tato tĹ™Ăda se exportuje z knihovny dll
class KERNEL_API Kernel {
@@ -45,19 +50,24 @@ namespace mikafil {
#endif
Kernel(void);
+ user_function getUserFunction(const char* name);
// TODO: sem přidejte svoje metody.
std::shared_ptr<mikafil::Process> createProcess(const kiv_hal::TRegisters& regs);
HMODULE User_Programs;
public:
static Kernel krnl;
-
+ void init();
#ifdef KERNEL_TEST
public:
+
#else
private:
#endif
- std::unique_ptr<mikafil::Handle>hndl;
+ bool initialized = false;
+
+ std::unique_ptr<mikafil::Handle>hndl;
+ std::unique_ptr<mikafil::FileSystem> fs;
};
};
diff --git a/src/kernel/process.cpp b/src/kernel/process.cpp
index e811653..3ddadb7 100644
--- a/src/kernel/process.cpp
+++ b/src/kernel/process.cpp
@@ -1,67 +1,178 @@
-#include "process.h"
-#include "process.h"
+#include <mutex>
+#include <memory>
+#include <string>
+
+#include "../kernel/process.h"
#include "../kernel/regutil.h"
+#include "../kernel/handle_item.h"
+#include "../kernel/kernel.h"
+
+
+/*
+Kriticka sekce ukonceni jakehokoliv procesu
+Pro tuto kritickou sekci vytvorime mutex pro vzajemne vylouceni
+*/
+std::mutex ProcessFinishedMutex;
+
+void process_run_function(void* data);
+
-std::map<uint16_t, std::shared_ptr<Process>> Process::prc_map;
-std::map<DWORD, uint16_t> Process::thr_map;
-std::map<uint16_t, DWORD> Process::thi_map;
-uint16_t Process::last_pid = 1;
+std::map<uint16_t, std::shared_ptr<mikafil::Process>> mikafil::Process::prc_map;
+std::map<DWORD, uint16_t> mikafil::Process::thr_map;
+std::map<uint16_t, DWORD> mikafil::Process::thi_map;
+uint16_t mikafil::Process::last_pid = 1;
+
+mikafil::Process::Process(const kiv_hal::TRegisters& p_regs, kiv_os::THandle p_handle, DWORD p_thread_id,
+ HANDLE p_thread, uint16_t p_pid, uint16_t p_ppid, user_function p_function,
+ std::shared_ptr<char[]> p_name, std::shared_ptr<char[]>p_params) :
+ pid(p_pid),
+ ppid(p_ppid),
+ regs(RegUtil::clone(regs)),
+ funkce(p_function),
+ name(p_name),
+ params(p_params),
+ input((kiv_os::THandle)regs.rax.x),
+ output((kiv_os::THandle)regs.rbx.x),
+ thread_id(p_thread_id),
+ thread(p_thread),
+ handle(p_handle)
-Process::Process(const kiv_hal::TRegisters& regs, uint16_t _ppid) : pid(gen_pid()), ppid(_ppid), regs(RegUtil::clone(regs))
{
+ prc_map.insert(std::pair<uint16_t, std::shared_ptr<mikafil::Process>>(this->pid, std::shared_ptr<mikafil::Process>(this)));
+ thr_map.insert(std::pair<DWORD, uint16_t>(this->thread_id, this->pid));
+ thi_map.insert(std::pair<uint16_t, DWORD>(this->pid, this->thread_id));
}
-double Process::tst()
+std::shared_ptr<mikafil::Process> mikafil::Process::create(const kiv_hal::TRegisters& regs, mikafil::Handle hndl, uint16_t ppid)
{
- return 0.0;
+ DWORD thread_id;
+ uint16_t pid = genPid();
+ HANDLE thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)process_run_function, (void*)pid, CREATE_SUSPENDED, &(thread_id));
+ kiv_os::THandle h = hndl.convert(thread, mikafil::HandleType::Process);
+ const char* addr = reinterpret_cast<char*>((char*)regs.rdx.r);
+ user_function p_funct = mikafil::Kernel::krnl.getUserFunction(addr);
+ std::shared_ptr<char[]> p_name = mikafil::Process::copyText(reinterpret_cast<char*>((char*)regs.rdx.r));
+ std::shared_ptr<char[]> p_params = mikafil::Process::copyText(reinterpret_cast<char*>((char*)regs.rdi.r));
+ return std::make_shared<mikafil::Process>(regs, h, thread_id, thread, pid, ppid, p_funct, p_name, p_params);
}
-std::shared_ptr<File> Process::getFile(kiv_os::THandle hndl)
+
+std::shared_ptr<mikafil::File> mikafil::Process::getFile(kiv_os::THandle hndl)
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-std::shared_ptr<Process> Process::current()
+std::shared_ptr<mikafil::Process> mikafil::Process::current()
{
DWORD dw = GetCurrentThreadId();
- auto itr = Process::thr_map.find(dw);
+ auto itr = mikafil::Process::thr_map.find(dw);
- if (itr != Process::thr_map.end())
+ if (itr != mikafil::Process::thr_map.end())
{
- if (Process::prc_map.find(itr->second) != Process::prc_map.end())
+ if (mikafil::Process::prc_map.find(itr->second) != mikafil::Process::prc_map.end())
{
- return Process::prc_map.at(itr->second);
+ return mikafil::Process::prc_map.at(itr->second);
}
}
- return std::shared_ptr<Process>();
+ return std::shared_ptr<mikafil::Process>();
+}
+
+bool mikafil::Process::erase(std::shared_ptr<mikafil::Process> prc)
+{
+
+ prc_map.erase(prc->pid);
+ thr_map.erase(prc->thread_id);
+ thi_map.erase(prc->pid);
+ return false;
}
-std::shared_ptr<File> Process::currentFile()
+std::shared_ptr<mikafil::File> mikafil::Process::currentFile()
{
- return std::shared_ptr<File>();
+ return std::shared_ptr<mikafil::File>();
}
-uint16_t Process::gen_pid()
+std::shared_ptr<mikafil::Process> mikafil::Process::get(uint16_t id)
{
-
- uint16_t break_pid = Process::last_pid;
- uint16_t work_pid = Process::last_pid;
+ auto iterator = prc_map.find(id);
+ if (iterator != prc_map.end()) {
+ return iterator->second;
+ }
+ return std::shared_ptr<mikafil::Process>();
+}
+
+uint16_t mikafil::Process::genPid()
+{
+
+ uint16_t break_pid = mikafil::Process::last_pid; // break pid bude slouzit jako zastavujici podminka nekonecneho cyklu
+ uint16_t work_pid = mikafil::Process::last_pid; // worked pid je pracovni id procesu
while (true) {
++work_pid;
if (work_pid == 0) // There isn't process with pid 0
{
continue;
}
- if (work_pid == break_pid)
+ if (work_pid == break_pid) // pokud se obe hodnoty rovanji, neni mozne vytvorit novy proces
{
break;
}
- if (Process::prc_map.find(work_pid) == Process::prc_map.end())
+ if (mikafil::Process::prc_map.find(work_pid) == mikafil::Process::prc_map.end())
{
+ //volne pid
+ last_pid = work_pid;
return work_pid;
}
}
/* Fatal error! There isn't possible pid for new process.*/
}
+
+
+void mikafil::Process::start()
+{
+ ResumeThread(this->thread);
+
+}
+
+std::shared_ptr<char[]> mikafil::Process::copyText(const char* data)
+{
+ char* arr = new char[(strlen(data) + 1)];
+
+ memset(arr, 0, (strlen(data) + 1));
+ memcpy(arr, (void*)data, strlen(data));
+ std::shared_ptr<char[]> text(arr);
+ return text;
+}
+
+void process_run_function(void* data) {
+ int pid = (int)data;
+ uint64_t tname;
+ std::shared_ptr<mikafil::Process> prc = mikafil::Process::get(pid);
+ //main = &prc;
+ if (prc)
+ {
+ try {
+ if (((uint64_t)prc->funkce) > 0) {
+ kiv_hal::TRegisters reg = mikafil::RegUtil::start_process(prc->name.get(), prc->params.get(), prc->input, prc->output);
+ prc->funkce(reg);
+ }
+
+ //delete name;
+ //delete params;
+ }
+ catch (...) {} //pokud se vyskytne vyjimka, tak ji ignorujem.
+ //tady fakt nepotrebujeme soubeh dvou procesu
+ ProcessFinishedMutex.lock();
+ /*
+ * Vyvolalem udalost, proces dokoncil svuj kod, ktera pro vede odstraneni zaznamu procesu z
+ * pseoudo PCB tabulky
+ */
+ prc->erase(prc);
+
+
+ ProcessFinishedMutex.unlock();
+
+ }
+
+}
+
diff --git a/src/kernel/process.h b/src/kernel/process.h
index fb525b4..189e437 100644
--- a/src/kernel/process.h
+++ b/src/kernel/process.h
@@ -2,64 +2,110 @@
#include <map>
#include <memory>
+#include <string>
#include <Windows.h>
#include "../../src/kernel/kernel.h"
#include "../../src/kernel/io.h"
#include "../../src/kernel/file.h"
-#include "../../src/kernel/pipe.h"
+#include "../../src/kernel/handle.h"
+
+
-class IO;
-class Kernel;
-class File;
-class Pipe;
#ifdef KERNEL_EXPORTS
#define KERNEL_API __declspec(dllexport)
#else
#define KERNEL_API __declspec(dllimport)
#endif
+/*
+ Funkce, ktera bude volana pri vytvoreni noveho procesu
+*/
+typedef size_t(__stdcall *user_function)(const kiv_hal::TRegisters& regs);
+
+/*
+* odkaz na funkci, ktera bude volana po ukonceni procesu
+*/
+typedef void (*callback_function)(const void*);
+
+// Tato tda se exportuje z knihovny dll
+namespace mikafil {
+
+ class File;
+ class Kernel;
+ class Executor;
+ class Handle;
+
+ class KERNEL_API Process {
+ friend class Kernel;
+ friend class Executor;
+
+#ifdef KERNEL_TEST
+ public:
+#else
+ public:
+#endif
+ Process(const kiv_hal::TRegisters& p_regs, kiv_os::THandle p_handle, DWORD p_thred_id,
+ HANDLE p_thread, uint16_t p_pid, uint16_t p_ppid, user_function p_function,
+ std::shared_ptr<char[]> p_name, std::shared_ptr<char[]>p_params);
+ // TODO: sem pidejte svoje metody.
+
+ static std::shared_ptr<Process> create(const kiv_hal::TRegisters& regs, mikafil::Handle hndl, uint16_t ppid);
+
+ /*mapovani porcesu podle identifikaturu vlakna*/
+ static std::map<uint16_t, std::shared_ptr<Process>> prc_map;
+ static std::map<DWORD, uint16_t> thr_map;
+ static std::map<uint16_t, DWORD> thi_map;
+
+ /*mapovani otevrenych handlu*/
+ std::map<kiv_os::THandle, HANDLE> hndls;
+
+
+ /*otevrene soubory*/
+ std::map<kiv_os::THandle, std::shared_ptr<File>> files;
+
+ /*otevrene trubky*/
+ //std::map<kiv_os::Handle, Pipe> pipes;
+
+ static uint16_t last_pid;
+
+ bool is_valid = false;
+
+ std::shared_ptr<File> getFile(kiv_os::THandle hndl);
+
+ static std::shared_ptr<mikafil::Process> current();
+ static bool erase(std::shared_ptr<mikafil::Process> prc);
+
+ std::shared_ptr<mikafil::File> currentFile();
+ static std::shared_ptr<mikafil::Process> get(uint16_t);
+ static uint16_t genPid();
+
+ void start();
+
+ const kiv_os::THandle input;
+ const kiv_os::THandle output;
+
+ const user_function funkce;
+
+ kiv_os::THandle handle;
+
+ public:
+ const std::shared_ptr<char[]> name;
+ const std::shared_ptr<char[]> params;
+ const uint16_t pid;
+ const uint16_t ppid;
+ const kiv_hal::TRegisters regs;
+
+ static std::shared_ptr<char[]> copyText(const char* data);
-// Tato třída se exportuje z knihovny dll
-class KERNEL_API Process {
- friend class Kernel;
- friend class IO;
-
#ifdef KERNEL_TEST
-public:
+ public:
#else
-private:
+ private:
#endif
- Process(const kiv_hal::TRegisters& regs, uint16_t pipid);
- // TODO: sem přidejte svoje metody.
- double tst();
-
- /*mapovani porcesu podle identifikaturu vlakna*/
- static std::map<uint16_t, std::shared_ptr<Process>> prc_map;
- static std::map<DWORD, uint16_t> thr_map;
- static std::map<uint16_t, DWORD> thi_map;
-
- /*mapovani otevrenych handlu*/
- std::map<kiv_os::THandle, HANDLE> hndls;
-
- /*otevrene soubory*/
- std::map<kiv_os::THandle, std::shared_ptr<File>> files;
-
- /*otevrene trubky*/
- std::map<kiv_os::THandle, Pipe> pipes;
-
- static uint16_t last_pid;
-
- bool is_valid = false;
-
- std::shared_ptr<File> getFile(kiv_os::THandle hndl);
-
- static std::shared_ptr<Process> current();
- std::shared_ptr<File> currentFile();
- static uint16_t gen_pid();
-public:
- const uint16_t pid;
- const uint16_t ppid;
- const kiv_hal::TRegisters regs;
-};
+
+ const DWORD thread_id;
+ const HANDLE thread;
+ };
+}
diff --git a/test/kernel/disk_test.cpp b/test/kernel/disk_test.cpp
index aaf6ba2..bf92c86 100644
--- a/test/kernel/disk_test.cpp
+++ b/test/kernel/disk_test.cpp
@@ -31,8 +31,9 @@ namespace disktest
char chr = 'F';
uint8_t id = (uint8_t)chr;
+ uint8_t kernel_id = (uint8_t)chr;
- Disk dsk(chr, id, prms);
+ Disk dsk(chr, id, prms,kernel_id);
Assert::AreEqual(
id,
dsk.id,
diff --git a/test/kernel/file_sytem_test.cpp b/test/kernel/file_sytem_test.cpp
index 42dc6df..38f4b22 100644
--- a/test/kernel/file_sytem_test.cpp
+++ b/test/kernel/file_sytem_test.cpp
@@ -23,8 +23,9 @@ namespace filesystemtest
{
kiv_hal::TDrive_Parameters prms = {};
mikafil::FileSystem fs;
+ uint8_t kernel_id = 1;
char exp = fs.disk_names[fs.last_name_idx];
- char ret = fs.add_disk(prms);
+ char ret = fs.add_disk(prms, kernel_id);
Assert::AreEqual(
(int)exp,
@@ -39,7 +40,8 @@ namespace filesystemtest
kiv_hal::TDrive_Parameters prms = {};
mikafil::FileSystem fs;
uint8_t last_idx_exp = fs.last_name_idx + 1;
- char ret = fs.add_disk(prms);
+ uint8_t kernel_id = 1;
+ char ret = fs.add_disk(prms,kernel_id);
uint8_t last_idx_ret = fs.last_name_idx;
Assert::AreEqual(
@@ -54,7 +56,9 @@ namespace filesystemtest
{
kiv_hal::TDrive_Parameters prms = {};
mikafil::FileSystem fs;
- char ret = fs.add_disk(prms);
+
+ uint8_t kernel_id = 1;
+ char ret = fs.add_disk(prms, kernel_id);
bool exp = (fs.disks.find(ret) == fs.disks.end());
Assert::IsTrue(
!exp,
@@ -67,7 +71,8 @@ namespace filesystemtest
{
kiv_hal::TDrive_Parameters prms = {};
mikafil::FileSystem fs;
- char chr = fs.add_disk(prms);
+ uint8_t kernel_id = 1;
+ char chr = fs.add_disk(prms, kernel_id);
std::shared_ptr<Disk> dsk = fs.get_disk(chr);
bool ret;
if (dsk)
diff --git a/test/kernel/process_test.cpp b/test/kernel/process_test.cpp
index 9c2ab8e..940a424 100644
--- a/test/kernel/process_test.cpp
+++ b/test/kernel/process_test.cpp
@@ -33,7 +33,7 @@ namespace processtest
L"Test set parent_pid",
LINE_INFO()
);
-
+ /*
Assert::AreEqual(
(long)input,
(long)prc->input,
@@ -47,7 +47,7 @@ namespace processtest
L"Test set handle output from registry",
LINE_INFO()
);
-
+ */
}
@@ -56,8 +56,8 @@ namespace processtest
uint16_t parent_pid = 123;
kiv_os::THandle input = 2142533;
kiv_os::THandle output = 12332109;
- char* program_name = "test";
- char* program_params = "-e";
+ const char* program_name = "test\0";
+ const char* program_params = "-e\0";
kiv_hal::TRegisters regs = RegUtil::clone_process(program_name, program_params, input, output);
mikafil::Handle hndl;
std::shared_ptr<Process> prc = mikafil::Process::create(regs, hndl, 1);
--
GitLab