| /* |
| * bootlace.inc -- code shared by 16-bit DOS and 32-bit Linux |
| * Copyright (ABS(C)) 2005 Tinybit(tinybit@163.net) |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| */ |
| |
| .file "bootlace.inc" |
| |
| #ifdef __DOS_16 |
| |
| #undef ABS |
| #define ABS(x) (x - _start + 0x100) |
| |
| #undef iBX |
| #define iBX %bx |
| |
| #undef iSI |
| #define iSI %si |
| |
| #undef iDI |
| #define iDI %di |
| |
| #undef iDX |
| #define iDX %dx |
| |
| #undef LEAL |
| #define LEAL ADDR32 leal |
| |
| #undef MOVZWL |
| #define MOVZWL ADDR32 movzwl |
| |
| #undef MOVL |
| #define MOVL ADDR32 movl |
| |
| #undef MOVW |
| #define MOVW ADDR32 movw |
| |
| #undef CMPL |
| #define CMPL ADDR32 cmpl |
| |
| #undef CMPW |
| #define CMPW ADDR32 cmpw |
| |
| #undef SUBL |
| #define SUBL ADDR32 subl |
| |
| #undef SBBL |
| #define SBBL ADDR32 sbbl |
| |
| #undef NEGL |
| #define NEGL ADDR32 negl |
| |
| #undef NOTL |
| #define NOTL ADDR32 notl |
| |
| #undef ADCL |
| #define ADCL ADDR32 adcl |
| |
| #undef DIVL |
| #define DIVL ADDR32 divl |
| |
| . = _start + 0x34 // dos entry point invalid_dos_exec |
| |
| #if 0 |
| movl $ABS(msg_invalid_dos), %ecx |
| call 8f |
| |
| movw $0x4c01, %ax // EXIT - TERMINATE WITH RETURN CODE 1 |
| int $0x21 // call DOS |
| #else |
| jmp 1f |
| #endif |
| |
| |
| ////////////////////////////////////////////////////////////////////// |
| |
| . = _start + 0x47 // dos entry point |
| |
| 1: |
| /* dos entry point */ |
| |
| movl $0x81, %esi |
| movl %esi, %edi |
| movl $0x7f, %ecx |
| movb $0x0d, %al /* CR */ |
| |
| cld |
| repnz scasb |
| |
| decl %edi /* points to CR */ |
| std |
| movb $0, %al |
| stosb |
| movl %edi, %esi |
| xorl %ecx, %ecx |
| pushl %ecx /* 0 is the end of argv */ |
| xorl %edx, %edx /* find spaces */ |
| 3: |
| cmpl $0x81, %edi |
| jb 3f |
| lodsb |
| cmpb $0x20, %al |
| je 1f |
| cmpb $0x09, %al |
| jne 2f |
| 1: |
| testl %edx, %edx |
| jz 1f |
| notl %edx |
| incl %edi |
| pushl %edi /* argv */ |
| decl %edi |
| 1: |
| movb $0, %al |
| stosb |
| jmp 3b |
| 2: |
| testl %edx, %edx |
| jnz 1f |
| incl %ecx |
| notl %edx |
| 1: |
| stosb |
| jmp 3b |
| 3: |
| testl %edx, %edx |
| jz 1f |
| incl %edi |
| pushl %edi |
| 1: |
| pushl %esi /* dummy for program name */ |
| incl %ecx |
| pushl %ecx /* argc */ |
| cld |
| #else |
| |
| #undef ABS |
| #define ABS(x) (x) |
| |
| #undef iBX |
| #define iBX %ebx |
| |
| #undef iSI |
| #define iSI %esi |
| |
| #undef iDI |
| #define iDI %edi |
| |
| #undef iDX |
| #define iDX %edx |
| |
| #undef LEAL |
| #define LEAL leal |
| |
| #undef MOVZWL |
| #define MOVZWL movzwl |
| |
| #undef MOVL |
| #define MOVL movl |
| |
| #undef MOVW |
| #define MOVW movw |
| |
| #undef CMPL |
| #define CMPL cmpl |
| |
| #undef CMPW |
| #define CMPW cmpw |
| |
| #undef SUBL |
| #define SUBL subl |
| |
| #undef SBBL |
| #define SBBL sbbl |
| |
| #undef NEGL |
| #define NEGL negl |
| |
| #undef NOTL |
| #define NOTL notl |
| |
| #undef ADCL |
| #define ADCL adcl |
| |
| #undef DIVL |
| #define DIVL divl |
| |
| #endif |
| |
| popl %ecx # argc |
| |
| /* argc must be > 1 */ |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $1, %ecx |
| movl $ABS(msg_no_args), %ecx |
| jbe 4f /* error */ |
| |
| /* Note: ECX does not hold the argc now. */ |
| |
| xorl %eax, %eax # EAX will point to file name |
| //movl %ebx, ABS(filename) # save 0 to filename |
| popl %ecx # discard argv[0], the program name |
| 1: |
| popl %ecx # argv |
| movl %ecx, %ebx |
| test %ecx, %ecx |
| jz 1f # end of arguments |
| |
| /* check if it is an option */ |
| cmpb $0x2D, (iBX) # "-" |
| jz 2f |
| |
| /* it is a filename */ |
| |
| testl %eax, %eax # filename already specified? |
| //cmpl $0, ABS(filename) |
| jz 3f |
| |
| /* error: only one file should be specified. */ |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| movl $ABS(msg_too_many_files), %ecx |
| jmp 4f /* error */ |
| |
| 3: |
| |
| /* not yet, this is the first filename */ |
| |
| movl %ecx, %eax # save ECX to EAX |
| //movl %ecx, ABS(filename) # save ECX to filename |
| jmp 1b # continue |
| |
| 2: |
| |
| /* it is an option */ |
| |
| /* check --no-backup-mbr */ |
| |
| movl $16, %ecx |
| movl $ABS(option_no_backup_mbr), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $1, ABS(backup_mbr) |
| movl $ABS(msg_option_backup_mbr), %ecx |
| jnz 4f /* error */ |
| movl $0, ABS(backup_mbr) |
| jmp 1b |
| |
| 3: |
| /* check --force-backup-mbr */ |
| |
| movl $19, %ecx |
| movl $ABS(option_force_backup_mbr), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $1, ABS(backup_mbr) |
| movl $ABS(msg_option_backup_mbr), %ecx |
| jnz 4f /* error */ |
| movl $2, ABS(backup_mbr) |
| jmp 1b |
| |
| 3: |
| |
| /* check --mbr-enable-floppy */ |
| |
| movl $20, %ecx |
| movl $ABS(option_mbr_enable_floppy), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(mbr_floppy) |
| movl $ABS(msg_option_mbr_floppy), %ecx |
| jnz 4f /* error */ |
| movl $2, ABS(mbr_floppy) |
| jmp 1b |
| |
| 3: |
| |
| /* check --mbr-disable-floppy */ |
| |
| movl $21, %ecx |
| movl $ABS(option_mbr_disable_floppy), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(mbr_floppy) |
| movl $ABS(msg_option_mbr_floppy), %ecx |
| jnz 4f /* error */ |
| movl $1, ABS(mbr_floppy) |
| jmp 1b |
| |
| 3: |
| |
| /* check --mbr-enable-osbr */ |
| |
| movl $18, %ecx |
| movl $ABS(option_mbr_enable_osbr), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(mbr_osbr) |
| movl $ABS(msg_option_mbr_osbr), %ecx |
| jnz 4f /* error */ |
| movl $2, ABS(mbr_osbr) |
| jmp 1b |
| |
| 3: |
| |
| /* check --mbr-disable-osbr */ |
| |
| movl $19, %ecx |
| movl $ABS(option_mbr_disable_osbr), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(mbr_osbr) |
| movl $ABS(msg_option_mbr_osbr), %ecx |
| jnz 4f /* error */ |
| movl $1, ABS(mbr_osbr) |
| jmp 1b |
| |
| 3: |
| |
| /* check --duce */ |
| |
| movl $7, %ecx |
| movl $ABS(option_duce), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(duce) |
| movl $ABS(msg_option_duce), %ecx |
| jnz 4f /* error */ |
| movl $1, ABS(duce) |
| jmp 1b |
| |
| 3: |
| |
| /* check --boot-prevmbr-first */ |
| |
| movl $21, %ecx |
| movl $ABS(option_boot_prevmbr_first), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(boot_prevmbr) |
| movl $ABS(msg_option_boot_prevmbr), %ecx |
| jnz 4f /* error */ |
| movl $1, ABS(boot_prevmbr) |
| jmp 1b |
| |
| 3: |
| |
| /* check --boot-prevmbr-last */ |
| |
| movl $20, %ecx |
| movl $ABS(option_boot_prevmbr_last), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(boot_prevmbr) |
| movl $ABS(msg_option_boot_prevmbr), %ecx |
| jnz 4f /* error */ |
| movl $2, ABS(boot_prevmbr) |
| jmp 1b |
| |
| 3: |
| |
| /* check --preferred-drive= */ |
| |
| movl $18, %ecx |
| movl $ABS(option_preferred_drive), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xff, ABS(preferred_drive) |
| movl $ABS(msg_option_preferred_drive), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xfe, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(preferred_drive) |
| jmp 1b |
| |
| 3: |
| |
| /* check --preferred-partition= */ |
| |
| movl $22, %ecx |
| movl $ABS(option_preferred_partition), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xff, ABS(preferred_partition) |
| movl $ABS(msg_option_preferred_partition), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xfe, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(preferred_partition) |
| jmp 1b |
| |
| 3: |
| |
| /* check --time-out= */ |
| |
| movl $11, %ecx |
| movl $ABS(option_time_out), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffff05, ABS(time_out) |
| movl $ABS(msg_option_time_out), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xff, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(time_out) |
| jmp 1b |
| |
| 3: |
| |
| /* check --hot-key= */ |
| |
| movl $10, %ecx |
| movl $ABS(option_hot_key), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffff3920, ABS(hot_key) |
| movl $ABS(msg_option_hot_key), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xffff, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(hot_key) |
| jmp 1b |
| |
| 3: |
| |
| /* check --install-partition= */ |
| |
| movl $20, %ecx |
| movl $ABS(option_install_partition), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(install_partition) |
| movl $ABS(msg_option_install_partition), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xffff, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(install_partition) |
| jmp 1b |
| |
| 3: |
| |
| /* check --sectors-per-track= */ |
| |
| movl $20, %ecx |
| movl $ABS(option_sectors_per_track), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| movl $ABS(msg_option_sectors_per_track), %ecx |
| jnz 4f /* error */ |
| |
| movl $0x3f, %ebx # maximum is 63 |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| cmpl $0, %edi |
| je 4f /* error */ |
| movl %edi, ABS(sectors_per_track) |
| jmp 1b |
| |
| 3: |
| |
| /* check --heads= */ |
| |
| movl $8, %ecx |
| movl $ABS(option_heads), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffff00ff, ABS(heads) |
| movl $ABS(msg_option_heads), %ecx |
| jnz 4f /* error */ |
| |
| movl $0x100, %ebx # maximum is 256 |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| cmpl $0, %edi |
| je 4f /* error */ |
| movl %edi, ABS(heads) |
| jmp 1b |
| |
| 3: |
| |
| /* check --start-sector= */ |
| |
| movl $15, %ecx |
| movl $ABS(option_start_sector), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(start_sector) |
| movl $ABS(msg_option_start_sector), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xfffffffe, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(start_sector) |
| jmp 1b |
| |
| 3: |
| |
| /* check --total-sectors= */ |
| |
| movl $16, %ecx |
| movl $ABS(option_total_sectors), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0, ABS(total_sectors) |
| movl $ABS(msg_option_total_sectors), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xffffffff, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| cmpl $0, %edi |
| je 4f /* error */ |
| movl %edi, ABS(total_sectors) |
| jmp 1b |
| |
| 3: |
| |
| /* check --floppy= */ |
| |
| movl $9, %ecx |
| movl $ABS(option_floppy_partition), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(floppy) |
| movl $ABS(msg_option_floppy), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xfe, %ebx |
| call 7f /* parse_number */ |
| movl %ebx, %edi # save EBX to EDI |
| movl $0, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_invalid_number), %ecx |
| jc 4f /* error */ |
| movl %edi, ABS(floppy) |
| jmp 1b |
| |
| 3: |
| |
| /* check --read-only */ |
| |
| movl $12, %ecx |
| movl $ABS(option_read_only), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $2, ABS(read_only) |
| movl $ABS(msg_option_read_only), %ecx |
| jnz 4f /* error */ |
| |
| movl $0, ABS(read_only) |
| jmp 1b |
| |
| 3: |
| |
| /* check --floppy */ |
| |
| movl $9, %ecx |
| movl $ABS(option_floppy), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(floppy) |
| movl $ABS(msg_option_floppy), %ecx |
| jnz 4f /* error */ |
| |
| movl $0xff, ABS(floppy) |
| jmp 1b |
| |
| 3: |
| |
| /* check --lba */ |
| |
| movl $6, %ecx |
| movl $ABS(option_lba), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(lba) |
| movl $ABS(msg_option_lba), %ecx |
| jnz 4f /* error */ |
| |
| movl $1, ABS(lba) |
| jmp 1b |
| |
| 3: |
| |
| /* check --chs */ |
| |
| movl $6, %ecx |
| movl $ABS(option_chs), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(lba) |
| movl $ABS(msg_option_lba), %ecx |
| jnz 4f /* error */ |
| |
| movl $0, ABS(lba) |
| jmp 1b |
| |
| 3: |
| |
| /* check --fat12 */ |
| |
| movl $8, %ecx |
| movl $ABS(option_fat12), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $1, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| /* check --fat16 */ |
| |
| movl $8, %ecx |
| movl $ABS(option_fat16), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $2, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| /* check --fat32 */ |
| |
| movl $8, %ecx |
| movl $ABS(option_fat32), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $4, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| /* check --ntfs */ |
| |
| movl $7, %ecx |
| movl $ABS(option_ntfs), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $8, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| /* check --ext2 */ |
| |
| movl $7, %ecx |
| movl $ABS(option_ext2), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $0x10, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| /* check --vfat */ |
| |
| movl $7, %ecx |
| movl $ABS(option_vfat), %esi |
| movl %ebx, %edi |
| |
| cld |
| repz cmpsb |
| |
| jnz 3f |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| jnz 2f |
| movl $0, ABS(fstypes) |
| 2: |
| orb $7, ABS(fstypes) |
| jmp 1b |
| |
| 3: |
| |
| movl $ABS(msg_invalid_option), %ecx |
| jmp 4f /* error */ |
| |
| 1: |
| |
| //---------------------------------------------------------------------------- |
| /* end of arguments */ |
| |
| /* ECX=EBX=0 */ |
| |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| testl %eax, %eax # filename already specified? |
| //cmpl $0, ABS(filename) # filename already specified? |
| movl $ABS(msg_no_file), %ecx |
| jz 4f /* error */ |
| |
| xchgl %eax, %ebx # move EAX to EBX |
| //movl ABS(filename), %ebx # move filename to EBX |
| |
| /* EBX points to the pathname of the file. */ |
| |
| /* check if preferred_partition matches preferred_drive */ |
| |
| movb ABS(preferred_drive), %al |
| movb ABS(preferred_partition), %ah |
| |
| cmpb $0xff, %al |
| jne 1f |
| |
| movl %ebx, %edi # save EBX to EDI |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| cmpb $0xff, %ah |
| movl $ABS(msg_partition_without_drive), %ecx |
| jne 4f /* error */ |
| movl %edi, %ebx # restore EBX from EDI |
| 1: |
| |
| /* EBX points to the pathname of the file. */ |
| |
| movl %ebx, %edi # save EBX to EDI |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| |
| cmpl $0xffffffff, ABS(floppy) |
| je 1f # --floppy is not specified |
| |
| /* if --floppy is specified, should not specify the options for MBR. */ |
| cmpl $1, ABS(backup_mbr) |
| movl $ABS(msg_option_backup_mbr_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(mbr_floppy) |
| movl $ABS(msg_option_mbr_floppy_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(mbr_osbr) |
| movl $ABS(msg_option_mbr_osbr_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(duce) |
| movl $ABS(msg_option_duce_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(boot_prevmbr) |
| movl $ABS(msg_option_boot_prevmbr_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xff, ABS(preferred_drive) |
| movl $ABS(msg_option_preferred_drive_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xff, ABS(preferred_partition) |
| movl $ABS(msg_option_preferred_partition_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffffff, ABS(install_partition) |
| movl $ABS(msg_option_install_partition_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffff05, ABS(time_out) |
| movl $ABS(msg_option_time_out_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffff3920, ABS(hot_key) |
| movl $ABS(msg_option_hot_key_with_floppy), %ecx |
| jnz 4f /* error */ |
| |
| /* for a floppy, start_sector should be 0, and |
| * for a partition, start_sector should be non-zero |
| */ |
| cmpl $0xff, ABS(floppy) |
| je 2f # a real floppy |
| |
| /* a single partition */ |
| cmpl $0, ABS(start_sector) |
| movl $ABS(msg_partition_start), %ecx |
| jz 4f /* error */ |
| |
| jmp 3f |
| 2: |
| /* a real floppy */ |
| /* */ |
| cmpl $0xffffffff, ABS(start_sector) |
| je 3f |
| cmpl $0, ABS(start_sector) |
| movl $ABS(msg_floppy_start), %ecx |
| jnz 4f /* error */ |
| |
| 3: |
| jmp 2f |
| 1: |
| |
| /* EBX=0 */ |
| |
| cmpl $0xffffffff, ABS(install_partition) |
| je 1f # --install-partition is not specified |
| |
| /* should not specify --install-partition with options for MBR. */ |
| cmpl $1, ABS(backup_mbr) |
| movl $ABS(msg_option_backup_mbr_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(mbr_floppy) |
| movl $ABS(msg_option_mbr_floppy_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(mbr_osbr) |
| movl $ABS(msg_option_mbr_osbr_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(duce) |
| movl $ABS(msg_option_duce_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(boot_prevmbr) |
| movl $ABS(msg_option_boot_prevmbr_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xff, ABS(preferred_drive) |
| movl $ABS(msg_option_preferred_drive_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xff, ABS(preferred_partition) |
| movl $ABS(msg_option_preferred_partition_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffff05, ABS(time_out) |
| movl $ABS(msg_option_time_out_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffff3920, ABS(hot_key) |
| movl $ABS(msg_option_hot_key_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| movl $ABS(msg_option_sectors_per_track_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffff00ff, ABS(heads) |
| movl $ABS(msg_option_heads_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffffff, ABS(start_sector) |
| movl $ABS(msg_option_start_sector_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(total_sectors) |
| movl $ABS(msg_option_total_sectors_with_partition), %ecx |
| jnz 4f /* error */ |
| |
| jmp 2f |
| 1: |
| |
| /* EBX=0 */ |
| |
| /* this is an MBR device. Should not specify floppy-specific options. */ |
| |
| testl $1, ABS(boot_prevmbr) /* --boot-prevmbr-first specified? */ |
| jnz 2f /* Yes, specified. Continue */ |
| /* No, not specified. */ |
| /* Should not specify --time-out without --boot-prevmbr-first. */ |
| cmpl $0xffffff05, ABS(time_out) |
| movl $ABS(msg_option_time_out_without_prevmbr), %ecx |
| jne 4f /* error */ |
| |
| /* Should not specify --hot-key without --boot-prevmbr-first. */ |
| cmpl $0xffff3920, ABS(hot_key) |
| movl $ABS(msg_option_hot_key_without_prevmbr), %ecx |
| jne 4f /* error */ |
| |
| 2: |
| |
| /* EBX=0, EDI points to the pathname of the file. */ |
| |
| //---------------------------------------------------------------------------- |
| movl %edi, %ebx # restore EBX from EDI |
| |
| /* EBX=EDI points to the pathname of the file. */ |
| |
| #ifdef __DOS_16 |
| |
| xorl %eax, %eax |
| //movl %ebx, %edi /* EBX points to the pathname of the file. */ |
| movl $0xfe, %ebx |
| call 7f /* parse_number */ |
| jc 2f /* invalid number */ |
| /* EBX holds the bios drive number */ |
| movl %ebx, ABS(bios_drive_number) |
| jmp 1f |
| 2: |
| //AH = 3Dh //OPEN EXISTING FILE |
| //AL = access and sharing modes (see #01402) |
| //DS:DX -> ASCIZ filename |
| //CL = attribute mask of files to look for (server call only) |
| |
| //Return: |
| //CF clear if successful AX = file handle |
| //CF set on error AX = error code (01h,02h,03h,04h,05h,0Ch,56h) |
| |
| movzbl ABS(read_only), %eax |
| movb $0x3d, %ah // open file for read/write |
| movl %edi, %edx // DS:DX points to ASCIZ filename |
| int $0x21 |
| jnc 1f |
| negl %eax /* EAX < 0 */ |
| 1: |
| #else |
| |
| /* int open(const char *pathname, int flags, mode_t mode) */ |
| |
| movl $5, %eax # sys_open |
| movzbl ABS(read_only), %ecx # O_RDWR = 02 |
| int $0x80 |
| #endif |
| xorl %ebx, %ebx # invalid file descriptor for CLOSE below |
| movl $ABS(msg_open_file_rw), %ecx |
| cmpw $2, ABS(read_only) |
| je 1f |
| movl $ABS(msg_open_file_ro), %ecx |
| 1: |
| testl %eax, %eax |
| js 4f /* error */ |
| |
| //---------------------------------------------------------------------------- |
| /* open file succeeded */ |
| |
| pushl %eax # file descriptor, or 0 if specified BIOS drive |
| movl %eax, %ebx |
| |
| /* EBX and the stack holds the file descriptor number or 0 */ |
| |
| #ifdef __DOS_16 |
| |
| xorl %eax, %eax |
| cmpl $0xff, ABS(bios_drive_number) |
| je 1f |
| movw $0x204, %ax # read 4 sectors of the MBR |
| movw $ABS(mbr_63_sectors), %bx |
| movw $1, %cx |
| movw ABS(bios_drive_number), %dx |
| int $0x13 |
| jmp 2f |
| 1: |
| //READ FROM FILE OR DEVICE |
| |
| //AH = 3Fh |
| //BX = file handle |
| //CX = number of bytes to read |
| //DS:DX -> buffer for data |
| |
| //Return: |
| //CF clear if successful AX = number of bytes actually read (0 if at EOF before call) |
| //CF set on error AX = error code (05h,06h) |
| movl $0x3f00, %eax |
| movl $(63*512), %ecx |
| movl $ABS(mbr_63_sectors), %edx |
| int $0x21 |
| 2: |
| jnc 1f |
| negl %eax |
| 1: |
| #else |
| /* ssize_t read(int fd, void *buf, size_t count) */ |
| |
| movl $3, %eax # sys_read |
| movl $ABS(mbr_63_sectors), %ecx |
| movl $(63*512), %edx # read 63 sectors |
| int $0x80 |
| #endif |
| |
| popl %ebx # file descriptor, or 0 if specified BIOS drive |
| testl %eax, %eax |
| movl $ABS(msg_read_file), %ecx |
| js 4f /* error */ |
| |
| //---------------------------------------------------------------------------- |
| |
| /* rewind the file for write! important! */ |
| |
| pushl %ebx # file descriptor, or 0 if specified BIOS drive |
| |
| #ifdef __DOS_16 |
| |
| xorl %eax, %eax |
| cmpl $0xff, ABS(bios_drive_number) |
| jne 1f |
| //LSEEK - SET CURRENT FILE POSITION |
| |
| //AH = 42h |
| //AL = origin of move |
| // 00h start of file |
| // 01h current file position |
| // 02h end of file |
| //BX = file handle |
| //CX:DX = (signed) offset from origin of new file position |
| |
| //Return: |
| //CF clear if successful DX:AX = new file position in bytes from start of file |
| //CF set on error AX = error code (01h,06h) |
| movl $0x4200, %eax |
| movl $0, %ecx |
| movl $0, %edx |
| int $0x21 |
| jnc 1f |
| negl %eax |
| 1: |
| #else |
| /* off_t lseek(int fildes, off_t offset, int whence) */ |
| |
| movl $19, %eax # sys_lseek |
| movl $0, %ecx |
| movl $0, %edx # SEEK_SET = 0 |
| int $0x80 |
| #endif |
| |
| popl %ebx # file descriptor, or 0 if specified BIOS drive |
| testl %eax, %eax |
| movl $ABS(msg_lseek_file), %ecx |
| js 4f /* error */ |
| |
| //---------------------------------------------------------------------------- |
| /* remember EBX holds file descriptor number, and don't touch it */ |
| |
| /* check if the partition table is valid. */ |
| |
| movl $ABS(mbr_63_sectors), %esi |
| cmpw $0xAA55, 0x1fe(iSI) |
| movl $ABS(msg_boot_signature_mbr), %ecx |
| //jne 4f /* error */ |
| clc |
| jne 2f |
| |
| call 9f /* probe_geometry */ |
| jnc 1f |
| |
| 2: |
| |
| /* should be floppy since no partition table or no boot signature. */ |
| |
| /* CF=0 means no boot signature, CF=1 means no partition table. */ |
| |
| jnc 2f |
| |
| movl $ABS(msg_invalid_partition_table), %ecx |
| 2: |
| cmpl $0xffffffff, ABS(floppy) /* Is --floppy specified? */ |
| je 4f /* error */ |
| |
| /* Yes, --floppy is specified */ |
| |
| /* ESI points to ABS(mbr_63_sectors) */ |
| call 5f /* floppy routine */ |
| movl $0, %ecx |
| jc 4f /* error */ |
| |
| jmp 2f /* write file */ |
| 1: |
| |
| //---------------------------------------------------------------------------- |
| /* the image type is MBR. So, should not specify --floppy */ |
| |
| cmpl $0xffffffff, ABS(floppy) |
| movl $ABS(msg_floppy_partition_table), %ecx |
| jne 4f /* error */ |
| |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| movl $ABS(msg_option_sectors_per_track_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffff00ff, ABS(heads) |
| movl $ABS(msg_option_heads_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffffff, ABS(start_sector) |
| movl $ABS(msg_option_start_sector_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0, ABS(total_sectors) |
| movl $ABS(msg_option_total_sectors_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xffffffff, ABS(lba) |
| movl $ABS(msg_option_lba_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $0xfffffff7, ABS(fstypes) |
| movl $ABS(msg_option_fstypes_for_mbr), %ecx |
| jnz 4f /* error */ |
| |
| cmpl $((pre_stage2_start - _start1) / 512), ABS(probed_sectors_per_track) |
| movl $ABS(msg_sectors_per_track), %ecx |
| jb 4f /* error */ |
| |
| cmpl $0xffffffff, ABS(install_partition) |
| movl $ABS(msg_option_install_partition_not_implemented), %ecx |
| je 1f |
| jmp 4f /* error */ |
| /* EBX holds the file descriptor number or 0 if it is BIOS drive */ |
| /* move partition table forward to the beginning of the 17th sector */ |
| movl $ABS(mbr_63_sectors + 0x01be), %esi |
| movl $ABS(mbr_63_sectors + 0x2000), %edi |
| movl $0x10, %ecx # 0x10 dwords = 0x40 bytes |
| |
| cld |
| repz movsl |
| |
| /* initialize the current_partition number */ |
| movzbl ABS(install_partition), %eax |
| movl %eax, ABS(current_partition) |
| |
| 3: |
| /* load the next partition and modify the boot record */ |
| call 0f /* partition */ |
| jc 3f /* done */ |
| call 2f /* write to file */ |
| incl ABS(current_partition) |
| movw ABS(install_partition), %ax |
| addb %ah, %al /* Max partition number for install */ |
| cmpb %al, ABS(current_partition) |
| jbe 3b |
| 3: |
| /* all partitions have been installed. */ |
| |
| xorl %eax, %eax # exit code = 0 |
| |
| #ifdef __DOS_16 |
| |
| movb $0x4c, %ah // EXIT - TERMINATE WITH RETURN CODE in AL |
| int $0x21 // call DOS |
| |
| #else |
| xchgl %eax, %ebx # move exit code in EAX to EBX |
| movl $1, %eax # sys_exit |
| int $0x80 |
| #endif |
| |
| ret |
| |
| 1: |
| //---------------------------------------------------------------------------- |
| /* backup mbr */ |
| |
| /* auto backup */ |
| cmpl $1, ABS(backup_mbr) |
| jnz 1f |
| |
| /* check if the second sector consists of 512 dups of one byte */ |
| movb ABS(mbr_63_sectors + 0x200), %al |
| movl $ABS(mbr_63_sectors + 0x200), %edi |
| movl $0x200, %ecx |
| |
| cld |
| repz scasb |
| |
| jz 1f # yes, enable backup |
| |
| movl $0, ABS(backup_mbr) # no, do not backup |
| |
| 1: |
| |
| //---------------------------------------------------------------------------- |
| cmpl $0, ABS(backup_mbr) |
| jz 1f # will not backup |
| |
| movl $ABS(mbr_63_sectors), %esi |
| movl $ABS(mbr_63_sectors + 0x200), %edi |
| movl $0x80, %ecx # 0x80 dwords = 0x200 bytes |
| |
| cld |
| repz movsl |
| |
| 1: |
| |
| //---------------------------------------------------------------------------- |
| /* copy byte 0000 to 01b7 of grldr.mbr to ABS(mbr_63_sectors) */ |
| |
| movl $ABS(_start1), %esi |
| movl $ABS(mbr_63_sectors), %edi |
| movl $0x6e, %ecx # 0x6e dwords = 0x1b8 bytes |
| |
| cld |
| repz movsl |
| |
| /* modify ABS(mbr_floppy) bit */ |
| |
| movb ABS(mbr_floppy), %al |
| andb $0x01, %al |
| movb %al, ABS(mbr_63_sectors + 2) |
| |
| /* modify ABS(mbr_osbr) bit */ |
| |
| movb ABS(mbr_osbr), %al |
| andb $0x01, %al |
| shlb $1, %al |
| orb %al, ABS(mbr_63_sectors + 2) |
| |
| /* modify ABS(duce) bit */ |
| |
| movb ABS(duce), %al |
| andb $0x01, %al |
| shlb $2, %al |
| orb %al, ABS(mbr_63_sectors + 2) |
| |
| /* modify ABS(boot_prevmbr) bit */ |
| |
| movb ABS(boot_prevmbr), %al |
| notb %al |
| andb $0x01, %al |
| rorb $1, %al |
| orb %al, ABS(mbr_63_sectors) + 2 |
| |
| /* modify ABS(time_out) byte */ |
| |
| movb ABS(time_out), %al |
| movb %al, ABS(mbr_63_sectors) + 3 |
| |
| /* modify ABS(hot_key) byte */ |
| |
| movw ABS(hot_key), %ax |
| movw %ax, ABS(mbr_63_sectors) + 4 |
| |
| /* modify ABS(preferred_drive) byte */ |
| |
| movb ABS(preferred_drive), %al |
| movb %al, ABS(mbr_63_sectors) + 6 |
| |
| /* modify ABS(preferred_partition) byte */ |
| |
| movb ABS(preferred_partition), %al |
| movb %al, ABS(mbr_63_sectors) + 7 |
| |
| /* copy byte 0400 and the rest of grldr.mbr to ABS(mbr_63_sectors) */ |
| |
| movl $ABS(_start1 + 0x400), %esi |
| movl $ABS(mbr_63_sectors + 0x400), %edi |
| movl $((pre_stage2_start - _start1 - 0x400) / 4), %ecx |
| |
| cld |
| repz movsl |
| |
| //---------------------------------------------------------------------------- |
| 2: /* label for the above floppy code to jump */ |
| |
| /* OK. Now write file! */ |
| |
| xorl %eax, %eax |
| |
| cmpw $2, ABS(read_only) |
| jne 3f |
| |
| pushl %ebx # file descriptor, or 0 if specified BIOS drive |
| |
| /* for safety, don't write too many sectors */ |
| cmpl $0xffffffff, ABS(install_partition) |
| jne 1f |
| cmpl $0xffffffff, ABS(floppy) |
| je 2f |
| 1: |
| cmpl $4, ABS(sectors_to_write) |
| jbe 1f |
| movl $4, ABS(sectors_to_write) |
| jmp 1f |
| 2: |
| cmpl $((pre_stage2_start - _start1) / 512), ABS(sectors_to_write) |
| jbe 1f |
| movl $((pre_stage2_start - _start1) / 512), ABS(sectors_to_write) |
| 1: |
| #ifdef __DOS_16 |
| |
| xorl %eax, %eax |
| cmpl $0xff, ABS(bios_drive_number) |
| je 1f |
| movb $0x03, %ah # write to disk |
| movb ABS(sectors_to_write), %al |
| // cmpl $0xffffffff, ABS(floppy) |
| // je 2f |
| // movb $4, %al # write 4 sectors if it is floppy |
| //2: |
| movw $ABS(mbr_63_sectors), %bx |
| movw $1, %cx |
| movw ABS(bios_drive_number), %dx |
| int $0x13 |
| jmp 2f |
| 1: |
| //WRITE TO FILE OR DEVICE |
| |
| //AH = 40h |
| //BX = file handle |
| //CX = number of bytes to write |
| //DS:DX -> data to write |
| |
| //Return: |
| //CF clear if successful AX = number of bytes actually written |
| //CF set on error AX = error code (05h,06h) |
| movl $0x4000, %eax |
| movl ABS(sectors_to_write), %ecx |
| shll $9, %ecx |
| //movl $(pre_stage2_start - _start1), %ecx |
| // cmpl $0xffffffff, ABS(floppy) |
| // je 1f |
| // movl $0x800, %ecx # write 4 sectors if it is floppy |
| //1: |
| movl $ABS(mbr_63_sectors), %edx |
| int $0x21 |
| 2: |
| jnc 1f |
| negl %eax |
| 1: |
| #else |
| /* ssize_t write(int fd, const void *buf, size_t count) */ |
| |
| movl $4, %eax # sys_write |
| movl $ABS(mbr_63_sectors), %ecx |
| movl ABS(sectors_to_write), %edx |
| shll $9, %edx |
| //movl $(pre_stage2_start - _start1), %edx # length of grldr.mbr |
| // cmpl $0xffffffff, ABS(floppy) |
| // je 1f |
| // movl $0x800, %edx # write 4 sectors if it is floppy |
| //1: |
| int $0x80 |
| #endif |
| |
| popl %ebx # file descriptor, or 0 if specified BIOS drive |
| 3: |
| cmpl $0xffffffff, ABS(install_partition) |
| je 3f |
| |
| /* for install_partition, SF=0 when success, SF=1 when failure */ |
| testl %eax, %eax |
| ret |
| 3: |
| testl %eax, %eax |
| movl $ABS(msg_write_file), %ecx |
| js 4f /* error */ |
| |
| //---------------------------------------------------------------------------- |
| cmpl $0xffffffff, ABS(floppy) |
| jne 3f |
| |
| movl $ABS(msg_geometry_S), %ecx |
| call 8f /* linux_print */ |
| |
| movl ABS(probed_sectors_per_track), %eax |
| call 6f /* print decimal number */ |
| |
| movl $ABS(msg_geometry_H), %ecx |
| call 8f /* linux_print */ |
| |
| movl ABS(probed_heads), %eax |
| call 6f /* print decimal number */ |
| |
| movl $ABS(msg_success), %ecx |
| call 8f /* linux_print */ |
| 3: |
| //success: |
| |
| # EBX=file descriptor, or 0 if specified BIOS drive |
| |
| xorl %eax, %eax # exit code = 0 |
| |
| jmp 1f |
| |
| //error: |
| 4: |
| # EBX=file descriptor, or 0 if specified BIOS drive |
| |
| testl %ecx, %ecx |
| jz 2f |
| call 8f /* linux_print */ |
| 2: |
| movl $ABS(msg_usage), %ecx |
| call 8f /* linux_print */ |
| |
| movl $1, %eax # exit code = 1 |
| |
| 1: |
| testl %ebx, %ebx |
| jz 1f |
| |
| pushl %eax # exit code |
| |
| #ifdef __DOS_16 |
| |
| movb $0x3e, %ah // close file (BX = file handle) |
| int $0x21 |
| jnc 2f |
| negl %eax /* EAX < 0 */ |
| 2: |
| #else |
| |
| /* int close(int fd); */ |
| movl $6, %eax # sys_close |
| int $0x80 |
| #endif |
| movl $ABS(msg_close_file), %ecx |
| testl %eax, %eax |
| |
| popl %eax # exit code |
| |
| jns 1f |
| |
| call 8f /* linux_print */ |
| |
| //exit: |
| 1: |
| #ifdef __DOS_16 |
| |
| movb $0x4c, %ah // EXIT - TERMINATE WITH RETURN CODE in AL |
| int $0x21 // call DOS |
| |
| #else |
| xchgl %eax, %ebx # move exit code in EAX to EBX |
| movl $1, %eax # sys_exit |
| int $0x80 |
| #endif |
| |
| ret |
| |
| //---------------------------------------------------------------------------- |
| //floppy: |
| 5: |
| |
| pushal |
| |
| /* First, try ext2 */ |
| |
| cmpw $0xEF53, 0x438(iSI) /* Magic signature */ |
| jnz 1f |
| xorl %eax, %eax |
| cmpl %eax, 0x400(iSI) /* s_inodes_count */ |
| jz 1f |
| cmpl %eax, 0x404(iSI) /* s_blocks_count */ |
| jz 1f |
| cmpw %ax, 0x458(iSI) /* s_inode_size, usually 0x80 */ |
| jz 1f |
| cmpl %eax, 0x420(iSI) /* s_blocks_per_group */ |
| jz 1f |
| cmpl %eax, 0x428(iSI) /* s_inodes_per_group */ |
| jz 1f |
| movl 0x414(iSI), %eax /* s_first_data_block */ |
| movw %ax, %bx /* BX=1 for 1K block, 0 otherwise */ |
| shrl $1, %eax /* must be 0 */ |
| jnz 1f |
| movl 0x418(iSI), %ecx /* s_log_block_size */ |
| cmpl $4, %ecx /* max size of block is 16K */ |
| ja 1f |
| negw %cx /* CF clear for 1K block, set otherwise */ |
| adcw %ax, %bx |
| decw %bx |
| jnz 1f |
| |
| /* BX = 0 */ |
| |
| /* super block is sane */ |
| |
| /* is EXT2 allowed write? */ |
| |
| testl $0x10, ABS(fstypes) |
| jnz 2f |
| /* EXT2 write not allowed */ |
| |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_ext2_deny), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| 2: |
| /* write to ext2 boot area */ |
| |
| cld |
| movl $ABS(_start1 + 0x800), %esi /* points to the 5th sector */ |
| movl $ABS(mbr_63_sectors), %edi |
| lodsw /* The first 2 byte: short jmp */ |
| LEAL 0x400(%edi), %esi /* ESI points to super block */ |
| stosw |
| |
| /* lba indicator byte is not used. so we shouldn't touch it. */ |
| |
| /* check lba-chs-mode specified, 1 byte */ |
| cmpl $-1, ABS(lba) /* lba-chs-mode not specified? */ |
| je 2f /* yes, do nothing. */ |
| |
| #if 0 |
| movb $0x42, %al /* initialize to lba mode. */ |
| cmpl $0, ABS(lba) /* chs ? */ |
| jnz 10f /* no, it is not chs.*/ |
| movb $0x02, %al /* yes, it is chs. */ |
| 10: |
| #else |
| /* if specified lba or chs, we simply place a 0x90. */ |
| movb $0x90, %al |
| #endif |
| stosb |
| decl %edi |
| 2: |
| |
| addl $(1+10), %edi /* skip 10-byte OEM name */ |
| |
| /* Sectors per block, byte */ |
| |
| movb 0x18(iSI), %cl /* s_log_block_size */ |
| movl $2, %eax |
| shlw %cl, %ax |
| stosb |
| |
| /* Bytes per block, word */ |
| |
| shlw $9, %ax /* block size is word wide */ |
| stosw |
| |
| /* Pointers covered by an indirect block, dword */ |
| /* Pointers per block, dword */ |
| |
| shrw $2, %ax |
| pushl %eax /* Pointers per block */ |
| addb $8, %cl |
| shll %cl, %eax |
| stosl /* Pointers covered by an indirect block */ |
| popl %eax |
| stosl /* Pointers per block */ |
| |
| /* Sectors per track, word */ |
| |
| cmpl $0xFFFFFF3F, ABS(sectors_per_track) |
| je 10f |
| movb ABS(sectors_per_track), %al |
| cbw |
| stosw |
| subl $2, %edi |
| 10: |
| addl $2, %edi |
| |
| /* Number of heads, word */ |
| |
| cmpl $0xFFFF00FF, ABS(heads) |
| je 10f |
| movw ABS(heads), %ax |
| stosw |
| subl $2, %edi |
| 10: |
| addl $2, %edi |
| |
| /* hidden sectors(i.e., partition start), dword */ |
| |
| movb ABS(floppy), %al /* partition number(0xFF for floppy) */ |
| cmpb $0xff, %al |
| jne 10f |
| /* real floppy */ |
| cmpl $0xffffffff, ABS(start_sector) |
| sete %al |
| movzbl %al, %eax |
| addl ABS(start_sector), %eax |
| stosl |
| jmp 11f |
| 10: |
| /* hard drive partition */ |
| addl $4, %edi |
| cmpl $0xffffffff, ABS(start_sector) |
| je 11f |
| movl ABS(start_sector), %eax |
| subl $4, %edi |
| stosl |
| 11: |
| |
| /* total sectors, dword */ |
| |
| movl %es:(iDI), %eax |
| cmpl %eax, ABS(total_sectors) |
| jbe 10f |
| movl ABS(total_sectors), %eax |
| 10: |
| stosl |
| |
| /* drive number, byte */ |
| |
| //this byte is not used. |
| incl %edi |
| |
| /* partition number, byte */ |
| |
| movb ABS(floppy), %al |
| stosb |
| |
| /* reserved, word */ |
| |
| incl %edi |
| incl %edi |
| |
| /* Number of inodes per group, dword */ |
| |
| movl 0x28(iSI), %eax /* s_inodes_per_group */ |
| stosl |
| |
| /* block number for group descriptors, dword */ |
| |
| movl 0x14(iSI), %eax /* s_first_data_block */ |
| incw %ax |
| stosl |
| |
| /* Machine code begins at offset 0x30, 462 bytes plus |
| * 2 bytes of boot signature */ |
| |
| movl $ABS(_start1 + 0x830), %esi |
| movl $(464 / 4), %ecx |
| repz movsl |
| |
| movl $1, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_ext2_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| |
| 1: |
| /* Secondly, try FAT12/16/32/NTFS */ |
| |
| cld |
| cmpw $0xAA55, 0x1fe(iSI) /* boot signature */ |
| jne 1f /* not a normal BPB */ |
| cmpw $0x200, 0x0b(iSI) /* bytes per sector */ |
| jne 1f /* not a normal BPB */ |
| movb 0x0d(iSI), %al /* sectors per cluster */ |
| testb %al, %al |
| jz 1f /* invalid if = 0 */ |
| movb %al, %cl |
| movw $128, %ax |
| divb %cl /* quo=AL, rem=AH */ |
| testb %ah, %ah |
| jnz 1f /* invalid if not 2^n */ |
| movw 0x18(iSI), %ax /* sectors per track */ |
| testw %ax, %ax |
| jz 1f /* invalid if = 0 */ |
| cmpw $63, %ax |
| ja 1f /* invalid if > 63 */ |
| movw 0x1a(iSI), %ax /* number of heads */ |
| decw %ax /* Max head number, should be a byte */ |
| testb %ah, %ah /* should be 0 */ |
| jnz 1f /* invalid if number of heads > 256 */ |
| cmpb $0xf0, 0x15(iSI) /* media descriptor */ |
| jb 1f |
| |
| // movw $0x0600, %bx /* FAT12/FAT16 */ |
| // movw $0x003c, %cx /* FAT12/FAT16 */ |
| |
| movb 0x10(iSI), %al /* number of FATs(NTFS:0, FAT:1,2) */ |
| cmpb $2, %al |
| ja 1f /* abnormal FAT */ |
| movw 0x11(iSI), %ax /* max root entries */ |
| testw %ax, %ax |
| jnz 2f /* FAT12/FAT16 */ |
| |
| /* FAT32 or NTFS */ |
| movw 0x13(iSI), %ax /* total sectors(small) */ |
| testw %ax, %ax |
| jnz 1f /* invalid FAT32 BPB */ |
| movw 0x16(iSI), %ax /* sectors per FAT(small) */ |
| testw %ax, %ax |
| jnz 1f /* invalid FAT32 BPB */ |
| movb 0x10(iSI), %al /* number of FATs(NTFS:0, FAT:1,2) */ |
| testb %al, %al |
| jz 4f /* NTFS */ |
| |
| /* FAT32 */ |
| movl 0x20(iSI), %eax /* FAT32 total sectors */ |
| testl %eax, %eax |
| jz 1f |
| movl 0x24(iSI), %eax /* FAT32 sectors per FAT */ |
| testl %eax, %eax |
| jz 1f |
| /* sure it is FAT32 */ |
| |
| /* is FAT32 allowed write? */ |
| |
| testl $0x04, ABS(fstypes) |
| jnz 3f |
| /* FAT32 write not allowed */ |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat32_deny), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| 3: |
| /* write to FAT32 boot area */ |
| |
| cld |
| movl $ABS(_start1 + 0x400), %esi /* points to the 3rd sector */ |
| movl $ABS(mbr_63_sectors), %edi |
| lodsw /* The first 2 byte: short jmp */ |
| //leal 0x400(%edi), %esi /* ESI points to super block */ |
| stosw |
| |
| /* check lba-chs-mode specified, 1 byte */ |
| cmpl $-1, ABS(lba) /* lba-chs-mode not specified? */ |
| je 3f /* yes, do nothing. */ |
| movb $0x0e, %al /* initialize to lba mode. */ |
| cmpl $0, ABS(lba) /* chs ? */ |
| jnz 10f /* no, it is not chs.*/ |
| movb $0x90, %al /* yes, it is chs. */ |
| 10: |
| stosb |
| decl %edi |
| 3: |
| addl $(1+8+2+1+2+1+2+2+1+2), %edi |
| addl $(1+8+2+1+2+1+2+2+1+2), %esi |
| /* skip 8-byte OEM name and Bytes per sector */ |
| |
| /* and Sectors per cluster, byte */ |
| /* and Reserved sectors, word */ |
| /* and Number of FATs, byte */ |
| /* (Max root dir entries)Must be 0, word */ |
| /* (Total sectors small)Must be 0, word */ |
| /* Media descriptor, byte */ |
| /* (Sectors per FAT)Must be 0, word */ |
| /* sectors per track, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| je 3f |
| movb ABS(sectors_per_track), %al |
| cbw |
| subl $2, %edi |
| stosw |
| 3: |
| |
| /* number of heads, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffff00ff, ABS(heads) |
| je 3f |
| movw ABS(heads), %ax |
| subl $2, %edi |
| stosw |
| 3: |
| |
| /* hidden sectors(i.e., partition start), dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0xffffffff, ABS(start_sector) |
| je 3f |
| movl ABS(start_sector), %eax |
| subl $4, %edi |
| stosl |
| 3: |
| |
| /* total sectors, dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0, ABS(total_sectors) |
| je 3f |
| movl ABS(total_sectors), %eax |
| subl $4, %edi |
| stosl |
| 3: |
| |
| /* FAT32 sectors per FAT, dword, etc... */ |
| |
| addl $(4+2+2+4+2+2+12+1+1+1+4+11+8), %esi |
| addl $(4+2+2+4+2+2+12+1+1+1+4+11+8), %edi |
| |
| //movl $0xFFB6FCFA, %eax /* CLI, CLD, MOV DH,FF */ |
| lodsw |
| stosw |
| lodsb |
| stosb |
| lodsb |
| |
| //decl %edi |
| |
| /* partition number, byte */ |
| |
| movb ABS(floppy), %al |
| stosb |
| |
| /* Machine code begins at offset 0x5e, 416 bytes without |
| * the ending 2 bytes of boot signature */ |
| |
| //movl $ABS(_start1 + 0x45e), %esi |
| movl $(416 / 4), %ecx |
| repz movsl |
| |
| movl $1, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat32_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| 4: |
| /* NTFS */ |
| movl 0x20(iSI), %eax /* FAT32 total sectors */ |
| testl %eax, %eax |
| jnz 1f |
| //movw 0x11(%si), %ax /* max root entries */ |
| //testw %ax, %ax |
| //jnz 1f |
| movw 0x0e(iSI), %ax /* reserved sectors */ |
| testw %ax, %ax |
| jnz 1f |
| /* sure it is NTFS */ |
| |
| /* is NTFS allowed write? */ |
| |
| testl $0x08, ABS(fstypes) |
| jnz 3f |
| /* NTFS write not allowed */ |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_ntfs_deny), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| 3: |
| /* write to NTFS boot area */ |
| |
| movl $ABS(mbr_63_sectors), %edi |
| LEAL 0x400(%edi), %esi /* ESI points to super block */ |
| |
| /* hidden sectors(i.e., partition start), dword */ |
| cmpl $0xffffffff, ABS(start_sector) |
| je 3f |
| movl ABS(start_sector), %eax |
| movl %eax, 0x1c(iDI) |
| 3: |
| |
| /* drive number needn't touch */ |
| |
| /* partition number */ |
| |
| call 4f |
| jc 5f |
| movl 0x06(iSI), %eax /* NT 4 */ |
| cmpl $0x03E8B800, %eax /* MOV ES,AX */ |
| jnz 3f |
| |
| cmpl $0x680007E8, 0x84(iDI) /* call 008e; push (0D00) */ |
| jnz 3f |
| movb $0xB6, %al /* 0xB6="MOV DH,imm8" */ |
| movb ABS(floppy), %ah /* partition number */ |
| movw %ax, 0x0a(iSI) |
| |
| movl $4, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_ntfs_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| 3: |
| /* NT 5.0 */ |
| |
| cmpl $0x680053E8, 0x71(iDI) /* call 00C7; push (0D00) */ |
| jnz 5f |
| |
| movl $0x4b, %ebx |
| movl (iBX, iSI), %eax /* NT 5 */ |
| cmpl $0x03E8B800, %eax /* MOV ES,AX */ |
| jz 3f |
| |
| movl $0x79, %ebx |
| movl (iBX, iSI), %eax /* NT 5p */ |
| cmpl $0x03E8B800, %eax /* MOV ES,AX */ |
| jnz 5f |
| 3: |
| movb $0xB6, %al /* 0xB6="MOV DH,imm8" */ |
| movb ABS(floppy), %ah /* partition number */ |
| movw %ax, 4(iBX, iSI) |
| |
| movl $4, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_ntfs_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| 5: |
| /* No NTFS boot record present */ |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_no_ntfs_boot_record), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| |
| 4: /* change NT to GR */ |
| |
| pushal |
| cld |
| movl $0x00520047, 0x202(iDI) /* G R L D R */ |
| addl $0x0100, %edi |
| movl $0x00fa, %ecx |
| movw $0x014e, %ax /* AL="N", AH=Carry for SAHF below */ |
| movl $0x52444c54, %ebx /* "TLDR" */ |
| |
| 3: |
| repnz scasb /* find "N" */ |
| jcxz 4f /* gets the end, exit */ |
| cmpl %ebx, (iDI) /* is it "NTLDR"? */ |
| jnz 3b /* no, continue to find */ |
| |
| /* "NTLDR" is found, so we believe it is NT boot sector. */ |
| |
| movw $0x5247, -1(iDI) /* change "NT" to "GR" */ |
| |
| /* CF=0 for now */ |
| |
| lahf /* Load Flags into AH */ |
| /* AH = SF:ZF:xx:AF:xx:PF:xx:CF */ |
| /* AH = binary xxxxxxx0 */ |
| jmp 3b |
| 4: |
| sahf /* Store AH into flags SF ZF xx AF xx PF xx CF */ |
| |
| /* CF=0 means "NTLDR" is found, CF=1 means "NTLDR" is not found. */ |
| |
| popal |
| ret |
| 2: |
| /* FAT12/FAT16 */ |
| movb 0x10(iSI), %al /* number of FATs(NTFS:0, FAT:1,2) */ |
| testb %al, %al |
| jz 1f |
| movw 0x16(iSI), %ax /* sectors per FAT(small) */ |
| testw %ax, %ax |
| jz 1f |
| // movw $(FAT16_message - _start1), %si |
| cmpw $12, %ax |
| ja 4f /* FAT16 */ |
| /* sure it is FAT12 */ |
| |
| /* is FAT12 allowed write? */ |
| |
| testl $0x01, ABS(fstypes) |
| jnz 2f |
| /* FAT12 write not allowed */ |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat12_deny), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| 2: |
| /* write to FAT12 boot area */ |
| |
| cld |
| movl $ABS(_start1 + 0x600), %esi /* points to the 4th sector */ |
| movl $ABS(mbr_63_sectors), %edi |
| lodsw /* The first 2 byte: short jmp */ |
| //leal 0x400(%edi), %esi /* ESI points to super block */ |
| stosw |
| |
| /* check lba-chs-mode specified, 1 byte */ |
| cmpl $-1, ABS(lba) /* lba-chs-mode not specified? */ |
| je 2f /* yes, do nothing. */ |
| movb $0x0e, %al /* initialize to lba mode. */ |
| cmpl $0, ABS(lba) /* chs ? */ |
| jnz 10f /* no, it is not chs.*/ |
| movb $0x90, %al /* yes, it is chs. */ |
| 10: |
| stosb |
| decl %edi |
| 2: |
| addl $(1+8+2+1+2+1+2+2+1+2), %edi |
| addl $(1+8+2+1+2+1+2+2+1+2), %esi |
| /* skip 8-byte OEM name and Bytes per sector */ |
| |
| /* and Sectors per cluster, byte */ |
| /* and Reserved sectors, word */ |
| /* and Number of FATs, byte */ |
| /* (Max root dir entries)Must be 0, word */ |
| /* (Total sectors small)Must be 0, word */ |
| /* Media descriptor, byte */ |
| /* (Sectors per FAT)Must be 0, word */ |
| /* sectors per track, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| je 2f |
| movb ABS(sectors_per_track), %al |
| cbw |
| subl $2, %edi |
| stosw |
| 2: |
| |
| /* number of heads, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffff00ff, ABS(heads) |
| je 2f |
| movw ABS(heads), %ax |
| subl $2, %edi |
| stosw |
| 2: |
| |
| /* hidden sectors(i.e., partition start), dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0xffffffff, ABS(start_sector) |
| je 2f |
| movl ABS(start_sector), %eax |
| subl $4, %edi |
| stosl |
| 2: |
| |
| /* total sectors, dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0, ABS(total_sectors) |
| je 2f |
| movl ABS(total_sectors), %eax |
| subl $4, %edi |
| stosl |
| 2: |
| |
| /* drive number, byte, etc... */ |
| |
| addl $(1+1+1+4+11+8), %esi |
| addl $(1+1+1+4+11+8), %edi |
| |
| //movl $0xFFB6FCFA, %eax /* CLI, CLD, MOV DH,FF */ |
| lodsw |
| stosw |
| lodsb |
| stosb |
| lodsb |
| |
| //decl %edi |
| |
| /* partition number, byte */ |
| |
| movb ABS(floppy), %al |
| stosb |
| |
| /* Machine code begins at offset 0x42, 444 bytes without |
| * the ending 2 bytes of boot signature */ |
| |
| //movl $ABS(_start1 + 0x642), %esi |
| movl $(444 / 4), %ecx |
| repz movsl |
| |
| movl $1, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat12_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| |
| 4: |
| |
| /* sure it is FAT16 */ |
| |
| /* is FAT16 allowed write? */ |
| |
| testl $0x02, ABS(fstypes) |
| jnz 2f |
| /* FAT16 write not allowed */ |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat16_deny), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| 2: |
| /* write to FAT16 boot area */ |
| |
| cld |
| movl $ABS(_start1 + 0x600), %esi /* points to the 4th sector */ |
| movl $ABS(mbr_63_sectors), %edi |
| lodsw /* The first 2 byte: short jmp */ |
| //leal 0x400(%edi), %esi /* ESI points to super block */ |
| stosw |
| |
| /* check lba-chs-mode specified, 1 byte */ |
| cmpl $-1, ABS(lba) /* lba-chs-mode not specified? */ |
| je 2f /* yes, do nothing. */ |
| movb $0x0e, %al /* initialize to lba mode. */ |
| cmpl $0, ABS(lba) /* chs ? */ |
| jnz 10f /* no, it is not chs.*/ |
| movb $0x90, %al /* yes, it is chs. */ |
| 10: |
| stosb |
| decl %edi |
| 2: |
| addl $(1+8+2+1+2+1+2+2+1+2), %edi |
| addl $(1+8+2+1+2+1+2+2+1+2), %esi |
| /* skip 8-byte OEM name and Bytes per sector */ |
| |
| /* and Sectors per cluster, byte */ |
| /* and Reserved sectors, word */ |
| /* and Number of FATs, byte */ |
| /* (Max root dir entries)Must be 0, word */ |
| /* (Total sectors small)Must be 0, word */ |
| /* Media descriptor, byte */ |
| /* (Sectors per FAT)Must be 0, word */ |
| /* sectors per track, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffffff3f, ABS(sectors_per_track) |
| je 2f |
| movb ABS(sectors_per_track), %al |
| cbw |
| subl $2, %edi |
| stosw |
| 2: |
| |
| /* number of heads, word */ |
| lodsw |
| addl $2, %edi |
| cmpl $0xffff00ff, ABS(heads) |
| je 2f |
| movw ABS(heads), %ax |
| subl $2, %edi |
| stosw |
| 2: |
| |
| /* hidden sectors(i.e., partition start), dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0xffffffff, ABS(start_sector) |
| je 2f |
| movl ABS(start_sector), %eax |
| subl $4, %edi |
| stosl |
| 2: |
| |
| /* total sectors, dword */ |
| lodsl |
| addl $4, %edi |
| cmpl $0, ABS(total_sectors) |
| je 2f |
| movl ABS(total_sectors), %eax |
| subl $4, %edi |
| stosl |
| 2: |
| |
| /* drive number, byte, etc... */ |
| |
| addl $(1+1+1+4+11+8), %esi |
| addl $(1+1+1+4+11+8), %edi |
| |
| //movl $0xFFB6FCFA, %eax /* CLI, CLD, MOV DH,FF */ |
| lodsw |
| stosw |
| lodsb |
| stosb |
| lodsb |
| |
| //decl %edi |
| |
| /* partition number, byte */ |
| |
| movb ABS(floppy), %al |
| stosb |
| |
| /* Machine code begins at offset 0x42, 444 bytes without |
| * the ending 2 bytes of boot signature */ |
| |
| //movl $ABS(_start1 + 0x642), %esi |
| movl $(444 / 4), %ecx |
| repz movsl |
| |
| movl $1, ABS(sectors_to_write) |
| |
| movl $ABS(msg_fstype_fat16_allow), %ecx |
| call 8f /* linux_print */ |
| |
| clc |
| popal |
| ret |
| 1: |
| |
| movl $0, ABS(sectors_to_write) |
| |
| movl $ABS(msg_unsupported_fstype), %ecx |
| call 8f /* linux_print */ |
| |
| stc |
| popal |
| ret |
| |
| //---------------------------------------------------------------------------- |
| //print decimal number in EAX |
| 6: |
| /* print EAX value in decimal format */ |
| pushal |
| |
| #if 0 |
| cld |
| movl $ABS(number_digits), %edi |
| xchgl %eax, %edx // save EAX to EDX |
| movw $0x2020, %ax // two spaces |
| stosw |
| stosw |
| stosw |
| stosw |
| stosw |
| decl %edi // EDI points to the last digit |
| xchgl %eax, %edx // restore EAX from EDX |
| #endif |
| std |
| movl $ABS(number_digits + 9), %edi |
| movl $10, %ebp |
| 1: |
| xorl %edx, %edx |
| divl %ebp // quo=EAX, rem=EDX |
| xchgl %eax, %edx |
| orb $0x30, %al |
| stosb |
| xchgl %eax, %edx |
| testl %eax, %eax |
| jnz 1b |
| |
| /* all digits are stored */ |
| incl %edi // points to the digit string |
| |
| movl %edi, %ecx |
| call 8f /* linux_print */ |
| |
| cld |
| popal |
| ret |
| |
| //---------------------------------------------------------------------------- |
| //parse_number: |
| 7: |
| |
| /* input: EDI points to the number |
| * EBX upper limit of the number |
| * output: EBX the value of the number |
| * EDX changed |
| * ESI changed |
| * EBP changed |
| * CF=1 failure |
| * CF=0 success |
| */ |
| |
| pushl %eax |
| pushl %ebx /* upper limit */ |
| cld |
| movl %edi, %esi |
| movl $0xffffffff, %edx |
| xorl %ebx, %ebx |
| lodsw |
| cmpw $0x5830, %ax /* 0X */ |
| je 1f |
| cmpw $0x7830, %ax /* 0x */ |
| je 1f |
| |
| /* decimal */ |
| decl %esi |
| decl %esi |
| movl $10, %ebp |
| 2: |
| xorl %eax, %eax |
| lodsb |
| cmpb $0, %al |
| je 4f /* CF=0 */ |
| cmpb $0x30, %al |
| jb 3f |
| cmpb $0x39, %al |
| ja 3f |
| subb $0x30, %al |
| pushl %eax |
| movl %ebx, %eax |
| mull %ebp |
| movl %eax, %ebx |
| popl %eax |
| jc 3f |
| addl %eax, %ebx |
| jc 3f |
| popl %eax |
| pushl %eax /* upper limit */ |
| cmpl %eax, %ebx |
| ja 3f |
| jmp 2b |
| 1: |
| |
| /* hex */ |
| movl $16, %ebp |
| 2: |
| xorl %eax, %eax |
| lodsb |
| cmpb $0, %al |
| je 4f /* CF=0 */ |
| cmpb $0x30, %al |
| jb 3f |
| cmpb $0x39, %al |
| jbe 1f |
| orb $0x20, %al |
| cmpb $0x61, %al |
| jb 3f |
| cmpb $0x66, %al |
| ja 3f |
| subb $0x27, %al |
| 1: |
| subb $0x30, %al |
| pushl %eax |
| movl %ebx, %eax |
| mull %ebp |
| movl %eax, %ebx |
| popl %eax |
| jc 3f |
| addl %eax, %ebx |
| jc 3f |
| popl %eax |
| pushl %eax /* upper limit */ |
| cmpl %eax, %ebx |
| ja 3f |
| jmp 2b |
| |
| 3: |
| stc |
| popl %eax /* upper limit */ |
| popl %eax |
| ret |
| 4: |
| testl %edx, %edx /* CF=0 */ |
| jnz 3b |
| popl %eax /* upper limit */ |
| popl %eax |
| ret |
| |
| //---------------------------------------------------------------------------- |
| //linux_print: |
| 8: |
| |
| /* print a message. |
| * input: ECX points to message string |
| * output: message is displayed on the stdout device |
| */ |
| |
| /* ssize_t write(int fd, const void *buf, size_t count) */ |
| |
| pushal |
| |
| #ifdef __DOS_16 |
| |
| cld |
| movl %ecx, %esi |
| // movw %si, %dx |
| // movb $0x09, %ah // WRITE STRING TO STANDARD OUTPUT |
| // int $0x21 // call DOS |
| // ret |
| |
| 1: |
| lodsb (%si), %al // get token |
| cmpb $0, %al // end of string? |
| je 1f |
| #if 0 |
| /* use BIOS independent of DOS */ |
| xorw %bx, %bx // video page 0 |
| movb $0x0e, %ah // print it |
| int $0x10 // via TTY mode |
| #else |
| /* use stdout for redirection of the output */ |
| movb %al, %dl // character to write |
| movb $0x02, %ah // WRITE CHARACTER TO STANDARD OUTPUT |
| int $0x21 // call DOS |
| #endif |
| jmp 1b // until done |
| 1: |
| |
| #else |
| pushl %ecx |
| movl %ecx, %edi # scan the message string ... |
| movl $(msg_end - msg_start), %ecx |
| movb $0, %al # ... find the ending zero byte |
| |
| cld |
| repnz scasb |
| |
| movl %edi, %edx |
| popl %ecx # ECX points to the message |
| subl %ecx, %edx # EDX=message length |
| decl %edx # discard the ending zero byte |
| |
| movl $4, %eax # sys_write |
| movl $1, %ebx # file descriptor = stdout |
| int $0x80 |
| #endif |
| |
| popal |
| ret |
| |
| //---------------------------------------------------------------------------- |
| //probe_geometry: |
| 9: |
| pushal |
| |
| addl $0x200, %esi |
| |
| movw $0, ABS(Cmax) |
| movl $0, ABS(Hmax) |
| movw $0, ABS(Smax) |
| |
| movl $0, ABS(i) # partition number |
| 1: |
| cmpl $4, ABS(i) |
| jae 1f |
| |
| /* the boot indicator must be 0x80(bootable) or 0(non-bootable) */ |
| |
| movl ABS(i), %ebx |
| movl ABS(i), %edi |
| shll $4, %ebx # EBX = ABS(i) * 16 |
| movb -66(iBX, iSI), %al # boot_indicator |
| shlb $1, %al |
| jnz 6f /* geometry_probe_failed */ |
| |
| /* check if the entry is empty, ABS(i).e., all the 16 bytes are 0 */ |
| |
| movl -66(iBX, iSI), %eax |
| orl -62(iBX, iSI), %eax |
| orl -58(iBX, iSI), %eax |
| orl -54(iBX, iSI), %eax |
| jz 2f # empty partition entry |
| |
| /* valid partitions never start at 0, because this is where the MBR |
| * lives; and more, the number of total sectors should be non-zero. |
| */ |
| |
| cmpl $0, -58(iBX, iSI) # start_lba |
| jz 6f /* geometry_probe_failed */ |
| |
| cmpl $0, -54(iBX, iSI) # total_sectors |
| jz 6f /* geometry_probe_failed */ |
| |
| /* the partitions should not overlap each other */ |
| |
| movl $0, ABS(j) |
| 3: |
| cmpl %edi, ABS(j) # i = EDI |
| jae 3f |
| |
| movl -58(iBX, iSI), %ecx # start_lba |
| |
| movl ABS(j), %edx |
| shll $4, %edx # EDX = ABS(j) * 16 |
| MOVL -58(%edx, %esi), %eax # start_lba |
| |
| cmpl %ecx, %eax |
| jae 4f |
| subl %eax, %ecx |
| CMPL -54(%edx, %esi), %ecx # total_sectors |
| jmp 5f |
| 4: |
| subl %ecx, %eax |
| cmpl -54(iBX, iSI), %eax # total_sectors |
| 5: |
| jb 6f /* geometry_probe_failed */ |
| |
| incl ABS(j) |
| jmp 3b |
| 3: |
| |
| /* the start cylinder number */ |
| |
| movzwl -64(iBX, iSI), %eax # start_sector_cylinder |
| |
| movl %eax, %edx |
| andw $0x003f, %dx |
| jz 6f /* geometry_probe_failed */ |
| |
| movw %dx, ABS(X) # the sector number |
| |
| cmpw %dx, ABS(Smax) |
| jae 3f |
| movw %dx, ABS(Smax) |
| 3: |
| movl -58(iBX, iSI), %ecx # start_lba |
| incl %ecx |
| subl %edx, %ecx |
| |
| movl $ABS(L), %edx |
| MOVL %ecx, (%edx, %edi, 8) # L[i] |
| |
| ///* partitions should not start at the first track, the MBR-track */ |
| //movw ABS(Smax), %dx |
| //cmpw %dx, -58(%ebx, %esi) # start_lba |
| //jb 6f /* geometry_probe_failed */ |
| |
| shrb $6, %al |
| xchgb %al, %ah |
| |
| movl $ABS(C), %edx |
| MOVW %ax, (%edx, %edi, 4) # C[i] |
| |
| cmpw %ax, ABS(Cmax) |
| jae 3f |
| movw %ax, ABS(Cmax) |
| 3: |
| |
| //movl ABS(i), %ebx |
| //shll $4, %ebx # EBX = ABS(i) * 16 |
| movzbl -65(iBX, iSI), %eax # start_head |
| movl $ABS(H), %edx |
| MOVL %eax, (%edx, %edi, 4) # H[i] |
| |
| cmpl %eax, ABS(Hmax) |
| jae 3f |
| movl %eax, ABS(Hmax) |
| 3: |
| |
| /* the end cylinder number */ |
| |
| movzwl -60(iBX, iSI), %eax # end_sector_cylinder |
| |
| movl %eax, %edx |
| andw $0x003f, %dx |
| jz 6f /* geometry_probe_failed */ |
| |
| movw %dx, ABS(Y) # the sector number |
| |
| cmpw %dx, ABS(Smax) |
| jae 3f |
| movw %dx, ABS(Smax) |
| 3: |
| movl -58(iBX, iSI), %ecx # start_lba |
| addl -54(iBX, iSI), %ecx # total_sectors |
| # XXX: possible overflow! |
| |
| subl %edx, %ecx |
| jb 6f /* geometry_probe_failed */ |
| |
| addl $4, %edi # EDI=i+4 |
| |
| movl $ABS(L), %edx |
| MOVL %ecx, (%edx, %edi, 8) # L[i+4] |
| |
| movl %ecx, %ebp # save ECX to EBP |
| |
| /* partitions should not start at the first track, the MBR-track */ |
| movw ABS(Smax), %dx |
| cmpw %dx, -58(iBX, iSI) # start_lba |
| jb 6f /* geometry_probe_failed */ |
| |
| shrb $6, %al |
| xchgb %al, %ah |
| |
| movl $ABS(C), %edx |
| MOVW %ax, (%edx, %edi, 4) # C[i+4] |
| |
| cmpw %ax, ABS(Cmax) |
| jae 3f |
| movw %ax, ABS(Cmax) |
| 3: |
| xchgl %eax, %ecx # save AX to CX |
| |
| //movl ABS(i), %ebx |
| //shll $4, %ebx # EBX = ABS(i) * 16 |
| movzbl -61(iBX, iSI), %eax # end_head |
| movl $ABS(H), %edx |
| MOVL %eax, (%edx, %edi, 4) # H[i+4] |
| |
| cmpl %eax, ABS(Hmax) |
| jae 3f |
| movl %eax, ABS(Hmax) |
| 3: |
| |
| /* Check the large disk partition -- Win98 */ |
| cmpw $63, ABS(Y) |
| jne 3f |
| cmpl %eax, ABS(Hmax) # EAX=H[i+4] |
| jne 3f |
| cmpw %cx, ABS(Cmax) # ECX=C[i+4] |
| jne 3f |
| |
| cmpl $254, %eax # EAX=ABS(Hmax) |
| jnb 4f |
| cmpw $1022, %cx # CX=ABS(Cmax) |
| jb 3f |
| 4: |
| movl $63, %edx # EDX=ABS(Y) |
| addl %edx, %ebp |
| incl %eax |
| mull %edx # EDX:EAX=product |
| # EDX=0 |
| # EAX high word = 0 |
| # AX=(Hmax+1)*63 |
| pushl %eax # EAX=(Hmax+1)*63 |
| incl %ecx |
| mull %ecx # EDX:EAX=product |
| # EDX=0 |
| cmpl %ebp, %eax |
| popl %eax # EAX=(Hmax+1)*63 |
| jnb 3f |
| |
| /* EDI=i+4 at this moment */ |
| |
| pushl %eax # EAX=(Hmax+1)*63 |
| subl $4, %edi # EDI=i |
| |
| movl $ABS(C), %ebx |
| MOVZWL (%ebx, %edi, 4), %eax # C[i] |
| |
| movl ABS(Hmax), %ebp # Hmax |
| incl %ebp |
| |
| pushl %eax # EAX=C[i] |
| |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %ecx # H[i] |
| |
| mull %ebp # EDX=0, EAX=product |
| addl %ecx, %eax |
| movl $63, %edx |
| mull %edx # EDX=0, EAX=product |
| |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %ebp # L[i] |
| |
| cmpl %ebp, %eax |
| popl %eax # EAX=C[i] |
| |
| jae 4f |
| |
| /* calculate CHS numbers from start LBA */ |
| |
| //pushl %eax # EAX=C[i] |
| |
| xorl %edx, %edx |
| xchgl %eax, %ebp # EBP=C[i], EDX:EAX=L[i] |
| |
| divl ABS(Y) # Y=63 |
| # quo=EAX, rem=EDX |
| incl %edx # sector number |
| cmpw %dx, ABS(X) |
| je 5f |
| cmpw $63, ABS(X) |
| jne 4f |
| 5: |
| xorl %edx, %edx |
| movl ABS(Hmax), %ebx |
| incl %ebx # EBX=Hmax+1 |
| divl %ebx # quo=EAX=cylinder number |
| # rem=EDX=head number |
| cmpl %edx, %ecx # ECX=H[i] |
| je 5f |
| decl %ebx # EBX=Hmax |
| cmpl %ebx, %ecx |
| jne 4f |
| 5: |
| /* EAX=calculated cylinder number, EBP=C[i] */ |
| |
| cmpl ABS(Cmax), %ebp |
| je 4f |
| andw $0x3ff, %ax # low 10 bit of calculated cylinder |
| cmpw %ax, %bp |
| //5: |
| // cmpw ABS(Cmax), %ax |
| // jne 4f |
| // cmpl ABS(Hmax), %ecx |
| // jne 4f |
| // cmpw $63, ABS(X) |
| 4: |
| popl %eax |
| jne 6f /* geometry_probe_failed */ |
| jmp 5f |
| 3: |
| |
| /* Check the large disk partition -- Win2K */ |
| |
| /* EDI=i+4 at this moment */ |
| cmpw $63, ABS(Y) |
| jne 3f |
| movl $ABS(H), %edx |
| MOVL (%edx, %edi, 4), %eax # H[i+4] |
| cmpl %eax, ABS(Hmax) # EAX=H[i+4] |
| jne 3f |
| |
| movl $ABS(L), %edx |
| MOVL (%edx, %edi, 8), %ebp # L[i+4] |
| |
| movl $ABS(C), %edx |
| MOVZWL (%edx, %edi, 4), %ecx # C[i+4] |
| |
| incl %ecx |
| incl %eax |
| |
| mull %ecx # EDX=0, EAX=product |
| mull ABS(Y) # Y=63, EDX=0, EAX=product |
| addl ABS(Y), %ebp |
| cmpl %ebp, %eax |
| jnb 3f |
| |
| movl ABS(Hmax), %eax |
| incl %eax |
| mull ABS(Y) # Y=63, EDX=0, EAX=product |
| |
| xorl %edx, %edx |
| xchgl %eax, %ebp # EBP=(Hmax+1)*63 |
| # EAX=L[i+4]+Y |
| |
| divl %ebp # EAX=quo, EDX=rem |
| testl %edx, %edx |
| jnz 3f |
| decl %eax |
| andl $0x3ff, %eax |
| decl %ecx |
| cmpl %eax, %ecx |
| jne 3f |
| |
| /* EDI=i+4 at this moment */ |
| |
| subl $4, %edi # EDI=i |
| |
| movl $ABS(C), %ebx |
| MOVL (%ebx, %edi, 4), %eax # C[i] |
| |
| pushl %eax |
| |
| mull %ebp # EBP=(Hmax+1)*63 |
| # EDX=0, EAX=product |
| |
| pushl %ebp # EBP=(Hmax+1)*63 |
| |
| xchgl %eax, %ebp # EBP=product |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %eax # H[i] |
| mull ABS(Y) # Y=63, EDX=0, EAX=H[i]*63 |
| |
| pushl %eax |
| |
| addl %eax, %ebp |
| |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %eax # L[i] |
| cmpl %eax, %ebp |
| |
| popl %ebx # EBX=H[i]*63 |
| popl %ebp # EBP=(Hmax+1)*63 |
| popl %ecx # ECX=C[i] |
| xchgl %eax, %ebp |
| |
| ja 6f /* geometry_probe_failed */ |
| je 5f |
| xchgl %eax, %ebp |
| subl %ebx, %eax |
| xorl %edx, %edx |
| divl %ebp # EAX=quo, EDX=rem |
| testl %edx, %edx |
| jnz 6f /* geometry_probe_failed */ |
| andl $0x3ff, %eax |
| cmpl %eax, %ecx |
| jne 6f /* geometry_probe_failed */ |
| |
| xchgl %eax, %ebp |
| 5: |
| |
| /* EAX = (Hmax+1)*63 */ |
| |
| movl $ABS(C), %ebx |
| MOVW $0, (%ebx, %edi, 4) # C[i]=0 |
| |
| movl $ABS(H), %ebx |
| MOVL $1, (%ebx, %edi, 4) # H[i]=1 |
| |
| movl $ABS(L), %ebx |
| MOVL $63, (%ebx, %edi, 8) # L[i]=63 |
| |
| addl $4, %edi # EDI=i+4 |
| |
| movl $ABS(C), %ebx |
| MOVW $1, (%ebx, %edi, 4) # C[i+4]=1 |
| |
| movl $ABS(H), %ebx |
| MOVL $0, (%ebx, %edi, 4) # H[i+4]=0 |
| |
| movl $ABS(L), %ebx |
| MOVL %eax, (%ebx, %edi, 8) # L[i+4]=(Hmax+1)*63 |
| 3: |
| jmp 3f |
| |
| 2: /* else */ |
| |
| /* empty entry, zero all the coefficients */ |
| |
| movl $ABS(C), %ebx |
| MOVW $0, (%ebx, %edi, 4) # C[i]=0 |
| |
| movl $ABS(H), %ebx |
| MOVW $0, (%ebx, %edi, 4) # H[i]=0 |
| |
| movl $ABS(L), %ebx |
| MOVL $0, (%ebx, %edi, 8) # L[i]=0 |
| |
| addl $4, %edi |
| movl $ABS(C), %ebx |
| MOVW $0, (%ebx, %edi, 4) # C[i+4]=0 |
| |
| movl $ABS(H), %ebx |
| MOVW $0, (%ebx, %edi, 4) # H[i+4]=0 |
| |
| movl $ABS(L), %ebx |
| MOVL $0, (%ebx, %edi, 8) # L[i+4]=0 |
| |
| 3: |
| |
| incl ABS(i) |
| jmp 1b |
| 1: |
| |
| /* all coefficients are generated ok */ |
| |
| # -------------------------------------------------------------------- |
| |
| #if 0 |
| |
| /* print the coefficients */ |
| |
| xorl %edi, %edi |
| 1: |
| cmpl $4, %edi |
| jae 1f |
| |
| /* print C[i] */ |
| movl $ABS(C), %ebx |
| MOVL (%ebx, %edi, 4), %eax # C[i] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_space), %ecx |
| call 8b /* linux_print */ |
| |
| /* print H[i] */ |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %eax # H[i] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_space), %ecx |
| call 8b /* linux_print */ |
| |
| /* print L[i] */ |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %eax # L[i] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_space), %ecx |
| call 8b /* linux_print */ |
| |
| addl $4, %edi |
| |
| /* print C[i] */ |
| movl $ABS(C), %ebx |
| MOVL (%ebx, %edi, 4), %eax # C[i+4] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_space), %ecx |
| call 8b /* linux_print */ |
| |
| /* print H[i] */ |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %eax # H[i+4] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_space), %ecx |
| call 8b /* linux_print */ |
| |
| /* print L[i] */ |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %eax # L[i+4] |
| |
| call 6b //print decimal number |
| |
| /* print spaces */ |
| movl $ABS(delimit_newline), %ecx |
| call 8b /* linux_print */ |
| |
| subl $4, %edi |
| |
| incl %edi |
| jmp 1b |
| 1: |
| |
| #endif |
| |
| # -------------------------------------------------------------------- |
| |
| xorl %edi, %edi # equation number ABS(i) |
| 1: |
| cmpl $8, %edi |
| jae 1f |
| |
| movl $ABS(C), %ebx |
| CMPW $0, (%ebx, %edi, 4) # C[i] |
| |
| jne 1f |
| |
| incl %edi |
| jmp 1b |
| 1: |
| |
| cmpl $8, %edi |
| jb 1f |
| |
| /* all C[i] == 0 */ |
| |
| xorl %edi, %edi # equation number ABS(i) |
| movl $ABS(H), %ebx |
| 2: |
| cmpl $8, %edi |
| jae 2f |
| |
| MOVL (%ebx, %edi, 4), %ecx # H[i] |
| testl %ecx, %ecx |
| |
| jne 2f |
| |
| incl %edi |
| jmp 2b |
| 2: |
| |
| cmpl $8, %edi |
| je 6f /* geometry_probe_failed */ # all H[i] == 0 |
| |
| xorl %edx, %edx # equation number j |
| movl $ABS(L), %ebx |
| 2: |
| cmpl %edi, %edx |
| jae 2f |
| |
| CMPW $0, (%ebx, %edx, 8) # L[j] |
| |
| jne 6f /* geometry_probe_failed */ |
| |
| incl %edx |
| jmp 2b |
| 2: |
| |
| /* j == i */ |
| |
| MOVL (%ebx, %edi, 8), %eax # L[i] |
| testl %eax, %eax |
| |
| jle 6f /* geometry_probe_failed */ |
| # OF=0; jmp if SF=1 or ZF=1 |
| |
| cdq # EDX=0 |
| divl %ecx # ECX=H[i] |
| # EAX=quo=sectors_per_track |
| # EDX=rem |
| testl %edx, %edx |
| jnz 6f /* geometry_probe_failed */ |
| |
| movl %eax, ABS(probed_sectors_per_track) |
| |
| cmpl $63, %eax |
| ja 6f /* geometry_probe_failed */ |
| |
| cmpw ABS(Smax), %ax |
| jb 6f /* geometry_probe_failed */ |
| |
| movw %ax, ABS(Smax) |
| |
| movl %edi, %edx |
| incl %edx # equation number j=i+1 |
| 2: |
| cmpl $8, %edx |
| jae 2f |
| |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edx, 4), %ecx # H[j] |
| |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edx, 8), %eax # L[j] |
| |
| jecxz 3f |
| |
| pushl %edx |
| |
| xchgl %eax, %ecx # EAX=H[j], ECX=L[j] |
| mull ABS(probed_sectors_per_track) # EAX=product |
| # EDX=0 |
| popl %edx |
| |
| cmpl %eax, %ecx |
| |
| jnz 6f /* geometry_probe_failed */ |
| |
| jmp 4f |
| 3: |
| testl %eax, %eax |
| jnz 6f /* geometry_probe_failed */ |
| 4: |
| |
| incl %edx |
| jmp 2b |
| 2: |
| |
| movl ABS(Hmax), %eax |
| incl %eax |
| movl %eax, ABS(probed_heads) |
| |
| jmp 2f |
| 1: |
| |
| testl %edi, %edi |
| jz 1f |
| |
| /* xchgw C[i], C[0] */ |
| |
| movl $ABS(C), %ebx |
| MOVW (%ebx, %edi, 4), %ax # C[i] |
| movw (iBX), %cx # C[0] |
| |
| movw %ax, (iBX) |
| MOVW %cx, (%ebx, %edi, 4) |
| |
| /* xchgw H[i], H[0] */ |
| |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %eax # H[i] |
| movl (iBX), %ecx # H[0] |
| |
| movl %eax, (iBX) |
| MOVL %ecx, (%ebx, %edi, 4) |
| |
| /* xchgw L[i], L[0] */ |
| |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %eax # L[i] |
| movl (iBX), %ecx # L[0] |
| |
| movl %eax, (iBX) |
| MOVL %ecx, (%ebx, %edi, 8) |
| |
| 1: |
| |
| movl $0, ABS(H8) # will store sectors per track |
| |
| /* for (i = 1; i < 8; i++) */ |
| |
| movl $1, %edi |
| 1: |
| cmpl $8, %edi |
| jae 1f |
| |
| movl $ABS(L), %ebx |
| MOVL (%ebx, %edi, 8), %eax # L[i] |
| |
| movzwl ABS(C), %edx # C[0] |
| mull %edx # EDX:EAX=product |
| |
| MOVL %eax, (%ebx, %edi, 8) # L[i] low |
| MOVL %edx, 4(%ebx, %edi, 8) # L[i] high |
| |
| movl $ABS(C), %ebx |
| MOVZWL (%ebx, %edi, 4), %eax # C[i] |
| |
| mull ABS(L) # L[0] |
| |
| movl $ABS(L), %ebx |
| SUBL %eax, (%ebx, %edi, 8) # L[i] low |
| SBBL %edx, 4(%ebx, %edi, 8) # L[i] high |
| |
| movl $ABS(H), %ebx |
| MOVL (%ebx, %edi, 4), %eax # H[i] |
| |
| movzwl ABS(C), %edx # C[0] |
| mull %edx # EDX:EAX=product |
| # EDX=0 |
| |
| MOVL %eax, (%ebx, %edi, 4) # H[i] |
| |
| movl $ABS(C), %ebx |
| MOVZWL (%ebx, %edi, 4), %eax # C[i] |
| |
| mull ABS(H) # H[0] |
| |
| movl $ABS(H), %ebx |
| SUBL %eax, (%ebx, %edi, 4) # H[i] |
| |
| /* if (H[i]) */ |
| |
| jz 3f |
| |
| ja 4f |
| |
| movl $ABS(H), %ebx |
| NEGL (%ebx, %edi, 4) # H[i] |
| |
| movl $ABS(L), %ebx |
| xorl %eax, %eax |
| NEGL (%ebx, %edi, 8) # L[i] low |
| cmc |
| NOTL 4(%ebx, %edi, 8) # L[i] high |
| ADCL %eax, 4(%ebx, %edi, 8) |
| |
| 4: |
| movl $ABS(L), %ebx |
| CMPL $0, 4(%ebx, %edi, 8) # L[i] high |
| jne 6f /* geometry_probe_failed */ |
| |
| MOVL (%ebx, %edi, 8), %eax # L[i] low |
| testl %eax, %eax |
| |
| jle 6f /* geometry_probe_failed */ |
| # OF=0; jmp if SF=1 or ZF=1 |
| |
| cdq # EDX=0 |
| |
| movl $ABS(H), %ebx |
| DIVL (%ebx, %edi, 4) # H[i] |
| # EAX=sectors per track |
| testl %edx, %edx |
| jnz 6f /* geometry_probe_failed */ |
| |
| movl %eax, ABS(L8) |
| |
| cmpl $63, %eax |
| ja 6f /* geometry_probe_failed */ |
| |
| cmpw ABS(Smax), %ax |
| jb 6f /* geometry_probe_failed */ |
| |
| movw %ax, ABS(Smax) |
| |
| cmpl $0, ABS(H8) |
| je 4f |
| |
| cmpl %eax, ABS(H8) # EAX=L[8] |
| jne 6f /* geometry_probe_failed */ |
| |
| jmp 5f |
| 4: |
| movl %eax, ABS(H8) # EAX=L[8] |
| 5: |
| |
| jmp 4f |
| 3: /* else */ |
| movl $ABS(L), %ebx |
| CMPL $0, (%ebx, %edi, 8) # L[i] low |
| jne 6f /* geometry_probe_failed */ |
| |
| CMPL $0, 4(%ebx, %edi, 8) # L[i] high |
| jne 6f /* geometry_probe_failed */ |
| |
| 4: /* end if (H[i]) */ |
| |
| incl %edi |
| jmp 1b |
| 1: /* end for (i = 1; i < 8; i++) */ |
| |
| /* if (ABS(H)[8]) */ |
| |
| cmpl $0, ABS(H8) |
| je 3f |
| |
| /* ABS(H)[8] is sectors per track */ |
| |
| movl ABS(H), %eax # H[0] |
| mull ABS(H8) |
| |
| //movl $ABS(L), %ebx |
| subl %eax, ABS(L) # L[0] low |
| sbbl %edx, ABS(L) + 4 # L[0] high |
| |
| jnz 6f /* geometry_probe_failed */ |
| |
| movl ABS(L), %eax |
| testl %eax, %eax |
| |
| jle 6f /* geometry_probe_failed */ |
| # OF=0; jmp if SF=1 or ZF=1 |
| |
| cdq # EDX=0 |
| |
| divl ABS(H8) |
| |
| testl %edx, %edx |
| jnz 6f /* geometry_probe_failed */ |
| |
| movzwl ABS(C), %ecx # C[0] |
| divl %ecx |
| |
| testl %edx, %edx |
| jnz 6f /* geometry_probe_failed */ |
| |
| movl %eax, ABS(L8) # L[8] is number of heads |
| |
| cmpl $256, %eax |
| ja 6f /* geometry_probe_failed */ |
| |
| cmpl ABS(Hmax), %eax |
| jbe 6f /* geometry_probe_failed */ |
| |
| movl ABS(H8), %eax |
| movl %eax, ABS(probed_sectors_per_track) |
| |
| jmp 4f |
| 3: /* else */ |
| |
| /* fail to set L[8], this means all H[i]==0, i=1,2,3,4,5,6,7 */ |
| |
| /* Now the only equation is: C[0] * H * S + H[0] * S = L[0] */ |
| |
| /* for (i = 63; i >= Smax; i--) */ |
| |
| movl ABS(L), %ebx # EBX=L[0] |
| movl $63, %edi |
| 3: |
| cmpl ABS(Smax), %edi |
| jb 3f |
| |
| movl ABS(H), %eax # H[0] |
| mull %edi # EDX=0 |
| # EAX=product |
| //movl %ebx, ABS(L8) |
| //subl %eax, ABS(L8) |
| |
| subl %ebx, %eax |
| negl %eax |
| |
| jz 5f # continue |
| js 5f # continue |
| |
| cdq # EDX=0 |
| divl %edi |
| |
| testl %edx, %edx |
| jnz 5f |
| |
| movzwl ABS(C), %ecx # C[0] |
| divl %ecx |
| |
| testl %edx, %edx |
| jnz 5f |
| |
| movl %eax, ABS(L8) # L[8] is number of heads |
| |
| cmpl $256, %eax |
| ja 5f |
| |
| cmpl ABS(Hmax), %eax |
| ja 3f |
| 5: |
| decl %edi |
| jmp 3b |
| 3: /* end for (i = 63; i >= Smax; i--) */ |
| |
| cmpl ABS(Smax), %edi |
| jb 6f /* geometry_probe_failed */ |
| |
| movl %edi, ABS(probed_sectors_per_track) |
| |
| 4: /* end if (ABS(H)[8]) */ |
| |
| movl ABS(L8), %eax |
| movl %eax, ABS(probed_heads) |
| |
| 2: /* end if (ABS(i) == 8) */ |
| |
| /* geometry_probe_ok */ |
| |
| clc |
| popal |
| ret |
| |
| //geometry_probe_failed: |
| 6: |
| stc |
| popal |
| ret |
| |
| //partition: |
| 0: |
| #if 0 |
| /* load the next partition and modify the boot record */ |
| |
| /* EBX holds the file descriptor number or 0 if it is BIOS drive */ |
| /* partition table is at ABS(mbr_63_sectors + 0x2000) */ |
| /* current partition number is ABS(current_partition) */ |
| |
| pushal |
| |
| /* enumerate all partitions */ |
| |
| /* initialize the partition table, move start_LBA(the 3rd dword) |
| * to the total_sectors field(the 4th dword) and clear the 3rd dword. |
| * The sum of the 3rd and 4th dwords gives the absolute start_LBA. |
| */ |
| movl $ABS(mbr_63_sectors + 0x2000), %ebp |
| xorl %eax, %eax |
| xchgl %eax, 0x08(%ebp) |
| movl %eax, 0x0c(%ebp) |
| xorl %eax, %eax |
| xchgl %eax, 0x18(%ebp) |
| movl %eax, 0x1c(%ebp) |
| xorl %eax, %eax |
| xchgl %eax, 0x28(%ebp) |
| movl %eax, 0x2c(%ebp) |
| xorl %eax, %eax |
| xchgl %eax, 0x38(%ebp) |
| movl %eax, 0x3c(%ebp) |
| |
| movl $0x04, ABS(total_partition_entries) |
| /* copy extended partition entries to the end of the partition table */ |
| xorl %esi, %esi |
| 1: |
| movb 4(%ebp, %esi), %al # partition id |
| cmpb $0x05, %al |
| je 2f |
| cmpb $0x0f, %al |
| je 2f |
| cmpb $0x15, %al |
| je 2f |
| cmpb $0x1f, %al |
| je 2f |
| cmpb $0x85, %al |
| jne 4f |
| 2: |
| /* extended partition */ |
| |
| /* read one sector of the partition to ABS(mbr_63_sectors) */ |
| ........ |
| /* check if the partition table is valid */ |
| j_invalid 3f |
| /* approve the partition entries and move onto the free entries */ |
| movl ABS(total_partition_entries), %edi |
| shll $4, %edi |
| addl %ebp, %edi # EDI points to the first free entry |
| /* move the extended partition entry onto the first free entry */ |
| movl (%ebp, %esi), %eax |
| stosl |
| movl 4(%ebp, %esi), %eax |
| stosl |
| xorl %eax, %eax |
| stosl |
| movl 8(%ebp, %esi), %eax |
| stosl |
| incl ABS(total_partition_entries) |
| 3: |
| ///* disable the original extended partition entry by clearing its id */ |
| //movb $0, 4(%ebp, %esi) |
| cmpl $0x40, %esi # Is it in the main partition table? |
| jb 4f # yes, keep the entry in its place. |
| |
| # no, remove the entry. |
| pushl %esi |
| addl %ebp, %esi |
| movl %esi, %edi |
| addl $0x10, %esi |
| movl ABS(total_partition_entries), %ecx |
| shll $4, %ecx |
| subl %esi, %ecx |
| shrl $2, %ecx |
| cld |
| repz movsl |
| popl %esi |
| decl ABS(total_partition_entries) |
| subl $0x10, %esi # go back one entry and redo |
| 4: |
| addl $0x10, %esi |
| movl ABS(total_partition_entries), %edi |
| shll $4, %edi |
| cmpl %edi, %esi |
| jb 1b |
| |
| /* end of partition enumeration */ |
| |
| /* recursively resolve extended partition entries */ |
| //xorl %esi, %esi |
| //movl $4, %esi |
| //cmpl ABS(total_partition_entries), %esi |
| |
| |
| cmpl $3, ABS(current_partition) |
| ja 1f |
| /* it is primary partition */ |
| movl ABS(current_partition), %esi |
| shll $4, %esi |
| movl 8(%ebp, %esi), %eax # start LBA |
| movl $ABS(msg_no_such_partition), ABS(error_message_pointer) |
| testl %eax, %eax |
| stc |
| jz 2f |
| /* read 4 sectors at start LBA to ABS(mbr_63_sectors) */ |
| movl $4, %ecx |
| clc /* read */ |
| call 6f |
| movl $ABS(msg_read_file), ABS(error_message_pointer) |
| jc 2f |
| /* modify the boot record */ |
| call 7f |
| movl $ABS(msg_unsupported_fstype), ABS(error_message_pointer) |
| jc 2f |
| /* write sectors to start LBA at ABS(mbr_63_sectors) */ |
| movl ABS(sectors_to_write), %ecx |
| stc /* write */ |
| call 6f |
| movl $ABS(msg_write_file), ABS(error_message_pointer) |
| 2: |
| popal |
| ret |
| |
| 1: |
| /* it is logical partition */ |
| movl $ABS(msg_end_of_partition_chain), ABS(error_message_pointer) |
| popal |
| ret |
| 6: |
| /* before the call: */ |
| /* EAX=start LBA */ |
| /* EBX=file descriptor or 0 for BIOS drive */ |
| /* ECX=sectors */ |
| /* CF=0 for read; CF=1 for write */ |
| /* on return: */ |
| /* CF=0 for success; CF=1 for failure */ |
| |
| pushal |
| |
| popal |
| ret |
| 7: |
| pushal |
| |
| popal |
| ret |
| /* EBX holds the file descriptor number or 0 if it is BIOS drive */ |
| /* move partition table forward to the beginning of the 17th sector */ |
| movl $ABS(mbr_63_sectors + 0x01be), %esi |
| movl $ABS(mbr_63_sectors + 0x2000), %edi |
| movl $0x10, %ecx # 0x10 dwords = 0x40 bytes |
| |
| cld |
| repz movsl |
| |
| /* initialize the current_partition number */ |
| movzbl ABS(install_partition), %eax |
| movl %eax, ABS(current_partition) |
| |
| 3: |
| /* load the next partition and modify the boot record */ |
| call 0f /* partition */ |
| jc 3f /* done */ |
| call 2f /* write to file */ |
| incl ABS(current_partition) |
| movw ABS(install_partition), %ax |
| addb %ah, %al /* Max partition number for install */ |
| cmpb %al, ABS(current_partition) |
| jbe 3b |
| 3: |
| /* all partitions have been installed. */ |
| |
| xorl %eax, %eax # exit code = 0 |
| |
| #ifdef __DOS_16 |
| |
| movb $0x4c, %ah // EXIT - TERMINATE WITH RETURN CODE in AL |
| int $0x21 // call DOS |
| |
| #else |
| xchgl %eax, %ebx # move exit code in EAX to EBX |
| movl $1, %eax # sys_exit |
| int $0x80 |
| #endif |
| |
| #endif |
| ret |
| |