Kernel: Remove Shell from kernel

This is now obsolete since we have a userspace Shell.
This commit is contained in:
Bananymous 2023-06-12 02:04:52 +03:00
parent 388cc7c3bb
commit ce55422a24
4 changed files with 0 additions and 755 deletions

View File

@ -41,7 +41,6 @@ set(KERNEL_SOURCES
kernel/Scheduler.cpp kernel/Scheduler.cpp
kernel/Semaphore.cpp kernel/Semaphore.cpp
kernel/Serial.cpp kernel/Serial.cpp
kernel/Shell.cpp
kernel/SpinLock.cpp kernel/SpinLock.cpp
kernel/SSP.cpp kernel/SSP.cpp
kernel/Storage/ATABus.cpp kernel/Storage/ATABus.cpp

View File

@ -1,39 +0,0 @@
#pragma once
#include <BAN/String.h>
#include <BAN/Vector.h>
#include <kernel/Input/KeyEvent.h>
namespace Kernel
{
class Shell
{
public:
Shell();
Shell(const Shell&) = delete;
BAN::ErrorOr<void> set_prompt(BAN::StringView);
void run();
private:
void rerender_buffer() const;
BAN::Vector<BAN::String> parse_arguments(BAN::StringView) const;
BAN::ErrorOr<void> process_command(const BAN::Vector<BAN::String>&);
BAN::ErrorOr<void> update_prompt();
private:
BAN::Vector<BAN::String> m_old_buffer;
BAN::Vector<BAN::String> m_buffer;
BAN::String m_prompt_string;
BAN::String m_prompt;
uint32_t m_prompt_length = 0;
struct
{
uint32_t line = 0;
uint32_t col = 0;
uint32_t index = 0;
} m_cursor_pos;
};
}

View File

@ -1,704 +0,0 @@
#include <BAN/ScopeGuard.h>
#include <BAN/StringView.h>
#include <BAN/Vector.h>
#include <kernel/CPUID.h>
#include <kernel/Device.h>
#include <kernel/Font.h>
#include <kernel/IO.h>
#include <kernel/PCI.h>
#include <kernel/PIT.h>
#include <kernel/Process.h>
#include <kernel/RTC.h>
#include <kernel/Shell.h>
#include <ctype.h>
#include <fcntl.h>
#include <unistd.h>
namespace Kernel
{
template<typename... Args>
static void TTY_PRINT(Args&&... args)
{
BAN::String message = BAN::String::formatted(BAN::forward<Args>(args)...);
MUST(Process::current().write(STDOUT_FILENO, message.data(), message.size()));
}
template<typename... Args>
static void TTY_PRINTLN(Args&&... args)
{
TTY_PRINT(BAN::forward<Args>(args)...);
MUST(Process::current().write(STDOUT_FILENO, "\n", 1));
}
static auto s_default_prompt = "\\[\e[32m\\]user\\[\e[m\\]:\\[\e[34m\\]\\w\\[\e[m\\]# "sv;
static const char* mode_string(Inode::Mode mode)
{
static char buffer[11] {};
buffer[0] =
mode.ifdir() ? 'd' :
mode.ifblk() ? 'b' :
mode.ifchr() ? 'c' :
mode.iflnk() ? 'l' :
'-';
buffer[1] = (mode.mode & Inode::Mode::IRUSR) ? 'r' : '-';
buffer[2] = (mode.mode & Inode::Mode::IWUSR) ? 'w' : '-';
buffer[3] = (mode.mode & Inode::Mode::IXUSR) ? 'x' : '-';
buffer[4] = (mode.mode & Inode::Mode::IRGRP) ? 'r' : '-';
buffer[5] = (mode.mode & Inode::Mode::IWGRP) ? 'w' : '-';
buffer[6] = (mode.mode & Inode::Mode::IXGRP) ? 'x' : '-';
buffer[7] = (mode.mode & Inode::Mode::IROTH) ? 'r' : '-';
buffer[8] = (mode.mode & Inode::Mode::IWOTH) ? 'w' : '-';
buffer[9] = (mode.mode & Inode::Mode::IXOTH) ? 'x' : '-';
return (const char*)buffer;
};
Shell::Shell()
{
MUST(Process::current().open("/dev/tty1", O_RDONLY));
MUST(Process::current().open("/dev/tty1", O_WRONLY));
MUST(Process::current().open("/dev/tty1", O_WRONLY));
MUST(set_prompt(s_default_prompt));
MUST(m_buffer.push_back(""sv));
MUST(Process::current().set_termios(termios { .canonical = false, .echo = false }));
}
BAN::ErrorOr<void> Shell::set_prompt(BAN::StringView prompt)
{
m_prompt_string = prompt;
TRY(update_prompt());
return {};
}
BAN::ErrorOr<void> Shell::update_prompt()
{
m_prompt_length = 0;
m_prompt.clear();
bool skipping = false;
for (size_t i = 0; i < m_prompt_string.size(); i++)
{
if (i < m_prompt_string.size() - 1 && m_prompt_string[i] == '\\')
{
switch (m_prompt_string[i + 1])
{
case '[':
skipping = true;
break;
case ']':
skipping = false;
break;
case 'w':
{
auto working_directory = TRY(Process::current().working_directory());
TRY(m_prompt.append(working_directory));
m_prompt_length += working_directory.size();
break;
}
default:
dprintln("unknown escape character '{}' in shell prompt", m_prompt_string[i + 1]);
break;
}
i++;
continue;
}
TRY(m_prompt.push_back(m_prompt_string[i]));
if (!skipping)
m_prompt_length++;
}
return {};
}
void Shell::run()
{
auto getch = [this] { uint8_t ch; MUST(Process::current().read(STDIN_FILENO, &ch, 1)); return ch; };
MUST(m_buffer.push_back(""sv));
TTY_PRINT("{}", m_prompt);
for (;;)
{
BAN::String& current = m_buffer[m_cursor_pos.line];
uint8_t ch = getch();
if (ch == '\b')
{
if (!current.empty())
{
while ((current.back() & 0xC0) == 0x80)
current.pop_back();
current.pop_back();
MUST(Process::current().write(STDOUT_FILENO, "\b \b", 3));
}
continue;
}
if (ch == '\e')
{
bool handled = false;
if (getch() == '[')
{
handled = true;
switch (getch())
{
case 'A': // Up
if (m_cursor_pos.line > 0)
{
m_cursor_pos.line--;
TTY_PRINT("\e[G{}{}\e[K", m_prompt, m_buffer[m_cursor_pos.line]);
}
break;
case 'B': // Down
if (m_cursor_pos.line < m_buffer.size() - 1)
{
m_cursor_pos.line++;
TTY_PRINT("\e[G{}{}\e[K", m_prompt, m_buffer[m_cursor_pos.line]);
}
break;
case 'C': // Right
break;
case 'D': // Left
break;
default:
handled = false;
}
}
if (!handled)
while (!isalpha(ch))
ch = getch();
continue;
}
MUST(Process::current().write(STDOUT_FILENO, &ch, 1));
if (ch != '\n')
{
MUST(current.push_back(ch));
continue;
}
if (auto res = process_command(parse_arguments(current)); res.is_error())
TTY_PRINTLN("{}", res.error());
TTY_PRINT("{}", m_prompt);
if (!current.empty())
{
MUST(m_old_buffer.push_back(current));
m_buffer = m_old_buffer;
MUST(m_buffer.push_back(""sv));
m_cursor_pos.line = m_buffer.size() - 1;
}
}
}
BAN::Vector<BAN::String> Shell::parse_arguments(BAN::StringView command) const
{
BAN::Vector<BAN::String> result;
while (!command.empty())
{
while (!command.empty() && isspace(command.front()))
command = command.substring(1);
if (command.empty())
break;
MUST(result.push_back(""sv));
char quoted = '\0';
bool escape = false;
while (!command.empty())
{
char ch = command.front();
switch (ch)
{
case '"':
case '\'':
if (!quoted)
quoted = ch;
else if (ch == quoted)
quoted = '\0';
else
goto default_case;
break;
case '\\':
if (escape)
goto default_case;
escape = true;
break;
default:
default_case:
if (isspace(ch) && !quoted && !escape)
goto argument_done;
if (quoted && escape)
{
switch (ch)
{
case 'f': MUST(result.back().push_back('\f')); break;
case 'n': MUST(result.back().push_back('\n')); break;
case 'r': MUST(result.back().push_back('\r')); break;
case 't': MUST(result.back().push_back('\t')); break;
case 'v': MUST(result.back().push_back('\v')); break;
case '"': MUST(result.back().push_back('"')); break;
case '\'': MUST(result.back().push_back('\'')); break;
case '\\': MUST(result.back().push_back('\\')); break;
default:
char buffer[3] { '\\', ch, '\0' };
MUST(result.back().append(buffer));
break;
}
}
else
{
MUST(result.back().push_back(ch));
}
escape = false;
break;
}
command = command.substring(1);
}
argument_done:
continue;
}
return result;
}
static uint32_t const crc32_table[256] =
{
0x00000000,
0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6,
0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac,
0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f,
0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a,
0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58,
0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033,
0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe,
0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4,
0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5,
0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07,
0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c,
0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1,
0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b,
0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698,
0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d,
0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f,
0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80,
0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a,
0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629,
0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c,
0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e,
0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65,
0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8,
0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2,
0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74,
0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21,
0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a,
0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087,
0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d,
0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce,
0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb,
0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09,
0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf,
0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};
BAN::ErrorOr<void> Shell::process_command(const BAN::Vector<BAN::String>& arguments)
{
if (arguments.empty())
{
}
else if (arguments.front() == "date")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'date' does not support command line arguments");
return {};
}
auto time = RTC::get_current_time();
TTY_PRINTLN("{}", time);
}
else if (arguments.front() == "echo")
{
if (arguments.size() > 1)
{
TTY_PRINT("{}", arguments[1]);
for (size_t i = 2; i < arguments.size(); i++)
TTY_PRINT(" {}", arguments[i]);
}
TTY_PRINTLN("");
}
else if (arguments.front() == "clear")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'clear' does not support command line arguments");
return {};
}
TTY_PRINT("\e[2J\e[H");
}
else if (arguments.front() == "exit")
{
Process::current().exit(0);
}
else if (arguments.front() == "time")
{
auto new_args = arguments;
new_args.remove(0);
auto start = PIT::ms_since_boot();
auto ret = process_command(new_args);
auto duration = PIT::ms_since_boot() - start;
TTY_PRINTLN("took {} ms", duration);
if (ret.is_error())
return ret.error();
}
else if (arguments.front() == "thread")
{
struct thread_data_t
{
Shell* shell;
SpinLock& lock;
const BAN::Vector<BAN::String>& arguments;
};
auto function = [](void* data)
{
thread_data_t* thread_data = (thread_data_t*)data;
Shell* shell = thread_data->shell;
auto args = thread_data->arguments;
thread_data->lock.unlock();
args.remove(0);
PIT::sleep(5000);
if (auto res = shell->process_command(args); res.is_error())
TTY_PRINT("{}", res.error());
};
SpinLock spinlock;
thread_data_t thread_data = { this, spinlock, arguments };
spinlock.lock();
auto* thread = TRY(Thread::create_kernel(function, &thread_data, &Process::current()));
Process::current().add_thread(thread);
while (spinlock.is_locked());
}
else if (arguments.front() == "memory")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'memory' does not support command line arguments");
return {};
}
kmalloc_dump_info();
TTY_PRINTLN("heap:");
TTY_PRINTLN(" used: 0x{8H}", Heap::get().used_pages() * PAGE_SIZE);
TTY_PRINTLN(" free: 0x{8H}", Heap::get().free_pages() * PAGE_SIZE);
}
else if (arguments.front() == "sleep")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'sleep' does not support command line arguments");
return {};
}
PIT::sleep(5000);
}
else if (arguments.front() == "cpuinfo")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'cpuinfo' does not support command line arguments");
return {};
}
uint32_t ecx, edx;
auto vendor = CPUID::get_vendor();
CPUID::get_features(ecx, edx);
TTY_PRINTLN("Vendor: '{}'", vendor);
TTY_PRINTLN("64-bit: {}", CPUID::is_64_bit());
bool first = true;
for (int i = 0; i < 32; i++)
if (ecx & ((uint32_t)1 << i))
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::feature_string_ecx((uint32_t)1 << i));
for (int i = 0; i < 32; i++)
if (edx & ((uint32_t)1 << i))
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::feature_string_edx((uint32_t)1 << i));
if (!first)
TTY_PRINTLN("");
}
else if (arguments.front() == "random")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'random' does not support command line arguments");
return {};
}
uint32_t ecx, edx;
CPUID::get_features(ecx, edx);
if (!(ecx & CPUID::Features::ECX_RDRND))
{
TTY_PRINTLN("cpu does not support RDRAND instruction");
return {};
}
for (int i = 0; i < 10; i++)
{
uint32_t random;
asm volatile("rdrand %0" : "=r"(random));
TTY_PRINTLN(" 0x{8H}", random);
}
}
else if (arguments.front() == "reboot")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'reboot' does not support command line arguments");
return {};
}
uint8_t good = 0x02;
while (good & 0x02)
good = IO::inb(0x64);
IO::outb(0x64, 0xFE);
asm volatile("cli; hlt");
}
else if (arguments.front() == "lspci")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'lspci' does not support command line arguments");
return {};
}
for (auto& device : PCI::get().devices())
TTY_PRINTLN("{2H}:{2H}.{2H} {2H}", device.bus(), device.dev(), device.func(), device.class_code());
}
else if (arguments.front() == "ls")
{
if (arguments.size() > 2)
{
TTY_PRINTLN("usage: 'ls [path]'");
return {};
}
BAN::String path;
if (arguments.size() == 2)
TRY(path.append(arguments[1]));
else
TRY(path.append(TRY(Process::current().working_directory())));
int fd = TRY(Process::current().open(path, O_RDONLY));
BAN::ScopeGuard _([fd] { MUST(Process::current().close(fd)); });
BAN::Vector<BAN::String> all_entries;
DirectoryEntryList* directory_list = (DirectoryEntryList*)kmalloc(4096);
if (directory_list == nullptr)
return BAN::Error::from_errno(ENOMEM);
while (true)
{
TRY(Process::current().read_next_directory_entries(fd, directory_list, 4096));
if (directory_list->entry_count == 0)
break;
DirectoryEntry* current = directory_list->array;
for (size_t i = 0; i < directory_list->entry_count; i++)
{
TRY(all_entries.emplace_back(current->dirent.d_name));
current = current->next();
}
}
BAN::String entry_prefix;
TRY(entry_prefix.append(path));
TRY(entry_prefix.push_back('/'));
for (const auto& entry : all_entries)
{
struct stat st;
BAN::String entry_path;
TRY(entry_path.append(entry_prefix));
TRY(entry_path.append(entry));
TRY(Process::current().stat(entry_path, &st, O_RDONLY | O_NOFOLLOW));
Inode::Mode mode { st.st_mode };
const char* color =
mode.ifdir() ? "34" :
mode.ifchr() || mode.ifblk() ? "33" :
mode.iflnk() ? "36" :
(mode.mode & Inode::Mode::IXUSR) ? "32" :
"";
TTY_PRINTLN(" {} {7} \e[{}m{}\e[m", mode_string(mode), st.st_size, color, entry);
}
}
else if (arguments.front() == "cat")
{
if (arguments.size() != 2)
{
TTY_PRINTLN("usage: 'cat path'");
return {};
}
int fd = TRY(Process::current().open(arguments[1], O_RDONLY));
BAN::ScopeGuard _([fd] { MUST(Process::current().close(fd)); });
constexpr size_t buffer_size = 1024;
char* buffer = new char[buffer_size];
BAN::ScopeGuard buffer_guard([buffer] { delete[] buffer; });
ASSERT(buffer);
while (size_t n_read = TRY(Process::current().read(fd, buffer, buffer_size)))
TTY_PRINT("{}", BAN::StringView(buffer, n_read));
TTY_PRINTLN("");
}
else if (arguments.front() == "stat")
{
if (arguments.size() != 2)
{
TTY_PRINTLN("usage: 'stat path'");
return {};
}
struct stat st;
TRY(Process::current().stat(arguments[1], &st, O_RDONLY | O_NOFOLLOW));
Inode::Mode mode { st.st_mode };
const char* type =
mode.ifreg() ? "regular file" :
mode.ifdir() ? "directory" :
mode.ifchr() ? "character device" :
mode.ifblk() ? "block device" :
mode.iflnk() ? "symbolic link" :
"other";
TTY_PRINTLN(" File: {}", arguments[1]);
TTY_PRINTLN(" Size: {}\tBlocks: {}\tIO Block: {}\t {}", st.st_size, st.st_blocks, st.st_blksize, type);
TTY_PRINT("Device: {},{}\tInode: {}\tLinks: {}", major(st.st_dev), minor(st.st_dev), st.st_ino, st.st_nlink);
if (st.st_rdev)
TTY_PRINT("\tDevice type: {},{}", major(st.st_rdev), minor(st.st_rdev));
TTY_PRINTLN("");
TTY_PRINTLN("Access: ({4O}/{})\tUid: {}\tGid: {}", mode.mode & 0777, mode_string(mode), st.st_uid, st.st_gid);
TTY_PRINTLN("Access: {}", BAN::from_unix_time(st.st_atime));
TTY_PRINTLN("Modify: {}", BAN::from_unix_time(st.st_mtime));
TTY_PRINTLN("Change: {}", BAN::from_unix_time(st.st_ctime));
}
else if (arguments.front() == "cd")
{
if (arguments.size() > 2)
{
TTY_PRINTLN("usage 'cd path'");
return {};
}
BAN::StringView path = arguments.size() == 2 ? arguments[1].sv() : "/"sv;
TRY(Process::current().set_working_directory(path));
TRY(update_prompt());
}
else if (arguments.front() == "touch")
{
if (arguments.size() != 2)
{
TTY_PRINTLN("usage 'touch path'");
return {};
}
TRY(Process::current().creat(arguments[1], 0));
}
else if (arguments.front() == "cksum")
{
if (arguments.size() < 2)
{
TTY_PRINTLN("usage 'cksum paths...'");
return {};
}
constexpr size_t buffer_size = 1024;
uint8_t* buffer = new uint8_t[buffer_size];
BAN::ScopeGuard buffer_guard([buffer] { delete[] buffer; });
ASSERT(buffer);
for (size_t i = 1; i < arguments.size(); i++)
{
int fd = TRY(Process::current().open(arguments[i], O_RDONLY));
BAN::ScopeGuard _([fd] { MUST(Process::current().close(fd)); });
uint32_t crc32 = 0;
uint32_t total_read = 0;
while (true)
{
size_t n_read = TRY(Process::current().read(fd, buffer, buffer_size));
if (n_read == 0)
break;
for (size_t j = 0; j < n_read; j++)
crc32 = (crc32 << 8) ^ crc32_table[((crc32 >> 24) ^ buffer[j]) & 0xFF];
total_read += n_read;
}
for (uint32_t length = total_read; length; length >>= 8)
crc32 = (crc32 << 8) ^ crc32_table[((crc32 >> 24) ^ length) & 0xFF];
crc32 = ~crc32 & 0xFFFFFFFF;
TTY_PRINTLN("{} {} {}", crc32, total_read, arguments[i]);
}
}
else if (arguments.front() == "mount")
{
if (arguments.size() != 3)
{
TTY_PRINTLN("usage: 'mount partition directory'");
return {};
}
TRY(Process::current().mount(arguments[1], arguments[2]));
}
else if (arguments.front() == "loadfont")
{
if (arguments.size() != 2)
{
TTY_PRINTLN("usage: 'loadfont font_path'");
return {};
}
auto font = TRY(Font::load(arguments[1]));
//m_tty->set_font(font);
}
else
{
TTY_PRINTLN("unrecognized command '{}'", arguments.front());
return {};
}
return {};
}
void Shell::rerender_buffer() const
{
TTY_PRINT("\e[{}G{}\e[K", m_prompt_length + 1, m_buffer[m_cursor_pos.line]);
}
}

View File

@ -18,7 +18,6 @@
#include <kernel/Process.h> #include <kernel/Process.h>
#include <kernel/Scheduler.h> #include <kernel/Scheduler.h>
#include <kernel/Serial.h> #include <kernel/Serial.h>
#include <kernel/Shell.h>
#include <kernel/Syscall.h> #include <kernel/Syscall.h>
#include <kernel/Terminal/TTY.h> #include <kernel/Terminal/TTY.h>
#include <kernel/Terminal/VesaTerminalDriver.h> #include <kernel/Terminal/VesaTerminalDriver.h>
@ -181,14 +180,4 @@ static void init2(void* tty1)
((TTY*)tty1)->initialize_device(); ((TTY*)tty1)->initialize_device();
MUST(Process::create_userspace({ 0, 0, 0, 0 }, "/usr/bin/init"sv)); MUST(Process::create_userspace({ 0, 0, 0, 0 }, "/usr/bin/init"sv));
return;
Process::create_kernel(
[](void*)
{
Shell* shell = new Shell();
ASSERT(shell);
shell->run();
}, nullptr
);
} }