| 0,0 → 1,816 |
|---|
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;; 23.01.2010 turbanoff - read from ext2fs ;; |
| ;; ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| |
| $Revision$ |
| |
| EXT2_BAD_INO = 1 |
| EXT2_ROOT_INO = 2 |
| EXT2_ACL_IDX_INO = 3 |
| EXT2_ACL_DATA_INO = 4 |
| EXT2_BOOT_LOADER_INO= 5 |
| EXT2_UNDEL_DIR_INO = 6 |
| |
| ;type inode |
| EXT2_S_IFREG = 0x8000 |
| EXT2_S_IFDIR = 0x4000 |
| ;user inode right's |
| EXT2_S_IRUSR = 0x0100 |
| EXT2_S_IWUSR = 0x0080 |
| EXT2_S_IXUSR = 0x0040 |
| ;group inode right's |
| EXT2_S_IRGRP = 0x0020 |
| EXT2_S_IWGRP = 0x0010 |
| EXT2_S_IXGRP = 0x0008 |
| ;other inode right's |
| EXT2_S_IROTH = 0x0004 |
| EXT2_S_IROTH = 0x0002 |
| EXT2_S_IROTH = 0x0001 |
| |
| EXT2_FT_REG_FILE = 1 ;это файл, запись в родительском каталоге |
| EXT2_FT_DIR = 2 ;это папка |
| |
| FS_FT_DIR = 0x10 ;это папка |
| FS_FT_ASCII = 0 ;имя в ascii |
| FS_FT_UNICODE = 1 ;имя в unicode |
| |
| struct EXT2_INODE_STRUC |
| .i_mode dw ? |
| .i_uid dw ? |
| .i_size dd ? |
| .i_atime dd ? |
| .i_ctime dd ? |
| .i_mtime dd ? |
| .i_dtime dd ? |
| .i_gid dw ? |
| .i_links_count dw ? |
| .i_blocks dd ? |
| .i_flags dd ? |
| .i_osd1 dd ? |
| .i_block dd 15 dup ? |
| .i_generation dd ? |
| .i_file_acl dd ? |
| .i_dir_acl dd ? |
| .i_faddr dd ? |
| .i_osd2 dd ? ; 1..12 |
| ends |
| |
| struct EXT2_DIR_STRUC |
| .inode dd ? |
| .rec_len dw ? |
| .name_len db ? |
| .file_type db ? |
| .name db ? ; 0..255 |
| ends |
| |
| |
| ext2_test_superblock: |
| mov eax, [PARTITION_START] |
| add eax, 2 ;superblock start at 1024b |
| call hd_read |
| |
| cmp [fs_type], 0x83 |
| jne .no |
| cmp dword [ebx+24], 3 ;s_block_size 0,1,2,3 |
| ja .no |
| cmp word [ebx+56], 0xEF53 ;s_magic |
| jne .no |
| cmp word [ebx+58], 1 ;s_state (EXT_VALID_FS=1) |
| jne .no |
| |
| ; OK, this is correct EXT2 superblock |
| clc |
| ret |
| .no: |
| ; No, this superblock isn't EXT2 |
| stc |
| ret |
| |
| ext2_setup: |
| mov [fs_type], 2 |
| mov ecx, [ebx+24] |
| inc ecx |
| mov [ext2_data.log_block_size], ecx ; 1, 2, 3, 4 equ 1kb, 2kb, 4kb, 8kb |
| |
| mov eax, 1 |
| shl eax, cl |
| mov [ext2_data.count_block_in_block], eax |
| |
| shl eax, 7 |
| mov [ext2_data.count_pointer_in_block], eax |
| mov edx, eax ; потом еще квадрат найдем |
| |
| shl eax, 2 |
| mov [ext2_data.block_size], eax |
| |
| push eax eax eax ;3 kernel_alloc |
| |
| mov eax, edx |
| mul edx |
| mov [ext2_data.count_pointer_in_block_square], eax |
| |
| call kernel_alloc |
| mov [ext2_data.global_desc_table],eax ;reserve mem for gdt |
| call kernel_alloc |
| mov [ext2_data.ext2_save_block], eax ; and for temp block |
| call kernel_alloc |
| mov [ext2_data.ext2_temp_block], eax ; and for get_inode proc |
| |
| mov ebp, [ebx+88] |
| mov ecx, [ebx+32] |
| mov edx, [ebx+40] |
| mov eax, [ebx+20] ; first_data_block |
| |
| mov [ext2_data.inode_size], ebp |
| mov [ext2_data.blocks_per_group], ecx |
| mov [ext2_data.inodes_per_group], edx |
| |
| mov ebx, [ext2_data.global_desc_table] |
| inc eax ; first_data_block + 1 = gdt |
| call ext2_get_block ; read gtd |
| |
| push ebp ebp ebp ;3 kernel_alloc |
| call kernel_alloc |
| mov [ext2_data.ext2_save_inode], eax |
| call kernel_alloc |
| mov [ext2_data.ext2_temp_inode], eax |
| call kernel_alloc |
| mov [ext2_data.root_inode], eax |
| |
| mov ebx, eax |
| mov eax, EXT2_ROOT_INO |
| call ext2_get_inode ; read root inode |
| |
| popad |
| call free_hd_channel |
| and [hd1_status], 0 |
| ret |
| ;================================================================== |
| ;in: eax = i_block |
| ; ebx = pointer to return memory |
| ext2_get_block: |
| push eax ebx ecx |
| mov ecx, [ext2_data.log_block_size] |
| shl eax, cl |
| add eax, [PARTITION_START] |
| mov ecx, [ext2_data.count_block_in_block] |
| @@: |
| call hd_read |
| inc eax |
| add ebx, 512 |
| loop @B |
| pop ecx ebx eax |
| ret |
| ;=================================================================== |
| ; in: ecx = номер блока |
| ; ebp = адрес inode |
| ; out: ecx = адрес очередного блока |
| ext2_get_inode_block: |
| cmp ecx, 12 |
| jbe .get_direct_block |
| |
| sub ecx, 12 |
| cmp ecx, [ext2_data.count_pointer_in_block] |
| jbe .get_indirect_block |
| |
| sub ecx, [ext2_data.count_pointer_in_block] |
| cmp ecx, [ext2_data.count_pointer_in_block_square] |
| jbe .get_double_indirect_block |
| |
| ;.get_triple_indirect_block: |
| push eax edx ebx |
| |
| mov eax, [ebx + EXT2_INODE_STRUC.i_block + 14*4] |
| mov ebx, [ext2_data.ext2_temp_block] |
| call ext2_get_block |
| |
| xor edx, edx |
| mov eax, ecx |
| div [ext2_data.count_pointer_in_block_square] |
| |
| ;eax - номер в полученном блоке edx - номер дальше |
| mov eax, [ebx + eax*4] |
| call ext2_get_block |
| |
| mov eax, edx |
| jmp @F |
| |
| .get_double_indirect_block: |
| push eax edx ebx |
| |
| mov eax, [ebp + EXT2_INODE_STRUC.i_block + 13*4] |
| mov ebx, [ext2_data.ext2_temp_block] |
| call ext2_get_block |
| |
| mov eax, ecx |
| @@: |
| xor edx, edx |
| div [ext2_data.count_pointer_in_block] |
| |
| mov eax, [ebx + eax*4] |
| call ext2_get_block |
| mov ecx, [ebx + edx*4] |
| |
| pop ebx edx eax |
| ret |
| |
| .get_indirect_block: |
| push eax ebx |
| mov eax, [ebp + EXT2_INODE_STRUC.i_block + 12*4] |
| mov ebx, [ext2_data.ext2_temp_block] |
| call ext2_get_block |
| |
| mov ecx, [ebx + ecx*4] |
| pop ebx eax |
| ret |
| |
| .get_direct_block: |
| mov ecx, dword [ebp + EXT2_INODE_STRUC.i_block + ecx*4] |
| ret |
| |
| |
| ;=================================================================== |
| ;get content inode by num |
| ;in: eax = inode_num |
| ; ebx = address of inode content |
| ext2_get_inode: |
| |
| pushad |
| mov edi, ebx ;сохраним адрес inode |
| dec eax |
| xor edx, edx |
| div [ext2_data.inodes_per_group] |
| |
| push edx ;locale num |
| |
| mov edx, 32 |
| mul edx ; address block_group in global_desc_table |
| |
| add eax, [ext2_data.global_desc_table] |
| mov eax, [eax+8] ; номер блока - в терминах ext2 |
| |
| mov ecx, [ext2_data.log_block_size] |
| shl eax, cl |
| add eax, [PARTITION_START] ; а старт раздела - в терминах hdd (512) |
| |
| ;eax - указывает на таблицу inode-ов на hdd |
| mov ecx, eax ;сохраним его пока в ecx |
| |
| ; прибавим локальный адрес inode-а |
| pop eax ; index |
| mul [ext2_data.inode_size] ; (index * inode_size) |
| mov ebp, 512 |
| div ebp ;поделим на размер блока |
| |
| add eax, ecx ;нашли адрес блока для чтения |
| mov ebx, [ext2_data.ext2_temp_block] |
| call hd_read |
| |
| mov esi, edx ;добавим "остаток" |
| add esi, ebx ;к адресу |
| mov ecx, [ext2_data.inode_size] |
| rep movsb ;копируем inode |
| popad |
| ret |
| |
| ;---------------------------------------------------------------- |
| ext2_upcase: |
| cmp al, 'a' |
| jb .ret |
| cmp al, 'z' |
| ja .ret |
| and al, 0xDF ; upcase = clear 0010 0000 |
| .ret: |
| ret |
| ;---------------------------------------------------------------- |
| ; in: esi -> children |
| ; ebx -> pointer to dir block |
| ; out: esi -> name without parent or not_changed |
| ; ebx -> dir_rec of inode children or trash |
| ext2_test_block_by_name: |
| push eax ecx edx edi |
| |
| mov edx, ebx |
| add edx, [ext2_data.block_size] ;запомним конец блока |
| |
| .start_rec: |
| cmp [ebx + EXT2_DIR_STRUC.inode], 0 |
| jz .next_rec |
| ; test [ebx + EXT2_DIR_STRUC.file_type], EXT2_FT_DIR |
| ; jz .next_rec |
| |
| push esi |
| movzx ecx, [ebx + EXT2_DIR_STRUC.name_len] |
| lea edi, [ebx + EXT2_DIR_STRUC.name] |
| inc ecx |
| |
| @@: |
| dec ecx |
| jecxz .test_find |
| lodsb |
| mov ah, [edi] |
| inc edi |
| |
| call ext2_upcase |
| xchg al, ah |
| call ext2_upcase |
| cmp al, ah |
| je @B |
| @@: ;не подошло |
| pop esi |
| .next_rec: |
| movzx eax, [ebx + EXT2_DIR_STRUC.rec_len] |
| add ebx, eax ;к след. записи |
| cmp ebx, edx ;проверим конец ли |
| jne .start_rec |
| jmp .ret |
| |
| .test_find: |
| cmp byte [esi], 0 |
| je .find ;нашли конец |
| cmp byte [esi], '/' |
| jne @B |
| inc esi |
| .find: |
| pop eax ;удаляем из стека сохраненое значение |
| ; mov ebx, [ebx + EXT2_DIR_STRUC.inode] |
| .ret: |
| pop edi edx ecx eax |
| ret |
| |
| ;---------------------------------------------------------------- |
| ; |
| ; ext2_HdReadFolder - read disk folder |
| ; |
| ; esi points to filename |
| ; ebx pointer to structure 32-bit number = first wanted block, 0+ |
| ; & flags (bitfields) |
| ; flags: bit 0: 0=ANSI names, 1=UNICODE names |
| ; ecx number of blocks to read, 0+ |
| ; edx mem location to return data |
| ; |
| ; ret ebx = blocks read or 0xffffffff folder not found |
| ; eax = 0 ok read or other = errormsg |
| ; |
| ;-------------------------------------------------------------- |
| uglobal |
| EXT2_files_in_folder dd ? ;всего файлов в папке |
| EXT2_read_in_folder dd ? ;сколько файлов "считали" |
| EXT2_end_block dd ? ;конец очередного блока папки |
| EXT2_counter_blocks dd ? |
| endg |
| |
| ext2_HdReadFolder: |
| mov ebp, [ext2_data.root_inode] |
| mov [EXT2_read_in_folder], ebx |
| mov [EXT2_files_in_folder], ecx ;сохраним регистры |
| |
| .next_folder: |
| cmp byte [esi], 0 |
| jz .get_folder |
| |
| or [EXT2_counter_blocks], -1 ;счетчик блоков папки cur block of inode |
| mov eax, [ebp + EXT2_INODE_STRUC.i_blocks] ;убывающий счетчик блоков |
| add eax, [ext2_data.count_block_in_block] |
| mov [EXT2_end_block], eax |
| .next_block_folder: |
| mov eax, [ext2_data.count_block_in_block] |
| sub [EXT2_end_block], eax |
| jz .not_found |
| inc [EXT2_counter_blocks] |
| mov ecx, [EXT2_counter_blocks] |
| call ext2_get_inode_block |
| |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] ;ebx = cur dir record |
| call ext2_get_block |
| |
| mov eax, esi |
| call ext2_test_block_by_name |
| cmp eax, esi ;нашли имя? |
| je .next_block_folder |
| |
| cmp [ebx + EXT2_DIR_STRUC.file_type], EXT2_FT_DIR |
| jne .not_found ;нашли, но это не папка |
| mov eax, [ebx + EXT2_DIR_STRUC.inode] |
| mov ebx, [ext2_data.ext2_save_inode] ;все же папка. |
| call ext2_get_inode |
| mov ebp, ebx |
| jmp .next_folder |
| |
| .not_found: |
| or ebx, -1 |
| mov eax, ERROR_FILE_NOT_FOUND |
| ret |
| ;--------------------------------------------- final step |
| ; in ebp - pointer to final inode (folder). |
| .get_folder: |
| push edx ;заголовок будем заполнять в конце (адрес - в стеке) edx |
| push [EXT2_read_in_folder] ;сохраненный регистр тоже в стек |
| |
| mov edi, [EXT2_files_in_folder] ;edi = число блоков для чтения |
| and [EXT2_read_in_folder], 0 |
| and [EXT2_files_in_folder], 0 |
| |
| mov esi, [ebp + EXT2_INODE_STRUC.i_blocks] |
| mov [EXT2_counter_blocks], esi |
| |
| add edx, 32 ;заголовок будем заполнять в конце (адрес - в стеке) edx = current mem for return |
| xor esi, esi ;esi = номер блока по порядку |
| |
| .new_block_folder: ;reserved label |
| mov ecx, esi ; получим номер блока |
| call ext2_get_inode_block |
| |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] |
| call ext2_get_block ; и считываем блок с hdd |
| |
| mov eax, ebx ; eax = current dir record |
| add ebx, [ext2_data.block_size] |
| mov [EXT2_end_block], ebx ; запомним конец очередного блока |
| |
| pop ecx |
| mov ecx, [ecx] ; ecx = first wanted (flags ommited) |
| |
| .find_wanted_start: |
| jecxz .find_wanted_end |
| .find_wanted_cycle: |
| cmp [eax + EXT2_DIR_STRUC.inode], 0 ; if (inode = 0) => not used |
| je @F |
| inc [EXT2_files_in_folder] |
| @@: |
| movzx ebx, [eax+EXT2_DIR_STRUC.rec_len] |
| add eax, ebx ; к следующей записи |
| cmp eax, [EXT2_end_block] ; проверяем "конец" |
| je .end_block_find_wanted |
| loop .find_wanted_cycle |
| .find_wanted_end: |
| |
| mov ecx, edi |
| .wanted_start: ; ищем first_wanted+count |
| jecxz .wanted_end |
| .wanted_cycle: |
| cmp [eax + EXT2_DIR_STRUC.inode], 0 ; if (inode = 0) => not used |
| jz .empty_rec |
| inc [EXT2_files_in_folder] |
| inc [EXT2_read_in_folder] |
| |
| test [eax + EXT2_DIR_STRUC.file_type], EXT2_FT_DIR ;папка или нет |
| jnz @F |
| |
| push eax ;получим размер, если это файл |
| mov eax, [eax + EXT2_DIR_STRUC.inode] |
| mov ebx, [ext2_data.ext2_temp_inode] |
| call ext2_get_inode |
| mov eax, [ebx + EXT2_INODE_STRUC.i_size] ;low size |
| mov ebx, [ebx + EXT2_INODE_STRUC.i_dir_acl] ;high size |
| mov dword [edx+32], eax |
| mov dword [edx+36], ebx |
| xor dword [edx], FS_FT_DIR ; для файлов xor - 2 раза |
| pop eax |
| @@: |
| xor dword [edx], FS_FT_DIR |
| mov dword [edx+4], FS_FT_ASCII ; symbol type in name |
| |
| push ecx esi ;copy name |
| movzx ecx, [eax + EXT2_DIR_STRUC.name_len] |
| mov edi, edx |
| add edi, 40 |
| lea esi, [eax + EXT2_DIR_STRUC.name] |
| rep movsb |
| pop esi ecx |
| and byte [edi], 0 |
| |
| add edx, 40 + 264 ; go to next record |
| .empty_rec: |
| movzx ebx, [eax + EXT2_DIR_STRUC.rec_len] |
| add eax, ebx |
| cmp eax, [EXT2_end_block] |
| je .end_block_wanted |
| loop .wanted_cycle |
| |
| .wanted_end: ;теперь дойдем до конца чтобы узнать сколько файлов в папке |
| or ecx, -1 ;цикл уже есть, просто поставим ему огромный счетчик |
| jmp .find_wanted_cycle |
| |
| .end_block_find_wanted: ;вылетили из цикла find_wanted |
| mov ebx, [ext2_data.count_block_in_block] |
| sub [EXT2_counter_blocks], ebx |
| jz .end_dir |
| |
| ;получаем новый блок |
| inc esi |
| push ecx |
| mov ecx, esi |
| call ext2_get_inode_block |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] |
| call ext2_get_block |
| pop ecx |
| dec ecx |
| mov eax, ebx |
| add ebx, [ext2_data.block_size] |
| mov [EXT2_end_block], ebx |
| jmp .find_wanted_start |
| |
| .end_block_wanted: ;вылетели из цикла wanted |
| mov ebx, [ext2_data.count_block_in_block] |
| sub [EXT2_counter_blocks], ebx |
| jz .end_dir |
| |
| inc esi |
| push ecx |
| mov ecx, esi |
| call ext2_get_inode_block |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] |
| call ext2_get_block |
| pop ecx |
| dec ecx |
| mov eax, ebx |
| add ebx, [ext2_data.block_size] |
| mov [EXT2_end_block], ebx |
| jmp .wanted_start |
| |
| .end_dir: |
| pop edx |
| mov ebx, [EXT2_read_in_folder] |
| mov ecx, [EXT2_files_in_folder] |
| mov dword [edx], 1 ;version |
| xor eax, eax |
| mov [edx+4], ebx |
| mov [edx+8], ecx |
| lea edi, [edx + 12] |
| mov ecx, 20 / 4 |
| rep stosd |
| ret |
| ;====================== end ext2_HdReadFolder |
| |
| ;---------------------------------------------------------------- |
| ; |
| ; ext2_HdRead - read hard disk |
| ; |
| ; esi points to filename |
| ; ebx pointer to 64-bit number = first wanted byte, 0+ |
| ; may be ebx=0 - start from first byte |
| ; ecx number of bytes to read, 0+ |
| ; edx mem location to return data |
| ; |
| ; ret ebx = bytes read or 0xffffffff file not found |
| ; eax = 0 ok read or other = errormsg |
| ; |
| ;-------------------------------------------------------------- |
| ext2_HdRead: |
| mov ebp, [ext2_data.root_inode] |
| |
| push ecx edx ebx |
| .next_folder: |
| push esi |
| @@: |
| lodsb |
| test al, al |
| jz .find_end |
| cmp al, '/' |
| jz .find_folder |
| jmp @B |
| |
| .find_end: |
| ;установим флаг что ищем файл или очередную папку |
| mov edi, 1 |
| jmp .find_any |
| .find_folder: |
| xor edi, edi |
| .find_any: |
| pop esi |
| |
| cmp byte [esi], 0 |
| jz .not_found |
| |
| or [EXT2_counter_blocks], -1 ;счетчик блоков папки cur block of inode |
| mov eax, [ebp + EXT2_INODE_STRUC.i_blocks] ;убывающий счетчик блоков |
| add eax, [ext2_data.count_block_in_block] |
| mov [EXT2_end_block], eax |
| .next_block_folder: |
| mov eax, [ext2_data.count_block_in_block] |
| sub [EXT2_end_block], eax |
| jz .not_found |
| inc [EXT2_counter_blocks] |
| mov ecx, [EXT2_counter_blocks] |
| call ext2_get_inode_block |
| |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] ;ebx = cur dir record |
| call ext2_get_block |
| |
| mov eax, esi |
| call ext2_test_block_by_name |
| cmp eax, esi ;нашли имя? |
| je .next_block_folder |
| |
| cmp [ebx + EXT2_DIR_STRUC.file_type], EXT2_FT_REG_FILE |
| je .test_file |
| cmp [ebx + EXT2_DIR_STRUC.file_type], EXT2_FT_DIR |
| jne .not_found |
| .test_dir: |
| cmp edi, 0 |
| jne .this_is_folder |
| |
| mov eax, [ebx + EXT2_DIR_STRUC.inode] |
| mov ebx, [ext2_data.ext2_save_inode] ;все же папка. |
| call ext2_get_inode |
| mov ebp, ebx |
| jmp .next_folder |
| |
| .test_file: |
| cmp edi, 0 |
| je .not_found |
| |
| mov eax, [ebx + EXT2_DIR_STRUC.inode] |
| mov ebx, [ext2_data.ext2_save_inode] |
| call ext2_get_inode |
| jmp .get_file |
| |
| .not_found: |
| pop edx ecx ebx |
| or ebx, -1 |
| mov eax, ERROR_FILE_NOT_FOUND |
| ret |
| .this_is_folder: |
| pop edx ecx ebx |
| or ebx, -1 |
| mov eax, ERROR_ACCESS_DENIED |
| .end_read: |
| ret |
| |
| ;-----------------------------------------------------------------------------final step |
| .get_file: |
| xchg bx, bx |
| mov ebp ,ebx |
| |
| ;pop eax edi ecx ; первый_блок память кол-во_байт |
| mov esi, [esp] |
| mov edi, [esp + 8] ;edi = нужно считать байт |
| |
| ;///// сравним хватит ли нам файла или нет |
| mov ebx, [esi+4] |
| mov eax, [esi] ; ebx : eax - стартовый номер байта |
| |
| mov edx, [ebp + EXT2_INODE_STRUC.i_dir_acl] |
| mov ecx, [ebp + EXT2_INODE_STRUC.i_size] ;edx : ecx - размер файла |
| |
| cmp edx, ebx |
| ja .size_great |
| jb .size_less |
| |
| cmp ecx, eax |
| ja .size_great |
| |
| .size_less: |
| add esp, 12 |
| mov ebx, 0 |
| mov eax, 6 ;EOF |
| ret |
| .size_great: |
| ;прибавим к старту кол-во байт для чтения |
| add eax, edi |
| jnc @F |
| inc ebx |
| @@: |
| cmp edx, ebx |
| ja .size_great_great |
| jb .size_great_less |
| cmp ecx, eax |
| jae .size_great_great |
| ;jmp .size_great_less |
| ; а если равно, то не важно куда |
| .size_great_less: |
| or [EXT2_files_in_folder], 1 ;читаем по границе размера |
| sub ecx, [esi] |
| pop eax edi edx ;ecx - не меняем |
| jmp @F |
| |
| .size_great_great: |
| and [EXT2_files_in_folder], 0 ;читаем нормально |
| pop eax edi ecx |
| |
| @@: |
| push ecx ;сохраним размер считанных байт в стеке |
| test eax, eax |
| je .zero_start |
| |
| ;пока делаем п..ц криво =) |
| mov edx, [eax+4] |
| mov eax, [eax] |
| div [ext2_data.block_size] |
| |
| mov [EXT2_counter_blocks], eax ;номер блока запоминаем |
| |
| push ecx |
| mov ecx, eax |
| call ext2_get_inode_block |
| mov ebx , [ext2_data.ext2_save_block] |
| mov eax, ecx |
| call ext2_get_block |
| pop ecx |
| add ebx, edx |
| |
| neg edx |
| add edx,[ext2_data.block_size] ;block_size - стартоый блок = сколько байт 1-го блока |
| cmp ecx, edx |
| jbe .only_one_block |
| |
| mov eax, ecx |
| sub eax, edx |
| mov ecx, edx |
| |
| mov esi, ebx |
| rep movsb ;кусок 1-го блока |
| |
| .zero_start: |
| mov ebx, edi ;чтение блока прям в ebx |
| ;теперь в eax кол-во оставшихся байт для чтения |
| xor edx, edx |
| div [ext2_data.block_size] |
| mov [EXT2_end_block], eax ;кол-во целых блоков |
| @@: |
| cmp [EXT2_end_block], 0 |
| jz .finish_block |
| inc [EXT2_counter_blocks] |
| mov ecx, [EXT2_counter_blocks] |
| call ext2_get_inode_block |
| |
| mov eax, ecx ;а ebx уже забит нужным значением |
| call ext2_get_block |
| add ebx, [ext2_data.block_size] |
| |
| dec [EXT2_end_block] |
| jmp @B |
| |
| .finish_block: ;в edx - кол-во байт в последнем блоке |
| cmp edx, 0 |
| je .end_read |
| |
| mov ecx, [EXT2_counter_blocks] |
| inc ecx |
| call ext2_get_inode_block |
| |
| mov edi, ebx |
| mov eax, ecx |
| mov ebx, [ext2_data.ext2_save_block] |
| call ext2_get_block |
| |
| mov ecx, edx |
| |
| .only_one_block: |
| mov esi, ebx |
| rep movsb ;кусок 1-го блока (последнего) |
| pop ebx |
| cmp [EXT2_files_in_folder], 0 |
| jz @F |
| |
| mov eax, 6 ;EOF |
| ret |
| @@: |
| xor eax, eax |
| ret |
| ;======================== |
| |
| ext2_HdRewrite: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| |
| ext2_HdWrite: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| ext2_HdSetFileEnd: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| ext2_HdGetFileInfo: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| ext2_HdSetFileInfo: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| ext2_HdDelete: |
| ; xchg bx, bx |
| xor ebx, ebx |
| mov eax, ERROR_UNSUPPORTED_FS |
| ret |
| |
| Property changes: |
|---|
| Added: svn:keywords |
|---|
| +Rev |
|---|
| \ No newline at end of property |
|---|