process.start(address)
qm.schedule(process)
else:
print(
f"O processo {process.pid} não conseguiu ser criado (falta de memória)."
)
process.finish()
# Chama execução do escalonador, retornando o processo que foi executado no tempo atual
print(qm.print()
) # imprime filas de escalonamento para monitoramento das filas
process = qm.run()
# Se a execução atual foi a última instrução de um processo, libera sua memória
if process and process.is_finished():
memory.free(process)
sleep(0.5)
TIME += 1
print(
"\n--------------------- Operações com arquivos -----------------------\n\n"
)
# O primeiro número lido de files_input é o tamanho do disco
drive_size = int(files_input.readline())
# Inicializa disco
fm = FileManager(drive_size)
# O segundo é uma quantidade n de arquivos pré-gravados no sistema
for _ in range(int(files_input.readline())):
class Kernel:
def __init__(self):
self.my_shell = Shell()
self.my_file_manager = FileManager(Config.storage_block_size,
Config.storage_track_num,
Config.storage_sec_num)
self.my_memory_manager = MemoryManager(
mode=Config.memory_management_mode,
page_size=Config.memory_page_size,
page_number=Config.memory_page_number,
physical_page=Config.memory_physical_page_number)
self.my_process_manager = ProcessManager(self.my_memory_manager)
self.is_monitoring = False
# start process manager
self.my_process_manager_run_thread = threading.Thread(
target=self.my_process_manager.start_manager)
self.my_process_manager_run_thread.start()
# printer Threading
self.IOdevice_thread = threading.Thread(
target=self.my_process_manager.io_device_handler)
self.IOdevice_thread.start()
# signal.signal(signal.SIGINT, self.my_shell.deblock)
# monitoring all resources
def monitoring(self, interval=1):
self.is_monitoring = True
self.my_file_manager.disk.disk_monitoring = True
while self.is_monitoring:
self.my_process_manager.resource_monitor()
self.my_memory_manager.memory_watching()
self.my_file_manager.draw_disk_speed()
sleep(interval)
def report_error(self, cmd, err_msg=''):
print('[error %s] %s' % (cmd, err_msg))
if err_msg == '':
self.display_command_description(cmd_list=[cmd])
# command: man [cmd1] [cmd2] ...
def display_command_description(self, cmd_list):
command_to_description = {
'man': 'manual page, format: man [command1] [command2] ...',
'ls': 'list directory contents, format: ls [-a|-l|-al] [path]',
'cd': 'change current working directory, format: cd [path]',
'rm':
'remove file or directory recursively, format: rm [-r|-f|-rf] path',
'mkdir': 'create directory, format: mkdir path',
'mkf':
'create common file, format: mkf path type size, e.g. mkf my_file crwx 300',
'dss': 'display storage status, format: dss',
'dms': 'display memory status, format: dms',
'exec': 'execute file, format: exec path, e.g. exec test',
'chmod':
'change mode of file, format: chmod path new_mode, e.g. chmod test erwx',
'ps': 'display process status, format: ps',
'rs': 'display resource status, format: rs',
'mon':
'start monitoring system resources, format: mon [-o], use -o to stop',
'td': 'tidy and defragment your disk, format: td',
'kill': 'kill process, format: kill pid',
'exit': 'exit MiniOS'
}
if len(cmd_list) == 0:
cmd_list = command_to_description.keys()
for cmd in cmd_list:
if cmd in command_to_description.keys():
print(cmd, '-', command_to_description[cmd])
else:
self.report_error(cmd=cmd, err_msg='no such command')
def run(self):
while True:
# a list of commands split by space or tab
current_file_list = self.my_file_manager.ls(method='get')
command_split_list = self.my_shell.get_split_command(
cwd=self.my_file_manager.current_working_path,
file_list=current_file_list)
# this indicates user push Enter directly, then nothing to happen
if len(command_split_list) == 0:
continue
for command_split in command_split_list:
if len(command_split) == 0: # an empty command
continue
tool = command_split[0] # tool name, e.g. ls, cd, ...
argc = len(command_split) # argument count
if tool == 'man':
self.display_command_description(
cmd_list=command_split[1:])
elif tool == 'ls':
if argc >= 2:
if command_split[1][0] == '-':
mode = command_split[1]
path_list = command_split[2:]
if len(path_list) == 0:
path_list = ['']
else:
mode = ''
path_list = command_split[1:]
for path in path_list:
self.my_file_manager.ls(dir_path=path, mode=mode)
else:
self.my_file_manager.ls()
elif tool == 'cd':
if argc >= 2:
self.my_file_manager.cd(dir_path=command_split[1])
else:
self.my_file_manager.cd(dir_path=os.sep)
elif tool == 'rm':
if argc >= 2:
if command_split[1][0] == '-':
mode = command_split[1]
path_list = command_split[2:]
if len(path_list) == 0:
self.report_error(cmd=tool)
else:
mode = ''
path_list = command_split[1:]
for path in path_list:
self.my_file_manager.rm(file_path=path, mode=mode)
else:
self.report_error(cmd=tool)
elif tool == 'chmod':
if argc >= 3:
self.my_file_manager.chmod(file_path=command_split[1],
file_type=command_split[2])
else:
self.report_error(cmd=tool)
elif tool == 'mkf':
if argc >= 4:
self.my_file_manager.mkf(file_path=command_split[1],
file_type=command_split[2],
size=command_split[3])
else:
self.report_error(cmd=tool)
elif tool == 'mkdir':
if argc >= 2:
for path in command_split[1:]:
self.my_file_manager.mkdir(dir_path=path)
else:
self.report_error(cmd=tool)
elif tool == 'dss':
self.my_file_manager.display_storage_status()
elif tool == 'dms':
self.my_memory_manager.display_memory_status()
# self.my_shell.block(func=self.my_memory_manager.display_memory_status)
elif tool == 'exec':
if argc >= 2:
path_list = command_split[1:]
for path in path_list:
my_file = self.my_file_manager.get_file(
file_path=path, seek_algo=Config.seek_algo)
if my_file:
if my_file['type'][3] == 'x':
self.my_process_manager.create(
exefile=my_file)
else:
self.report_error(
cmd=tool,
err_msg='no execution permission')
else:
self.report_error(cmd=tool)
else:
self.report_error(cmd=tool)
elif tool == 'ps':
self.my_process_manager.print_process_status()
# self.my_shell.block(func=self.my_process_manager.process_status)
elif tool == 'rs':
self.my_process_manager.print_resource_status()
# self.my_shell.block(func=self.my_process_manager.resource_status)
elif tool == 'mon':
if argc >= 2 and command_split[1] == '-o':
print('Stop monitoring')
self.is_monitoring = False
self.my_file_manager.disk.disk_monitoring = False
else:
# start monitoring
print('Start monitoring')
monitor_thread = threading.Thread(
target=self.monitoring)
monitor_thread.daemon = True
monitor_thread.start()
elif tool == 'td':
self.my_file_manager.tidy_disk()
elif tool == 'kill':
if argc >= 2:
for pid in command_split[1:]:
pid_to_kill = int(pid)
kill_res = self.my_process_manager.kill(
pid=pid_to_kill)
if kill_res:
self.my_memory_manager.free(pid=pid_to_kill)
else:
self.report_error(cmd=tool)
elif tool == 'exit':
self.my_process_manager.is_running = False
exit(0)
else:
self.report_error(cmd=tool, err_msg='no such command')