forked from KolibriOS/kolibrios
2122 lines
71 KiB
HTML
2122 lines
71 KiB
HTML
; Copyright (c) 2009, <Lrz>
|
||
; All rights reserved.
|
||
;
|
||
; Redistribution and use in source and binary forms, with or without
|
||
; modification, are permitted provided that the following conditions are met:
|
||
; * Redistributions of source code must retain the above copyright
|
||
; notice, this list of conditions and the following disclaimer.
|
||
; * Redistributions in binary form must reproduce the above copyright
|
||
; notice, this list of conditions and the following disclaimer in the
|
||
; documentation and/or other materials provided with the distribution.
|
||
; * Neither the name of the <organization> nor the
|
||
; names of its contributors may be used to endorse or promote products
|
||
; derived from this software without specific prior written permission.
|
||
;
|
||
; THIS SOFTWARE IS PROVIDED BY Alexey Teplov nickname <Lrz> ''AS IS'' AND ANY
|
||
; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||
; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||
; DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
|
||
; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||
; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||
; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||
; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||
; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
;*****************************************************************************
|
||
|
||
; в этой секции идет разбор параметров указатель на секцию храниться в point_default
|
||
;типы ошибок при обработке макроса
|
||
;Макрос RamdiskFS
|
||
;/определение флагов в записи корневой директории
|
||
ATTR_READ_ONLY equ 0x01
|
||
ATTR_HIDDEN equ 0x02
|
||
ATTR_SYSTEM equ 0x04
|
||
ATTR_VOLUME_ID equ 0x08
|
||
ATTR_DIRECTORY equ 0x10
|
||
ATTR_ARCHIVE equ 0x20
|
||
|
||
|
||
|
||
show_error_1 equ 0x1 ;кончились данные - не запланированный конец секции
|
||
show_error_2 equ 0x2 ;нет завершающего символа в размере рам диска.
|
||
show_error_3 equ 0x4 ; рам диск будет иметь размер =64 кб.
|
||
show_error_4 equ 0x8 ;
|
||
|
||
macro use_parse_def_sect
|
||
{
|
||
mov di, point_default
|
||
push ini_data_
|
||
pop es
|
||
mov si, point_to_point_def
|
||
sub si, 2
|
||
mov cx, [si] ;загрузим указатель наследующию секцию
|
||
|
||
xor ax, ax ;обнулим аx для очистки флагов
|
||
|
||
sub cx, di ;вот теперь имеем истиный размер
|
||
mov save_cx_d, cx ;сохраним значение cx своей переменной
|
||
;обнулим переменную флагов, это необходимо, для того, что бы избежать обработку повторяющихся значений
|
||
|
||
mov status_flag, ax
|
||
;;;;
|
||
;ВХод в обработку парсинга значений секций. es:di - указатель на начало секции cx размер секции доступной для парсинга
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
;соглашение не разрушаем bp, es, cs, sp
|
||
;use_Loader_Image ;загрузить образ выше 1 мб
|
||
use_RamdiskFS
|
||
;проверяется самый последний.
|
||
use_LoaderModule ;особенность - передает управление на загруженный модуль.
|
||
}
|
||
|
||
macro use_LoaderModule
|
||
;как вариант сейчас используется модель, при загрузке модуля на него передается управление, решение временое
|
||
;управление будет передаваться только после обработки всей секции
|
||
{
|
||
local .found_end_str
|
||
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
;обработка конструкции типа LoaderModule=kord/kolibri.ldm
|
||
.start_p_LM:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz ._afterLoaderModule ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'L'
|
||
jnz .start_p_LM
|
||
;проверка на значение LoaderModule
|
||
; parse_LoaderModule
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_LoaderModule
|
||
mov cx, parse_LoaderModule_e - parse_LoaderModule
|
||
repe cmpsb
|
||
jnz .rest_value_loop_LM ;is not compare
|
||
|
||
sub bx, parse_LoaderModule_e - parse_LoaderModule;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
test status_flag, flag_found_LM ;оценка флагов
|
||
jz .correct_is_not_set_LM
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
.correct_is_not_set_LM:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
jcxz .rest_value_loop_LM ;not found param timeout
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .rest_value_loop_LM
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;di указывает на начало блока информации, в cx длинна до конца секции.
|
||
;после загрузки заноситься значение занятой памяти.
|
||
;для того что бы загрузить модуль, воспользуемся callback сервисом
|
||
;оригинальное решение - разместим dd перед строчкой и после строчки разместим byte =0
|
||
;это выглядит так: в ini файле существует строчка LoaderModule = kord/kernel.loader
|
||
;мы ее модифицируем до такого состояния dw,dw,db'kord/kernel.loader',0 конечно сохранив те значения которые мы заменяем
|
||
;сохранили певые 2 word
|
||
push dword [es:di-6]
|
||
lea si, [di-6]
|
||
|
||
push word [es:di-2]
|
||
xor ax, ax
|
||
mov word [es:di-6], ax ;вносим нужные значения
|
||
;info_real_mode_size размер и указатель на область в которую можно загрузиться
|
||
mov ax, info_real_mode_size ;0x3000 ;следующий сегмент за данными
|
||
|
||
|
||
mov word [es:di-4], ax
|
||
mov word [es:di-2], 16 ;кол-во блоков по 4 кб =64 кб т.е. больше не считаем
|
||
;;;;;; поиск конца строчки
|
||
@@:
|
||
mov al, byte [es:di]
|
||
cmp al, ' '
|
||
jz .found_end_str
|
||
cmp al, 0xa
|
||
jz .found_end_str
|
||
cmp al, 0xd
|
||
jz .found_end_str
|
||
inc di
|
||
dec cx
|
||
jnz @b
|
||
;;;not found допустим,что это конец файла и он не имеет привычного заверешния строки
|
||
.found_end_str:
|
||
|
||
push word [es:di]
|
||
xor ax, ax
|
||
mov word [es:di], ax
|
||
; xor ax,ax ; function 1 - read file
|
||
mov di, si ;file_data
|
||
inc ax
|
||
push si
|
||
push es
|
||
|
||
push es
|
||
pop ds
|
||
push cs
|
||
pop es
|
||
|
||
call far dword [es:loader_callback]
|
||
|
||
push cs
|
||
pop ds
|
||
|
||
pop es
|
||
pop si
|
||
|
||
test bx, bx
|
||
jnz .error_LM
|
||
|
||
|
||
jmp far dword [es:si]
|
||
|
||
|
||
.error_LM:
|
||
call error.LoaderModule
|
||
.rest_value_loop_LM:
|
||
mov di, ax
|
||
mov cx, bx
|
||
jmp .start_p_LM
|
||
|
||
._afterLoaderModule:
|
||
}
|
||
|
||
macro use_RamdiskFS
|
||
; формирование рам диска, + обработка всего связанного.
|
||
{
|
||
if DEBUG
|
||
local ._not_memory_in_sys
|
||
;//////// clear window
|
||
mov ax, 3
|
||
int 0x10
|
||
;\\\\\\\\\ clear window is end
|
||
mov si, ramdiskFS_st
|
||
call printplain
|
||
end if
|
||
; обнулим регистр состояния ошибок
|
||
xor ax, ax
|
||
mov show_errors_sect, ax
|
||
use_free_memory ; узнаем какого объема у нас доступна память. значение возаращается в ax
|
||
;узнаем сколько у нас есть памяти и сможем ли мы сформировать нужного размера рам диск.
|
||
use_RamdiskSize ;значение возвращается в bx
|
||
cmp free_ad_memory, bx ; размерность в кб.
|
||
jbe ._not_memory_in_sys
|
||
movzx eax, bx
|
||
shl eax, 10 ;*1024 = get size in byte
|
||
mov save_ramdisksize, eax ; сорханим размер в byte
|
||
|
||
get_type_FS ;получим тип файловой системы + создадим ее
|
||
|
||
|
||
._not_memory_in_sys:
|
||
|
||
if DEBUG
|
||
;pause
|
||
xor ax, ax
|
||
int 0x16
|
||
end if
|
||
}
|
||
macro use_RamdiskSize
|
||
{
|
||
local .start_p_RS
|
||
local .correct_is_not_set_RS
|
||
local .CS
|
||
local .correct_val_RS
|
||
local .correct_size_RS
|
||
local .rest_value_loop_RS
|
||
local .end_get_RS_ERROR_1
|
||
local .end_get_RS_ERROR_2
|
||
local ._end_parse_RS
|
||
;обрабатывается размер формируемого рам диска
|
||
;загрузим начало секции, т.к. будем просматривать с начала и всю секцию
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
.start_p_RS:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz ._end_parse_RS ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'R'
|
||
jnz .start_p_RS
|
||
;проверка на значения RamdiskSize
|
||
; parse_RamdiskSize
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RamdiskSize
|
||
mov cx, parse_RamdiskSize_e - parse_RamdiskSize
|
||
repe cmpsb
|
||
jnz .rest_value_loop_RS ;is not compare
|
||
|
||
sub bx, parse_RamdiskSize_e - parse_RamdiskSize;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
test status_flag, flag_found_RS ;оценка флагов
|
||
jz .correct_is_not_set_RS
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
.correct_is_not_set_RS:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
jcxz .end_get_RS_ERROR_1 ;not found param
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .start_p_RS ; перейдем на начало и попробуем найти еще секцию
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
;Тут нужно преобразовывать строчку в цифровое значение.
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
xor bx, bx
|
||
mov cx, 5
|
||
@@:
|
||
mov al, byte [es:di]
|
||
cmp al, '0'
|
||
jb .CS
|
||
cmp al, '9'
|
||
jbe .correct_val_RS
|
||
.CS:
|
||
cmp al, 'K'
|
||
jz .correct_size_RS
|
||
jmp .end_get_RS_ERROR_2
|
||
.correct_val_RS:
|
||
imul bx, 10
|
||
xor al, 0x30
|
||
add bl, al
|
||
inc di
|
||
loop @b
|
||
|
||
.correct_size_RS:
|
||
;возможен 1 вариант, когда размер задан в K киллобайтах
|
||
;внутренный формат данных это кол-во запрощеной памяти в кб.
|
||
test bx, bx
|
||
jnz @f ;если значение отлично от 0
|
||
;;;;;сообщение об ошибке, размер "найденого" блока =0 минимально мы должны
|
||
;установить 64 кб размер рам диска.
|
||
or show_errors_sect, show_error_3
|
||
mov bx, 64
|
||
@@:
|
||
jmp ._end_parse_RS
|
||
|
||
|
||
.rest_value_loop_RS:
|
||
mov di, ax
|
||
mov cx, bx
|
||
jmp .start_p_RS
|
||
|
||
|
||
|
||
.end_get_RS_ERROR_1:
|
||
;сообщение об ошибке - данный участок кода не был корректно обработан :(
|
||
or show_errors_sect, show_error_1
|
||
jmp ._end_parse_RS
|
||
.end_get_RS_ERROR_2:
|
||
or show_errors_sect, show_error_2
|
||
|
||
._end_parse_RS:
|
||
if DEBUG
|
||
pusha
|
||
movzx eax, bx
|
||
mov cx, 0x0a
|
||
mov di, RamdiskSize_msg
|
||
mov dword[ds:di], ' '
|
||
mov word [ds:di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, RamdiskSize_msg
|
||
call printplain
|
||
|
||
popa
|
||
end if
|
||
|
||
}
|
||
|
||
macro use_free_memory
|
||
{
|
||
local _support_function_use_free_memory
|
||
;макрос для получения общего числа доступной памяти в кб, для формирования рам диска за пределами 1 мб.
|
||
;используется 0х88 функция 0х15 прерывания
|
||
; если поддерживается функция, то в ax значение в кб, если нет, то в ax=0
|
||
mov ah, 0x88 ;ah,0x88
|
||
int 0x15
|
||
jnc ._support_function_use_free_memory
|
||
xor ax, ax
|
||
;возвращает в ax число в кб
|
||
._support_function_use_free_memory:
|
||
mov free_ad_memory, ax ; если не поддерживается биосом, то в ax=0
|
||
if DEBUG
|
||
pushad
|
||
movzx eax, ax
|
||
mov cx, 0x0a
|
||
mov di, free_memory_msg
|
||
mov dword[ds:di], ' '
|
||
mov word [ds:di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, free_memory_msg
|
||
call printplain
|
||
|
||
popad
|
||
end if
|
||
|
||
|
||
|
||
|
||
}
|
||
macro show_ERRORS
|
||
{
|
||
|
||
}
|
||
|
||
macro get_type_FS ;получить и создать образ для заданной RFS.
|
||
{
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
.start_g_tpe_RFS:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz ._end_parse_FRS ;._end_get_type_RFS ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'R'
|
||
jnz .start_g_tpe_RFS
|
||
;проверка на значения RamdiskSize
|
||
; parse_RamdiskSize
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RamdiskFS
|
||
mov cx, parse_RamdiskFS_e - parse_RamdiskFS
|
||
repe cmpsb
|
||
jnz .start_g_tpe_RFS_rest_v ;is not compare
|
||
|
||
sub bx, parse_RamdiskFS_e - parse_RamdiskFS;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
test status_flag, flag_found_GTRFMS ;оценка флагов
|
||
jz .correct_is_not_set_FRS
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
.correct_is_not_set_FRS:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
test cx, cx
|
||
jz .end_get_FRS_ERROR_1 ;not found param
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .start_g_tpe_RFS ; перейдем на начало и попробуем найти еще секцию
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
;Тут нужно преобразовывать строчку в цифровое значение.
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RFS_FAT
|
||
mov cx, parse_RFS_FAT_e - parse_RFS_FAT
|
||
repe cmpsb
|
||
jnz .krfs_cmp ;is not compare
|
||
|
||
make_FAT_RamFS ;сделать
|
||
|
||
if DEBUG
|
||
pusha
|
||
mov si, make_fat12_RFS_msg
|
||
call printplain
|
||
popa
|
||
end if
|
||
jmp ._end_parse_FRS
|
||
|
||
.krfs_cmp:
|
||
mov cx, bx
|
||
mov di, ax
|
||
|
||
mov si, parse_RFS_KRFS
|
||
mov cx, parse_RFS_KRFS_e - parse_RFS_KRFS
|
||
repe cmpsb
|
||
; jnz @f ;is not compare
|
||
|
||
jmp ._end_parse_FRS
|
||
|
||
|
||
.start_g_tpe_RFS_rest_v:
|
||
mov cx, bx
|
||
mov di, ax
|
||
jmp .start_g_tpe_RFS
|
||
|
||
|
||
|
||
.end_get_FRS_ERROR_1:
|
||
;сообщение об ошибке - данный участок кода не был корректно обработан :(
|
||
or show_errors_sect, show_error_1
|
||
jmp ._end_parse_FRS
|
||
.end_get_FRS_ERROR_2:
|
||
or show_errors_sect, show_error_2
|
||
|
||
._end_parse_FRS:
|
||
if DEBUG
|
||
pusha
|
||
mov si, get_type_FS_msg
|
||
call printplain
|
||
popa
|
||
end if
|
||
|
||
|
||
|
||
}
|
||
macro make_FAT_RamFS
|
||
{
|
||
local .RS1
|
||
local .fat12
|
||
local .fat16
|
||
; мы должны сформировать в начальный образ Ram FS, а потом записать его за область выше 1 мб..
|
||
;для случая с FAT12
|
||
; mov di,fat12_buffer ;ds должен быть = cs
|
||
;es:di - указывают на начало блока для формирования рам фс.
|
||
use_RamdiskSector ;возращаемое значение в ax размер сектора в байтах
|
||
cmp ax, 4096;по спецификации значение должно быть в пределах от 1 до 4096
|
||
ja .RS1
|
||
test ax, ax
|
||
jnz @f ;ошибка если сюда прыгнули все таки ...
|
||
|
||
.RS1:
|
||
mov word [fat12_buffer.BPB_BytsPerSec], 512
|
||
;;;;;;;;;;скажем что по дефолту будем юзать значение...
|
||
@@:
|
||
mov word [fat12_buffer.BPB_BytsPerSec], ax;тут все ок
|
||
|
||
;BPB_SecPerClus кол-во секторов в кластере
|
||
use_RamdiskCluster ;возращаемое значение в al
|
||
cmp al, 128
|
||
ja @f
|
||
; test al,0x1 ;проверка на кратность )
|
||
; jnz @f
|
||
|
||
mov byte [fat12_buffer.BPB_SecPerClus], al
|
||
|
||
;incorrect value will be set dafault
|
||
|
||
;ниже некорректное значение в т.к. размер кратен 2 и в диапазоне от 1 до 128 включительно
|
||
; мы должны ругнуться на это
|
||
;@@: ;mov byte [fat12_buffer.BPB_SecPerClus],1
|
||
|
||
;;;;; определеим какая у нас будет использоваться FAT
|
||
;по условию, fat12<4085<=fat16<65525<=fat32
|
||
; fat12_buffer.BPB_BytsPerSec*fat12_buffer.BPB_SecPerClus = кол-во секторов
|
||
movzx eax, word [fat12_buffer.BPB_BytsPerSec]
|
||
movzx ebx, byte [fat12_buffer.BPB_SecPerClus]
|
||
|
||
imul ebx, eax;тут размерность сектора
|
||
mov eax, save_ramdisksize ;размер запрошенного рам диска в байтах
|
||
cdq
|
||
idiv ebx
|
||
;;;;;;;; сейчас частное в eax, а остаток в edx
|
||
;получим кол-во секторов, и можем уже определить тип FAT которую нужно делать.
|
||
cmp eax, 4085
|
||
jb .fat12
|
||
cmp eax, 65525
|
||
jb .fat16
|
||
;;;;;;;;;;;;;;;;;;;;;;;; тут fat32
|
||
mov set_ramfs, 32 ;установим тип файловой системы
|
||
mov word [fat12_buffer.BPB_RsvdSecCnt], 32
|
||
xor eax, eax
|
||
mov word [fat12_buffer.BPB_RootEntCnt], ax
|
||
mov word [fat12_buffer.BPB_TotSec16], ax
|
||
mov dword [fat12_buffer.BPB_TotSec32], eax
|
||
|
||
|
||
.fat16: ;fat16
|
||
;Для FAT12 и FAT16 дисков это поле содержит количество секторов, а BPB_TotSec32 равно 0, если значение <умещается> (меньше 0x10000).
|
||
jmp $
|
||
mov set_ramfs, 16 ;установим тип файловой системы
|
||
movzx ebx, byte [fat12_buffer.BPB_SecPerClus]
|
||
imul eax, ebx
|
||
|
||
cmp eax, 0x10000
|
||
jae @f
|
||
mov word [fat12_buffer.BPB_TotSec16], ax
|
||
mov dword [fat12_buffer.BPB_TotSec32], 0
|
||
@@:
|
||
;количество секторов занимаемое одной копией фат
|
||
; mov word [fat12_buffer.BPB_FATSz16],0x9 ;Для FAT12/FAT16 это количество секторов одной FAT. ??
|
||
;;;; заполним BPB_RootEntCnt Для FAT12 и FAT16 дисков, это поле содержит число
|
||
;32-байтных элементов корневой директории. Для FAT32 дисков, это поле должно
|
||
;быть 0. Пока константа, нужно будет позже доделать.
|
||
mov eax, root_dir_entry_count
|
||
mov word [fat12_buffer.BPB_RootEntCnt], ax ; count of 32-byte dir. entries (224*32 = 14 sectors= 7 kb)
|
||
;по документации рекомендуют отрезать 16 кб для рут дир но это оч много, даже для коос. имхо для начала хватит и 7 кб
|
||
;;;;;;;
|
||
;Для FAT16 это количество секторов одной FAT. Для FAT32 это значение
|
||
;равно 0, а количество секторов одной FAT содержится в BPB_FATSz32.
|
||
;RootDirSectors = ((BPB_RootEntCnt * 32) + (BPB_BytsPerSec - 1)) / BPB_BytsPerSec;
|
||
|
||
;TmpVal1 = DskSize - (BPB_ResvdSecCnt + RootDirSectors);
|
||
;TmpVal2 = (256 * BPB_SecPerClus) + BPB_NumFATs;
|
||
;If(FATType == FAT32)
|
||
; TmpVal2 = TmpVal2 / 2;
|
||
;FATSz = (TMPVal1 + (TmpVal2 - 1)) / TmpVal2;
|
||
;If(FATType == FAT32) {
|
||
; BPB_FATSz16 = 0;
|
||
; BPB_FATSz32 = FATSz;
|
||
;} else {
|
||
; BPB_FATSz16 = LOWORD(FATSz);
|
||
; /* there is no BPB_FATSz32 in a FAT16 BPB */
|
||
;}
|
||
;=====================================
|
||
;RootDirSectors
|
||
movzx ebx, word [fat12_buffer.BPB_BytsPerSec]
|
||
imul eax, 32
|
||
add eax, ebx
|
||
dec eax
|
||
|
||
cdq
|
||
idiv ebx
|
||
;;;;;;;; сейчас частное в eax, а остаток в edx для дискеты 1.44 у нас должно быть значение =14
|
||
;BPB_ResvdSecCnt + RootDirSectors
|
||
movzx ebx, word [fat12_buffer.BPB_RsvdSecCnt]
|
||
add ebx, eax
|
||
|
||
;DskSize у нас это значение уже получено и доступно
|
||
movzx eax, word [fat12_buffer.BPB_TotSec16] ;должен быть в секторах
|
||
sub eax, ebx
|
||
|
||
|
||
;TmpVal1=eax
|
||
shl edi, 8 ;=edi*256
|
||
movzx ecx, byte [fat12_buffer.BPB_NumFATs]
|
||
add edi, ecx
|
||
;TmpVal2=edi
|
||
add eax, edi
|
||
dec eax
|
||
cdq
|
||
idiv edi
|
||
;FATSz = сейчас частное в eax, а остаток в edx
|
||
mov word [fat12_buffer.BPB_FATSz16], ax
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
.fat12: ;fat12
|
||
if DEBUG
|
||
; выведем в отладке, что собираемся делать образ диска c FS=fat12
|
||
pushad
|
||
mov si, start_making_FAT12_msg
|
||
call printplain
|
||
popad
|
||
end if
|
||
|
||
|
||
|
||
;Для FAT12 и FAT16 дисков это поле содержит количество секторов, а BPB_TotSec32 равно 0, если значение <умещается> (меньше 0x10000).
|
||
mov set_ramfs, 12 ;установим тип файловой системы
|
||
movzx ebx, byte [fat12_buffer.BPB_SecPerClus]
|
||
imul eax, ebx
|
||
|
||
cmp eax, 0x10000
|
||
jae @f
|
||
mov word [fat12_buffer.BPB_TotSec16], ax
|
||
mov dword [fat12_buffer.BPB_TotSec32], 0
|
||
@@:
|
||
;количество секторов занимаемое одной копией фат
|
||
; mov word [fat12_buffer.BPB_FATSz16],0x9 ;Для FAT12/FAT16 это количество секторов одной FAT. ??
|
||
;;;; заполним BPB_RootEntCnt Для FAT12 и FAT16 дисков, это поле содержит число
|
||
;32-байтных элементов корневой директории. Для FAT32 дисков, это поле должно
|
||
;быть 0. Пока константа, нужно будет позже доделать.
|
||
mov eax, root_dir_entry_count
|
||
mov word [fat12_buffer.BPB_RootEntCnt], ax ; count of 32-byte dir. entries (224*32 = 14 sectors= 7 kb)
|
||
;по документации рекомендуют отрезать 16 кб для рут дир но это оч много, даже для коос. имхо для начала хватит и 7 кб
|
||
;;;;;;;
|
||
;DskSize(в секторах)*12 (размерность файловой системы, т.е предположим сколько битов потребуется для адресации этого объема) /8 (что получить размер в байтах)
|
||
;полученное число округляем в большую сторону кратное сектору т.е. 512 байт Такой подход не универсален, но пока пойдет
|
||
;вообще у мелкософт это все считается ручками, но мы будем юзать только под коос рам диск с фат12
|
||
movzx eax, word [fat12_buffer.BPB_TotSec16]
|
||
imul eax, 12
|
||
shr eax, 3 ;делим на 8 но т.е. нам нужно делить еще и на 512 или более в зависимости от размеров кластера
|
||
movzx ebx, word [fat12_buffer.BPB_BytsPerSec] ;размер сектора
|
||
cdq
|
||
idiv ebx ;разделим на размер кластера
|
||
;сейчас у нас в eax значение его нужно округлить в большую сторону кратному 512 байтам
|
||
;применим следующее очистим and и добавим 512 байт. таким образом выравним на 512 байт
|
||
;но т.к. все равно делить нижний код нам не нужен
|
||
; and eax,0xfff200
|
||
; add eax,0x200 ;добавим 512 байт для 1.44 дискеты идеально подходит ))
|
||
|
||
inc ax
|
||
;по идее должно на каждую фат таблицу
|
||
;резервироваться 9 секторов т.е. получается 2*9=18+1 =19 секторов т.е. рут дир находиться на с 20 сетора т.е. с адреса 0х2600
|
||
;сейчас нужно вычислить сколько будет секторов занимать фат ) нужно разделить на 512
|
||
;FATSz = сейчас частное в eax
|
||
mov word [fat12_buffer.BPB_FATSz16], ax
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
get_firstDataSector ;получить смещение до данных
|
||
;создадим певую запись в фат по определенному адресу.
|
||
first_create_fat_table
|
||
;закиним BPB файловой системы за 1 мб.
|
||
use_BPB_RAM
|
||
;
|
||
;копирование файла.
|
||
use_RamdiskFile
|
||
|
||
;;;; вычисляем указатель на корневую дир FirstRootDirSecNum = BPB_ResvdSecCnt + (BPB_NumFATs * BPB_FATSz16);
|
||
; movzx ebx, [fat12_buffer.BPB_NumFATs]
|
||
; movzx eax,ax
|
||
; imul eax,ebx
|
||
;eax=(BPB_NumFATs * BPB_FATSz16)
|
||
; inc eax
|
||
; BPB_ResvdSecCnt значение только 1 для fat12/16
|
||
;в eax указатель на root dir. для дискеты fat12 должно получиться при кол-во копий fat 1 = 1+ (1*1) =2 или 3
|
||
|
||
if DEBUG
|
||
pusha
|
||
; mov ax,point_default
|
||
; mov ax,cx
|
||
mov cx, 0x0a
|
||
mov di, show_db1
|
||
; mov dword[ds:di],' '
|
||
; mov word [ds:di+4],' '
|
||
call decode
|
||
;Show size
|
||
mov si, show_db1
|
||
call printplain
|
||
;
|
||
; xor ax,ax
|
||
; int 0x16
|
||
popa
|
||
end if
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
}
|
||
|
||
macro use_RamdiskSector
|
||
{
|
||
;для некоторых FS будет игнорироваться
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
|
||
.start_RamdiskSector:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz .end_RamdiskSector ;нету? ну ладно - следующее значение тогда )
|
||
|
||
cmp al, 'R'
|
||
jnz .start_RamdiskSector
|
||
;проверка на значения RamdiskSize
|
||
; parse_RamdiskSize
|
||
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RamdiskSector
|
||
mov cx, parse_RamdiskSector_e - parse_RamdiskSector
|
||
repe cmpsb
|
||
jnz .RamdiskSector_rest_val ;is not compare
|
||
|
||
sub bx, parse_RamdiskSector_e - parse_RamdiskSector;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
test status_flag, flag_found_RamdiskSector ;оценка флагов
|
||
jz .correct_is_not_set_RamdiskSector
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
.correct_is_not_set_RamdiskSector:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
jcxz .end_get_RamS_ERROR_1 ;not found param
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .start_RamdiskSector ; перейдем на начало и попробуем найти еще секцию
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
xor bx, bx
|
||
mov cx, 4
|
||
@@:
|
||
movzx ax, byte [es:di]
|
||
cmp al, '0'
|
||
jb .end_RamdiskSector
|
||
cmp al, '9'
|
||
ja .end_RamdiskSector
|
||
;;;;;;;;;;;;;;;;;;;
|
||
|
||
imul bx, 10
|
||
xor al, 0x30
|
||
add bx, ax
|
||
|
||
inc di
|
||
|
||
loop @b
|
||
jmp .end_RamdiskSector
|
||
|
||
|
||
.RamdiskSector_rest_val:
|
||
mov cx, bx
|
||
mov di, ax
|
||
jmp .start_RamdiskSector
|
||
.end_get_RamS_ERROR_1:
|
||
|
||
.end_RamdiskSector:
|
||
mov ax, bx
|
||
|
||
if DEBUG
|
||
pusha
|
||
movzx eax, bx;save_cx_d;point_default
|
||
mov cx, 0x0a
|
||
mov di, RamdiskSector_msg
|
||
mov dword[ds:di], ' '
|
||
mov dword [ds:di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, RamdiskSector_msg
|
||
call printplain
|
||
|
||
popa
|
||
end if
|
||
|
||
; pop di
|
||
; pop es
|
||
}
|
||
|
||
macro use_RamdiskCluster
|
||
{
|
||
;для некоторых FS будет игнорироваться
|
||
; push es
|
||
; push di
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
; push ini_data_
|
||
; pop es
|
||
.start_RamdiskCluster:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz .end_RamdiskCluster ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'R'
|
||
jnz .start_RamdiskCluster
|
||
;проверка на значения RamdiskSize
|
||
; parse_RamdiskSize
|
||
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RamdiskCluster
|
||
mov cx, parse_RamdiskCluster_e - parse_RamdiskCluster
|
||
repe cmpsb
|
||
jnz .RamdiskCluster_rest_val ;is not compare
|
||
|
||
sub bx, parse_RamdiskCluster_e - parse_RamdiskCluster;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
test status_flag, flag_found_RamdiskCluster ;оценка флагов
|
||
jz .correct_is_not_set_RamdiskCluster
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
.correct_is_not_set_RamdiskCluster:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
jcxz .end_get_RamSC_ERROR_1 ;not found param
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .start_RamdiskCluster ; перейдем на начало и попробуем найти еще секцию
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
@@:
|
||
movzx ax, byte [es:di]
|
||
cmp al, '0'
|
||
jb .end_RamdiskCluster
|
||
cmp al, '9'
|
||
ja .end_RamdiskCluster
|
||
;;;;;;;;;;;;;;;;;;;
|
||
xor al, 0x30
|
||
|
||
jmp .end_RamdiskCluster
|
||
|
||
|
||
.RamdiskCluster_rest_val:
|
||
mov cx, bx
|
||
mov di, ax
|
||
jmp .start_RamdiskCluster
|
||
.end_get_RamSC_ERROR_1:
|
||
|
||
.end_RamdiskCluster:
|
||
if DEBUG
|
||
pusha
|
||
mov cx, 0x0a
|
||
mov di, RamdiskCluster_msg
|
||
; mov word[ds:di],' '
|
||
call decode
|
||
;Show size
|
||
mov si, RamdiskCluster_msg
|
||
call printplain
|
||
|
||
popa
|
||
end if
|
||
|
||
}
|
||
|
||
macro use_Loader_Image
|
||
;предназначен для загрузки образов выше 1 Мб.
|
||
;первоначальная версия загружает образ дискеты 1.44 мб
|
||
{
|
||
local .start_p_LI
|
||
local .exit
|
||
local .error_LI
|
||
local .rest_value_loop
|
||
local .found_end_str
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
;обработка конструкции типа LoaderModule=kord/kolibri.ldm
|
||
.start_p_LI:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz .exit ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'L'
|
||
jnz .start_p_LI
|
||
;проверка на значение LoaderModule
|
||
; parse_LoaderModule
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_LoaderImage
|
||
mov cx, parse_LoaderImage_e - parse_LoaderImage
|
||
repe cmpsb
|
||
jnz .rest_value_loop ;is not compare
|
||
|
||
sub bx, parse_LoaderImage_e - parse_LoaderImage;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
|
||
; test status_flag,flag_found_LM ;оценка флагов
|
||
; jz .correct_is_not_set_LI
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
;.correct_is_not_set_LI:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
jcxz .rest_value_loop_LI ;not found param timeout
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .rest_value_loop_LI
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
;di указывает на начало блока информации, в cx длинна до конца секции.
|
||
;после загрузки заноситься значение занятой памяти.
|
||
;для того что бы загрузить модуль, воспользуемся callback сервисом
|
||
;оригинальное решение - разместим dd перед строчкой и после строчки разместим byte =0
|
||
;это выглядит так: в ini файле существует строчка LoaderModule = kord/kernel.loader
|
||
;мы ее модифицируем до такого состояния dw,dw,db'kord/kernel.loader',0 конечно сохранив те значения которые мы заменяем
|
||
;сохранили певые 2 word
|
||
push dword [es:di-6]
|
||
lea si, [di-6]
|
||
|
||
push word [es:di-2]
|
||
xor ax, ax
|
||
mov word [es:di-6], ax ;вносим нужные значения
|
||
;info_real_mode_size размер и указатель на область в которую можно загрузиться
|
||
mov ax, info_real_mode_size ;0x3000 ;следующий сегмент за данными
|
||
|
||
|
||
mov word [es:di-4], ax
|
||
mov word [es:di-2], 16 ;кол-во блоков по 4 кб =64 кб т.е. больше не считаем
|
||
;;;;;; поиск конца строчки
|
||
@@:
|
||
mov al, byte [es:di]
|
||
cmp al, ' '
|
||
jz .found_end_str
|
||
cmp al, 0xa
|
||
jz .found_end_str
|
||
cmp al, 0xd
|
||
jz .found_end_str
|
||
inc di
|
||
dec cx
|
||
jnz @b
|
||
;;;not found допустим,что это конец файла и он не имеет привычного заверешния строки
|
||
.found_end_str:
|
||
; чтение блока по 64 кб в сегмент и забрасывание его выше 1 мб.
|
||
push word [es:di]
|
||
xor ax, ax
|
||
mov word [es:di], ax
|
||
; xor ax,ax ; function 1 - read file
|
||
mov di, si ;file_data
|
||
inc ax
|
||
push si
|
||
push es
|
||
call far dword [loader_callback]
|
||
push cs
|
||
pop ds
|
||
|
||
pop es
|
||
pop si
|
||
|
||
test bx, bx
|
||
jnz .error_LM
|
||
|
||
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; забрасывание блока в 64 кб выше 1 мб.
|
||
mov si, table_15_87
|
||
push es
|
||
push ds
|
||
pop es
|
||
mov cx, 256*18
|
||
mov ah, 0x87
|
||
int 0x15
|
||
pop es
|
||
pop dx cx
|
||
test ah, ah
|
||
|
||
|
||
|
||
jmp far dword [es:si]
|
||
|
||
|
||
|
||
|
||
.rest_value_loop:
|
||
mov di, ax
|
||
mov cx, bx
|
||
jmp .start_p_LI
|
||
|
||
.exit:
|
||
|
||
|
||
|
||
}
|
||
|
||
|
||
|
||
macro name_in_root_fat
|
||
;макрос, который записывает информацию о загруженном файле в корневую фат таблицу
|
||
{
|
||
|
||
}
|
||
|
||
|
||
|
||
macro use_RamdiskFile
|
||
{
|
||
;загрузка файлов с использование callback сервиса первичного загрузчика
|
||
;используется только для загрузки необходимых и небольших файлов, т.к. достаточно медленно работает
|
||
;для загрузки использует 0х87 функцию int 0x15 прерывания - загрузка блоков данных до 64 кб выше 1 мб
|
||
local .start_loop
|
||
local ._end
|
||
local .rest_value_loop
|
||
local .error
|
||
mov di, point_default ;restore value
|
||
mov cx, save_cx_d
|
||
mov data_offset, 0 ;clean offset
|
||
;обработка конструкции типа LoaderModule=kord/kolibri.ldm
|
||
.start_loop:
|
||
call get_firs_sym ;get first symbol on new line
|
||
test cx, cx
|
||
jz ._end ;нету? ну ладно - следующее значение тогда )
|
||
cmp al, 'R'
|
||
jnz .start_loop
|
||
;проверка на значение RamdiskFile
|
||
mov bx, cx
|
||
mov ax, di
|
||
|
||
mov si, parse_RamdiskFile
|
||
mov cx, parse_RamdiskFile_e - parse_RamdiskFile
|
||
repe cmpsb
|
||
jnz .rest_value_loop ;is not compare
|
||
|
||
sub bx, parse_RamdiskFile_e - parse_RamdiskFile;correct cx
|
||
add bx, cx
|
||
mov cx, bx
|
||
; test status_flag,flag_found_LM ;оценка флагов
|
||
; jz .correct_is_not_set_LM
|
||
|
||
; mov si,found_equal_timeout ;мы нашли что флаг уже установлен, информируем
|
||
; call printplain
|
||
; jmp .get_next_str
|
||
|
||
;.correct_is_not_set_LM:
|
||
mov ax, 0x3d20 ;cut al=' ' ah='='
|
||
repe scasb
|
||
test ecx, ecx
|
||
jz .rest_value_loop ;not found param timeout
|
||
|
||
cmp ah, byte [es:di-1] ;find '='
|
||
jnz .rest_value_loop
|
||
|
||
repe scasb ;cut ' '
|
||
inc cx
|
||
dec di
|
||
|
||
mov save_di_RAMDISK, di
|
||
mov save_cx_RAMDISK, cx
|
||
;di указывает на начало блока информации, в cx длинна до конца секции.
|
||
;после загрузки заноситься значение занятой памяти.
|
||
;для того что бы загрузить модуль, воспользуемся callback сервисом
|
||
;оригинальное решение - разместим dd перед строчкой и после строчки разместим byte =0
|
||
;это выглядит так: в ini файле существует строчка RamdiskFile = @menu,@menu
|
||
;мы ее модифицируем до такого состояния dw,dw,db'@menu',0 конечно сохранив те значения которые мы заменяем
|
||
;сохранили певые 2 word
|
||
|
||
;
|
||
@@:
|
||
mov al, byte [es:di]
|
||
cmp al, ',' ; т.е. ищем разделитель
|
||
jz .found_end_str
|
||
inc di
|
||
dec cx
|
||
jnz @b
|
||
;;;not found допустим,что это конец файла и он не имеет привычного завершения строки
|
||
.found_end_str:
|
||
; mov al,byte [es:di]
|
||
; cmp al,' ' ; убираем пробелы, если они есть
|
||
; jnz @f
|
||
; inc di
|
||
; dec cx
|
||
; jnz .found_end_str
|
||
|
||
;@@:
|
||
mov point_to_dest_file_name, di
|
||
inc di
|
||
;проверка индивидуальности имени файла
|
||
check_name_file
|
||
;/restore di - point and cx -size section
|
||
mov di, save_di_RAMDISK
|
||
mov cx, save_cx_RAMDISK
|
||
|
||
test al, al
|
||
jnz .start_loop ;если в al значение не =0, то такое имя уже существует в системе.
|
||
|
||
|
||
|
||
push dword [es:di-6]
|
||
lea si, [di-6]
|
||
|
||
push word [es:di-2]
|
||
push di
|
||
xor ax, ax
|
||
mov word [es:di-6], ax ;вносим нужные значения
|
||
;info_real_mode_size размер и указатель на область в которую можно загрузиться
|
||
mov ax, info_real_mode_size ;0x3000 ;следующий сегмент за данными
|
||
|
||
|
||
mov word [es:di-4], ax
|
||
mov word [es:di-2], 16 ;кол-во блоков по 4 кб =64 кб т.е. больше не читаем
|
||
|
||
mov di, point_to_dest_file_name
|
||
|
||
if DEBUG
|
||
pushad
|
||
; mov ax,di
|
||
mov cx, 0x0a
|
||
mov di, name_of_seg_get_64
|
||
mov dword[ds:di], ' '
|
||
mov word[ds:di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, name_of_seg_get_64
|
||
call printplain
|
||
|
||
popad
|
||
end if
|
||
|
||
push word [es:di]
|
||
push cx
|
||
xor ax, ax
|
||
mov word [es:di], ax
|
||
; xor ax,ax ; function 1 - read file
|
||
push di
|
||
mov di, si ;file_data
|
||
inc ax
|
||
push si
|
||
push es
|
||
push bp
|
||
|
||
push es
|
||
pop ds
|
||
push cs
|
||
pop es
|
||
|
||
call far dword [es:loader_callback]
|
||
|
||
|
||
push cs
|
||
pop ds
|
||
|
||
pop bp
|
||
pop es
|
||
pop si
|
||
|
||
cmp bx, 2
|
||
ja .error
|
||
; сейчас у нас в dx:ax размер файла, который мы загрузили.
|
||
; возможна ситуация, когда в bx=1 т.е. есть еще данные на диске
|
||
mov status_flag_loader_f, bx
|
||
|
||
shl edx, 16
|
||
mov dx, ax
|
||
; shr edx,10 ;размер файла в кб.
|
||
;;в edx размер в байтах.
|
||
mov save_file_size, edx
|
||
mov eax, edx
|
||
;восстановим полностью файл сценария
|
||
pop di
|
||
pop cx ;длинна остатка с 2-ой частью имени т.е. с именем назначением.
|
||
pop word [es:di]
|
||
pop di
|
||
pop word [es:di-2]
|
||
pop dword [es:di-6]
|
||
|
||
|
||
if DEBUG
|
||
pushad
|
||
mov cx, 0x0a
|
||
mov di, RamdiskFile_msg
|
||
mov dword[ds:di], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, RamdiskFile_msg
|
||
call printplain
|
||
|
||
popad
|
||
end if
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
; загрузим чему у нас равен кластер
|
||
; mov ax,word [fat12_buffer.BPB_BytsPerSec] ;кол-во байтов в секторе может быть любое 512 1024 2048 4096 2 байта
|
||
; movzx bx,byte [fat12_buffer.BPB_SecPerClus] ;кол-во секторов в кластере
|
||
; imul ax,bx
|
||
;сейчас в eax размер кластера (512) байт
|
||
;в edx длина файла в байтах до 64 кб
|
||
;закиним файл за 1 мб
|
||
;1 нам нужно составить фат таблицу т.е. произвести разметку рамдиска, затем перенесем по адресу файл
|
||
|
||
;записать инфорамацию о файле в корневую директорию
|
||
register_file_in_fat
|
||
;перенести за 1 мб содержимое файла
|
||
move_file_up
|
||
|
||
;проверим, загружен ли до конца файл? т.е. если размер файла больше чем 64 кб, то будет подгружать оставшиеся блоки
|
||
cmp status_flag_loader_f, 0x1
|
||
jnz @f
|
||
;нужно дозагузить данные файла и перенести их за 1-ый мб согласно фат структуре
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
@@:
|
||
;тут организован цикл по загрузке файлов в корневую директорию
|
||
mov di, save_di_RAMDISK
|
||
mov cx, save_cx_RAMDISK
|
||
if DEBUG
|
||
pusha
|
||
xor ax, ax
|
||
int 0x16
|
||
popa
|
||
end if
|
||
|
||
|
||
jmp .start_loop
|
||
|
||
|
||
.error:
|
||
;call error.LoaderModule
|
||
;fixme!
|
||
.rest_value_loop:
|
||
mov di, ax
|
||
mov cx, bx
|
||
jmp .start_loop
|
||
|
||
._end:
|
||
;перенесем за 1-ый мб фат и рут дир
|
||
move_up_fat_and_root_d
|
||
|
||
|
||
|
||
|
||
|
||
|
||
;загрузка блока
|
||
; mov ah,0x87
|
||
; mov cx, ;size in byte
|
||
|
||
|
||
;es:si point to descripts
|
||
|
||
|
||
}
|
||
|
||
macro use_BPB_RAM ;закинуть самые первые 512 байт за 1-й мб
|
||
;данный макрос закидывает BPB структуру т.е. первые 512 байт, пока только фат12 за 1 мб
|
||
{
|
||
mov ax, fat12_buffer
|
||
mov si, table_15_87
|
||
add word [si+8*2+2], ax
|
||
push es
|
||
push ds
|
||
pop es
|
||
mov cx, 256 ;бут сектор укладывается в 512 байт 512/2=256
|
||
mov ah, 0x87
|
||
int 0x15
|
||
pop es
|
||
;add 512 byte for destination adress
|
||
; add dword [si+8*3+2], 512
|
||
; test ah, ah
|
||
; jz
|
||
if DEBUG
|
||
pusha
|
||
mov ax, word [si+8*2+2]
|
||
mov cx, 0x0a
|
||
mov di, BPB_msg
|
||
call decode
|
||
;Show size
|
||
mov si, BPB_msg
|
||
call printplain
|
||
popa
|
||
end if
|
||
}
|
||
macro first_create_fat_table
|
||
;данный макрос создает оформляет 3 первых байта fat таблицы, и устанавливает указатель на следующий блок, и вносит 0 значение
|
||
;для смещения в корневой таблице.
|
||
{
|
||
mov al, byte [fat12_buffer.BPB_Media]
|
||
|
||
|
||
push ds
|
||
|
||
|
||
mov di, info_real_mode_size
|
||
add di, 0x1000
|
||
|
||
if DEBUG
|
||
pushad
|
||
|
||
mov ax, info_real_mode_size
|
||
add ax, 0x1000
|
||
; mov ax,ds
|
||
mov cx, 0xa
|
||
|
||
mov di, first_entry_in_fat
|
||
mov dword [di], ' '
|
||
mov word [di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, first_entry_in_fat
|
||
call printplain
|
||
|
||
xor ax, ax
|
||
int 0x16
|
||
|
||
popad
|
||
end if
|
||
|
||
|
||
push di ; push word info_real_mode_size+0x1000 ;cледующий сегмент за загруженным участком
|
||
|
||
xor di, di
|
||
mov point_to_free_root, di ;значение смещения =0 в корневой фат таблице описания
|
||
|
||
pop ds ; загружен следующий сегмент т.е. пустой сегмент
|
||
|
||
mov byte [di], al
|
||
or ax, -1
|
||
inc di
|
||
mov word [di], ax
|
||
|
||
pop ds
|
||
mov point_next_fat_str, 3
|
||
|
||
if DEBUG
|
||
pushad
|
||
mov ax, point_next_fat_str
|
||
mov cx, 0x0a
|
||
mov di, fat_create_msg
|
||
call decode
|
||
;Show size
|
||
mov si, fat_create_msg
|
||
call printplain
|
||
popad
|
||
end if
|
||
|
||
}
|
||
macro register_file_in_fat
|
||
;макрос регистрации файла в файловой структуре Fat
|
||
;пока поддерживается только фат12, пока ))
|
||
;вычисление смежных кластеров и занесение инфы в fat/
|
||
{
|
||
local .step2
|
||
local .step3
|
||
local .end
|
||
local .eof_file
|
||
|
||
;di point on root dir на фри секцию.
|
||
push es
|
||
|
||
mov ax, info_real_mode_size
|
||
add ax, 0x1000
|
||
mov es, ax ; push word info_real_mode_size+0x1000 ;сегмент следующий за загруженным блоком в 64 кб
|
||
|
||
; определяем тип фат пока не определяем, пока только фат 12
|
||
; 12 бит, для вычесления соседних каластеров.
|
||
mov di, firstDataSect ;в секторах
|
||
sub di, size_root_dir
|
||
;теперь в ax размер в секторах начала рут дир
|
||
shl di, 9;imul 512
|
||
add di, point_to_free_root ;смещение в уже записанных 32-х структурах.
|
||
;необходимо внести значение в рут дир т.е. 32 байта
|
||
if DEBUG
|
||
pushad
|
||
; mov ax,point_default
|
||
; mov ax,
|
||
mov cx, 0x0a
|
||
mov di, show_db2
|
||
mov dword[ds:di], ' '
|
||
mov word [ds:di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, show_db2
|
||
call printplain
|
||
;
|
||
; xor ax,ax
|
||
; int 0x16
|
||
popad
|
||
end if
|
||
|
||
|
||
|
||
;gs:di - указатель для внесения инфорации в рут область фат таблицы инормации о файле.
|
||
mov si, shot_name_fat
|
||
mov cx, 11
|
||
;запишем в структуру имя
|
||
@@:
|
||
lodsb
|
||
stosb
|
||
loop @b
|
||
|
||
;запишем атрибуты файла и DIR_NTRes - зарезеврированный байт =0
|
||
xor ax, ax
|
||
mov ah, ATTR_VOLUME_ID
|
||
mov word [es:di], ax
|
||
add di, 2
|
||
;DIR_CrtTimeTenth
|
||
mov byte [es:di], 100
|
||
inc di
|
||
;DIR_CrtTime
|
||
mov word [es:di], 0x032b ;дата
|
||
add di, 2
|
||
;DIR_CrtDate
|
||
mov word [es:di], 0x0 ;время ><
|
||
add di, 2
|
||
;DIR_LstAccDate
|
||
mov word [es:di], 0x032b ;дата моего
|
||
add di, 2
|
||
;DIR_FstClusHI
|
||
mov word [es:di], 0x0 ;время для фат12 /16 всегда 0
|
||
add di, 2
|
||
;DIR_WrtTime
|
||
mov word [es:di], 0x0 ;время ><
|
||
add di, 2
|
||
;DIR_WrtDate
|
||
mov word [es:di], 0x032b
|
||
add di, 2
|
||
|
||
mov ax, point_next_fat_str
|
||
mov word [es:di], ax
|
||
add di, 2
|
||
|
||
push di
|
||
;DIR_FstClusLO Младшее слово номера первого кластера.
|
||
; mov ax,point_next_fat_str ;загрузим указатель на элемент фат таблицы т.е. это номер фат записи
|
||
;FATOffset = N + (N / 2) т.е. это уже у нас смещение мы знаем что -начинается все с 3-го элемента записи фат
|
||
mov bx, ax
|
||
shr bx, 1
|
||
add ax, bx
|
||
;в ах сейчас FATOffset
|
||
;ThisFATEntOffset = BPB_ResvdSecCnt + (FATOffset / BPB_BytsPerSec);
|
||
mov bx, word [fat12_buffer.BPB_BytsPerSec]
|
||
cwd
|
||
idiv bx
|
||
;ax=ThisFATEntOffset= rem (FATOffset / BPB_BytsPerSec) четный или нечетный указатель.
|
||
mov si, ax
|
||
;нам нужно в цикле записать все кластеры которые будут использованы для размещения файла.
|
||
;узнаем размер кластера.
|
||
movzx eax, word [fat12_buffer.BPB_BytsPerSec]
|
||
movzx ebx, byte [fat12_buffer.BPB_SecPerClus]
|
||
imul eax, ebx
|
||
;ax - размер кластера.
|
||
;сейчас будем записывать во временный буфер фат таблицу для выбранного файла. Поскольку мы его загрузили возможно не полностью
|
||
;мы обработаем запись для фат полностью, в не зависимости от предела буфера где возможна часть файла.
|
||
mov ebx, save_file_size ;размер файла в байтах
|
||
|
||
@@:
|
||
sub ebx, eax
|
||
cmp ebx, eax
|
||
jbe .eof_file
|
||
|
||
inc point_next_fat_str
|
||
mov cx, point_next_fat_str ;загрузим указатель на элемент фат таблицы т.е. это номер фат записи
|
||
;FATOffset = N + (N / 2) т.е. это уже у нас смещение мы знаем что -начинается все с 3-го элемента записи фат
|
||
mov dx, ax
|
||
shr dx, 1
|
||
add cx, dx
|
||
|
||
|
||
|
||
test si, 0x1
|
||
jz .step2
|
||
shl cx, 4
|
||
mov word[es:si], cx
|
||
inc si
|
||
add cx, ax
|
||
jmp @b
|
||
|
||
.step2:
|
||
and cx, 0x0FFF
|
||
mov word[es:si], cx
|
||
inc si
|
||
add cx, ax
|
||
jmp @b
|
||
|
||
.eof_file:
|
||
mov cx, 0x0fff
|
||
test si, 0x1
|
||
jz .step3
|
||
shl cx, 4
|
||
mov word[es:si], cx
|
||
jmp .end
|
||
|
||
.step3:
|
||
and cx, 0x0FFF
|
||
mov word[es:si], cx
|
||
|
||
.end:
|
||
inc point_next_fat_str
|
||
|
||
pop di
|
||
;DIR_FileSize 32-битный DWORD содержит размер файла в байтах.
|
||
mov eax, save_file_size
|
||
mov dword [es:di], eax
|
||
|
||
if DEBUG
|
||
pushad
|
||
|
||
mov di, firstDataSect ;в секторах
|
||
sub di, size_root_dir
|
||
;теперь в ax размер в секторах начала рут дир
|
||
shl di, 9;imul 512
|
||
add di, point_to_free_root ;смещение в уже записанных 32-х структурах.
|
||
|
||
push di
|
||
|
||
mov si, dest_name_fat
|
||
mov cx, 11
|
||
|
||
;запишем в структуру имя
|
||
@@:
|
||
mov al, byte [es:di]
|
||
inc di
|
||
mov byte [ds:si], al
|
||
inc si
|
||
loop @b
|
||
|
||
mov di, si
|
||
inc di
|
||
pop ax
|
||
mov cx, 0xa
|
||
call decode
|
||
|
||
mov si, dest_name_fat
|
||
call printplain
|
||
popad
|
||
|
||
END IF
|
||
|
||
|
||
|
||
|
||
|
||
add point_to_free_root, 32 ;увелицим смещение до следующего значения.
|
||
pop es
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
macro get_firstDataSector
|
||
;макрос для вычисления певого сектора данных т.е. данных файлов в фате
|
||
;вычислим FirstDataSector = BPB_ResvdSecCnt + (BPB_NumFATs * FATSz) + RootDirSectors;
|
||
{
|
||
mov ax, word [fat12_buffer.BPB_FATSz16]
|
||
movzx bx, byte [fat12_buffer.BPB_NumFATs]
|
||
imul ax, bx ;9x1=9
|
||
;ax=BPB_NumFATs * FATSz
|
||
mov bx, word [fat12_buffer.BPB_RootEntCnt] ; count of 32-byte dir. entries (224*32 = 14 sectors= 7 kb)
|
||
shr bx, 4 ;imul bx,32 and then div 512 -> in bx size in sectors
|
||
add ax, bx ;9+14=23
|
||
mov size_root_dir, bx
|
||
movzx bx, byte [fat12_buffer.BPB_RsvdSecCnt] ;add 1 for fat 16/12
|
||
add ax, bx
|
||
;ax=firstDataSector - где начинается первый секторо от 0 сектора в секторах. - фактически = 24 сектор
|
||
mov firstDataSect, ax ;сохраним для вычисления
|
||
; получимзначение кластеров, это объем в который мы можем записать данные
|
||
mov bx, word [fat12_buffer.BPB_TotSec16]
|
||
sub bx, ax
|
||
mov ax, bx
|
||
movzx bx, byte [fat12_buffer.BPB_SecPerClus]
|
||
cwd
|
||
idiv bx
|
||
mov DataClasters, ax
|
||
|
||
if DEBUG
|
||
pushad
|
||
mov ax, firstDataSect ;первый сектор данных
|
||
mov cx, 0x0a
|
||
mov di, firstDataSect_msg
|
||
call decode
|
||
;Show size
|
||
mov si, firstDataSect_msg
|
||
call printplain
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
mov ax, size_root_dir ;размер рут дир в сетокторах
|
||
mov cx, 0x0a
|
||
mov di, size_root_dir_msg
|
||
call decode
|
||
;Show size
|
||
mov si, size_root_dir_msg
|
||
call printplain
|
||
;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||
mov ax, DataClasters;кластеры
|
||
mov cx, 0x0a
|
||
mov di, DataClasters_msg
|
||
call decode
|
||
;Show size
|
||
mov si, DataClasters_msg
|
||
call printplain
|
||
popad
|
||
|
||
end if
|
||
|
||
}
|
||
|
||
macro use_RamdiskPATHS
|
||
;парсинг пути источника файлов.
|
||
{
|
||
|
||
}
|
||
|
||
macro use_RamdiskPATHD
|
||
;парсинг пути назначения файлов.
|
||
{
|
||
|
||
}
|
||
macro check_name_file
|
||
;макрос проверки имени на повтор, имя должно быть уникальным.
|
||
;входные данные: es- сегмент где лежит файл для парсинга т.е. startos.ini
|
||
;di - указатель на имя файла т.е. es:di указывает на имя файла назначения
|
||
;выходные данные eax =-1 имя совпало, eax=0 имя не совпало.
|
||
{
|
||
local .no_equal
|
||
local .exit
|
||
local .loop_size_root_dir
|
||
;вычислим длинну строчки имени назначения, которую будем сравнивать с уже записанными данными.
|
||
;преобразуем в аналог фат записи сточку с именем назначения
|
||
convertion_file_name ; преобразовали имя по нужным правилам
|
||
test ax, ax
|
||
jnz .exit
|
||
|
||
lea si, [shot_name_fat] ; desination name of file
|
||
|
||
;вычислим указатель на корневую директорию
|
||
mov di, firstDataSect
|
||
sub di, size_root_dir
|
||
;теперь в ax размер в секторах начала рут дир
|
||
shl di, 9;imul 512
|
||
;di= Это смещение от начала буфера до рут директории. в пределах 64 кб.
|
||
;загрузим значение - т.е. кол-во элементов, которые мы можем просматривать.
|
||
mov dx, root_dir_entry_count
|
||
|
||
mov ax, info_real_mode_size
|
||
add ax, 0x1000
|
||
|
||
|
||
mov gs, ax
|
||
.loop_size_root_dir:
|
||
DEBUG1 equ 0
|
||
if DEBUG1
|
||
pushad
|
||
push di
|
||
mov eax, dword[gs:di]
|
||
lea si, [check_root_fat_+14]
|
||
mov dword [ds:si], '----'
|
||
mov dword [ds:si+4], '----'
|
||
mov dword [ds:si+8], '----'
|
||
mov dword[ds:si], eax
|
||
mov eax, dword[gs:di+4]
|
||
mov dword[ds:si+4], eax
|
||
mov eax, dword[gs:di+8]
|
||
mov dword[ds:si+8], eax
|
||
|
||
;
|
||
xor eax, eax
|
||
mov ax, gs;point_next_fat_str
|
||
mov cx, 0x0a
|
||
mov di, check_root_fat_
|
||
mov dword [di], ' '
|
||
mov word [di+4], ' '
|
||
call decode
|
||
xor eax, eax
|
||
pop ax
|
||
mov di, (check_root_fat_+7)
|
||
mov dword [di], ' '
|
||
mov word [di+4], ' '
|
||
call decode
|
||
|
||
;Show size
|
||
lea si, [check_root_fat_]
|
||
call printplain
|
||
|
||
lea si, [shot_name_fat]
|
||
call printplain
|
||
|
||
xor ax, ax
|
||
int 0x16
|
||
popad
|
||
end if
|
||
|
||
xor bx, bx
|
||
mov cx, 11 ;size of name in struct FAT
|
||
|
||
@@:
|
||
mov al, byte [ds:si+bx] ;ds:si - point to name of convertion variable.
|
||
mov ah, byte [gs:di+bx] ;gs:di - point to name in fat struct
|
||
inc bx
|
||
|
||
if DEBUG
|
||
; pushad
|
||
; lea si,[check_root_fat_+14]
|
||
; mov dword [ds:si],'----'
|
||
; mov word [ds:si],ax
|
||
; call printplain
|
||
|
||
; xor ax,ax
|
||
; int 0x16
|
||
|
||
; popad
|
||
end if
|
||
|
||
|
||
|
||
cmp ah, al
|
||
jnz .no_equal
|
||
|
||
; dec cx
|
||
; jnz @b
|
||
loop @b
|
||
|
||
;.succesfuly:
|
||
;печально, такое имя уже имеется :(
|
||
or ax, -1
|
||
jmp .exit
|
||
|
||
|
||
.no_equal:
|
||
add di, 32 ;fat struct =32 byte
|
||
dec dx
|
||
jnz .loop_size_root_dir
|
||
|
||
;.exit_check_name:
|
||
and ax, 0
|
||
|
||
.exit:
|
||
|
||
if DEBUG
|
||
pushad
|
||
;Show size
|
||
lea si, [check_name_fat_msg_n]
|
||
test ax, ax
|
||
jz @f
|
||
lea si, [check_name_fat_msg_y]
|
||
call printplain
|
||
lea si, [alarm_msg]
|
||
@@:
|
||
call printplain
|
||
popad
|
||
end if
|
||
|
||
}
|
||
|
||
|
||
macro convertion_file_name
|
||
;макрос конвертации имени, это нужно поскольку формат представленный не соответсвует фат и напрямую редко можно когда использовать
|
||
;преобразование имени типа hello.asm в 'HELLO ASM', в соответствии с правилами fat.
|
||
;входные параметры es:di указатель на имя файла которое нужно преобразовать, конечный буфер shot_name_fat
|
||
{
|
||
local .next_step
|
||
local .error
|
||
local .st1
|
||
local .st2
|
||
local .st2_l
|
||
local .st3
|
||
local .st4_s
|
||
local .st4
|
||
local .st5
|
||
|
||
;вычислим длинну строчки имени назначения, которую будем сравнивать с уже записанными данными.
|
||
; mov di,point_to_dest_file_name входной параметр
|
||
mov si, shot_name_fat
|
||
or first_input, -1 ;при первом входе устанавливаем флаг
|
||
mov cx, 11 ;длинна имени в стуктуре фат таблицы
|
||
|
||
@@:
|
||
mov al, byte [es:di]
|
||
cmp al, 0xa
|
||
jz .st4_s
|
||
cmp al, 0xd
|
||
jz .st4_s
|
||
cmp al, 0x20
|
||
jz .st4_s
|
||
|
||
cmp al, 0x20
|
||
jb .error
|
||
cmp al, 0x22
|
||
jz .error
|
||
cmp al, 0x2a
|
||
jz .error
|
||
cmp al, 0x2b
|
||
jz .error
|
||
cmp al, 0x2c
|
||
jz .error
|
||
cmp al, 0x2F
|
||
jz .error
|
||
|
||
cmp al, 0x3a
|
||
jz .error
|
||
cmp al, 0x3b
|
||
jz .error
|
||
cmp al, 0x3c
|
||
jz .error
|
||
cmp al, 0x3d
|
||
jz .error
|
||
cmp al, 0x3E
|
||
jz .error
|
||
cmp al, 0x3F
|
||
jz .error
|
||
|
||
cmp al, 0x5b
|
||
jz .error
|
||
cmp al, 0x5c
|
||
jz .error
|
||
cmp al, 0x5d
|
||
jz .error
|
||
|
||
cmp al, 0x7c
|
||
jz .error
|
||
|
||
|
||
cmp first_input, -1
|
||
jnz .next_step
|
||
and first_input, 0 ;сборосим флаг.
|
||
cmp al, '.'
|
||
jz .error ;обработка точки, файл не может начинаться с точки
|
||
|
||
.next_step:
|
||
cmp al, 0x2e
|
||
jnz .st2 ;обработка точки, в середине файла
|
||
;тут у нас установлен разделитель
|
||
;все остальнео место займут пробелы
|
||
mov al, ' '
|
||
|
||
;!fixme обработаны не все исключения :(
|
||
cmp cl, 3 ;формат файла такой GIDGIDIIASM т.е. gidgidii.asm
|
||
jbe .st2
|
||
|
||
|
||
.st3:
|
||
mov byte [si], al
|
||
inc si
|
||
dec cx
|
||
cmp cx, 3
|
||
ja .st3
|
||
; inc cx
|
||
inc di
|
||
jmp @b
|
||
|
||
.st2:
|
||
cmp al, 0x60
|
||
jbe .st2_l
|
||
|
||
xor al, 0x20;сделаем заглавные буквы
|
||
.st2_l:
|
||
mov byte [si], al
|
||
inc di
|
||
inc si
|
||
; dec cx
|
||
; jnz @b
|
||
loop @b
|
||
.st5:
|
||
xor ax, ax
|
||
jmp @f
|
||
|
||
;;;;;;;;файл закончился, и нужно внести в конец пробелы
|
||
.st4_s:
|
||
mov al, ' '
|
||
.st4:
|
||
mov byte [si], al
|
||
inc si
|
||
loop .st4
|
||
jmp .st5
|
||
|
||
.error:
|
||
or ax, -1
|
||
@@:
|
||
|
||
if DEBUG
|
||
pushad
|
||
|
||
mov si, convertion_file_name_msg_y
|
||
test ax, ax
|
||
jz @f
|
||
mov si, convertion_file_name_msg_n
|
||
@@:
|
||
call printplain
|
||
|
||
mov si, shot_name_fat
|
||
mov byte [si+12], 0
|
||
call printplain
|
||
popad
|
||
|
||
end if
|
||
}
|
||
|
||
macro move_file_up
|
||
;макрос который перемещает за 1 мб с правилами фат данные файла.
|
||
{
|
||
local .st1
|
||
local .correct_on_byte
|
||
;сейчас имеет быть ситуация, когда BPB уже перемещен за 1 мб, фат, и рут дир будут позже перемещены,
|
||
;а нам нужно вычислить место, и перенести туда содержимое файла
|
||
;полученое значение указывает в байтах на начало данных
|
||
|
||
mov ax, info_real_mode_size ; сегмент где расположены данные
|
||
mov si, table_15_87
|
||
mov word [si+8*2+2], ax
|
||
;смещение до данных уже за 1-м мб
|
||
movzx eax, firstDataSect
|
||
movzx edx, data_offset
|
||
add eax, edx
|
||
|
||
movzx ebx, word [fat12_buffer.BPB_BytsPerSec]
|
||
movzx edx, byte [fat12_buffer.BPB_SecPerClus]
|
||
imul bx, dx ;получим размер кластера
|
||
|
||
|
||
|
||
push ebx ;save bx
|
||
|
||
imul eax, ebx
|
||
; shl eax,9 ;умножим на 512
|
||
|
||
if DEBUG
|
||
pushad
|
||
xor eax, eax
|
||
mov ax, info_real_mode_size
|
||
mov cx, 0x0a
|
||
mov di, seg_where_get_data
|
||
mov dword [di], ' '
|
||
mov word [di+4], ' '
|
||
call decode
|
||
;Show size
|
||
mov si, seg_where_get_data
|
||
call printplain
|
||
popad
|
||
|
||
end if
|
||
|
||
; mov bx,word [fat12_buffer.BPB_BytsPerSec]
|
||
; movzx dx,byte [fat12_buffer.BPB_SecPerClus]
|
||
; imul bx,dx
|
||
; cwd
|
||
; idiv bx
|
||
|
||
mov dl, 0x10
|
||
|
||
@@:
|
||
cmp eax, 0x00010000
|
||
jb @f
|
||
|
||
sub eax, 0x00010000
|
||
inc dl
|
||
jmp @b
|
||
|
||
|
||
@@:
|
||
mov byte [si+8*3+3], dl ;куда писать
|
||
mov word [si+8*3+2], ax
|
||
|
||
mov ecx, save_file_size ;размер файла в байтах.
|
||
cmp ecx, 0x0000ffff ;размер блока т.е. 64 кб
|
||
jbe .correct_on_byte ;корректировка на байт значения
|
||
|
||
|
||
|
||
mov ecx, 0x00010000 ;65536
|
||
sub save_file_size, ecx ;отнимим
|
||
; jmp .st1 ;получим 0х8000
|
||
|
||
|
||
|
||
|
||
;корректировка значения должна быть выполенена на размер кластера
|
||
.correct_on_byte:
|
||
;/узнаем размер кластера
|
||
pop eax ;restore size of claster
|
||
push ecx
|
||
@@:
|
||
inc data_offset
|
||
|
||
cmp eax, ecx
|
||
jae @f
|
||
sub ecx, eax
|
||
jmp @b
|
||
@@:
|
||
pop ecx
|
||
|
||
|
||
|
||
|
||
test ecx, 0x1
|
||
jz .st1
|
||
inc ecx
|
||
.st1:
|
||
shr ecx, 1 ; преобразовать значение для 0x87 function
|
||
|
||
;перенесем блок за 1 мб
|
||
push es
|
||
push ds
|
||
pop es
|
||
|
||
mov ah, 0x87
|
||
int 0x15
|
||
pop es
|
||
|
||
if DEBUG
|
||
pusha
|
||
; mov ax,point_next_fat_str
|
||
mov cx, 0x0a
|
||
mov di, return_code_af_move
|
||
call decode
|
||
;Show size
|
||
mov si, return_code_af_move
|
||
call printplain
|
||
popa
|
||
|
||
end if
|
||
|
||
}
|
||
|
||
|
||
macro move_up_fat_and_root_d
|
||
;макрос, который позволяет перенести выше 1 мб в структуру образа фат таблицу и рут директорию
|
||
{
|
||
local .st1
|
||
|
||
mov ax, info_real_mode_size
|
||
add ax, 0x1000
|
||
|
||
mov si, table_15_87
|
||
mov word [si+8*2+2], ax
|
||
;смещение до данных
|
||
mov ax, 512
|
||
mov word [si+8*3+2], ax
|
||
;fixme! тут необходимо сделать подержку т.е. формировать смещение файла в уже записанных данных.
|
||
|
||
movzx ecx, word [fat12_buffer.BPB_FATSz16]
|
||
movzx bx, byte [fat12_buffer.BPB_NumFATs]
|
||
imul cx, bx ;9x1=9
|
||
|
||
add cx, size_root_dir ;размер корневой дирректории
|
||
shl ecx, 9 ;imul 512
|
||
|
||
|
||
;корректировка значения
|
||
test ecx, 0x1
|
||
jz .st1
|
||
inc ecx
|
||
.st1:
|
||
shr ecx, 1
|
||
|
||
push es
|
||
push ds
|
||
pop es
|
||
|
||
mov ah, 0x87
|
||
int 0x15
|
||
pop es
|
||
|
||
if DEBUG
|
||
pusha
|
||
; mov ax,point_next_fat_str
|
||
mov cx, 0x0a
|
||
mov di, return_code_af_fat_m
|
||
call decode
|
||
;Show size
|
||
mov si, return_code_af_fat_m
|
||
call printplain
|
||
popa
|
||
|
||
end if
|
||
|
||
}
|