1/* 2 * Copyright (c) 2000 John Baldwin 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26/* 27 * This simple program is a preloader for the normal boot3 loader. It is simply 28 * prepended to the beginning of a fully built and btxld'd loader. It then 29 * copies the loader to the address boot2 normally loads it, emulates the 30 * boot[12] environment (protected mode, a bootinfo struct, etc.), and then jumps 31 * to the start of btxldr to start the boot process. This method allows a stock 32 * /boot/loader to be booted over the network via PXE w/o having to write a 33 * separate PXE-aware client just to load the loader. 34 */ 35 36#include <sys/reboot.h> 37#include <bootargs.h> 38 39/* 40 * Memory locations. 41 */ 42 .set MEM_PAGE_SIZE,0x1000 # memory page size, 4k 43 .set MEM_ARG,0x900 # Arguments at start 44 .set MEM_ARG_BTX,0xa100 # Where we move them to so the 45 # BTX client can see them 46 .set MEM_ARG_SIZE,0x18 # Size of the arguments 47 .set MEM_BTX_ADDRESS,0x9000 # where BTX lives 48 .set MEM_BTX_ENTRY,0x9010 # where BTX starts to execute 49 .set MEM_BTX_OFFSET,MEM_PAGE_SIZE # offset of BTX in the loader 50 .set MEM_BTX_CLIENT,0xa000 # where BTX clients live 51 .set MEM_BIOS_KEYBOARD,0x496 # BDA byte with keyboard bit 52/* 53 * a.out header fields 54 */ 55 .set AOUT_TEXT,0x04 # text segment size 56 .set AOUT_DATA,0x08 # data segment size 57 .set AOUT_BSS,0x0c # zero'd BSS size 58 .set AOUT_SYMBOLS,0x10 # symbol table 59 .set AOUT_ENTRY,0x14 # entry point 60 .set AOUT_HEADER,MEM_PAGE_SIZE # size of the a.out header 61/* 62 * Segment selectors. 63 */ 64 .set SEL_SDATA,0x8 # Supervisor data 65 .set SEL_RDATA,0x10 # Real mode data 66 .set SEL_SCODE,0x18 # PM-32 code 67 .set SEL_SCODE16,0x20 # PM-16 code 68/* 69 * BTX constants 70 */ 71 .set INT_SYS,0x30 # BTX syscall interrupt 72/* 73 * Bit in MEM_BIOS_KEYBOARD that is set if an enhanced keyboard is present 74 */ 75 .set KEYBOARD_BIT,0x10 76/* 77 * We expect to be loaded by the BIOS at 0x7c00 (standard boot loader entry 78 * point) 79 */ 80 .code16 81 .globl start 82 .org 0x0, 0x0 83/* 84 * BTX program loader for PXE network booting 85 */ 86start: cld # string ops inc 87 xorw %ax, %ax # zero %ax 88 movw %ax, %ss # setup the 89 movw $start, %sp # stack 90 movw %es, %cx # save PXENV+ segment 91 movw %ax, %ds # setup the 92 movw %ax, %es # data segments 93 andl $0xffff, %ecx # clear upper words 94 andl $0xffff, %ebx # of %ebx and %ecx 95 shll $4, %ecx # calculate the offset of 96 addl %ebx, %ecx # the PXENV+ struct and 97 pushl %ecx # save it on the stack 98 movw $welcome_msg, %si # %ds:(%si) -> welcome message 99 callw putstr # display the welcome message 100/* 101 * Setup the arguments that the loader is expecting from boot[12] 102 */ 103 movw $bootinfo_msg, %si # %ds:(%si) -> boot args message 104 callw putstr # display the message 105 movw $MEM_ARG, %bx # %ds:(%bx) -> boot args 106 movw %bx, %di # %es:(%di) -> boot args 107 xorl %eax, %eax # zero %eax 108 movw $(MEM_ARG_SIZE/4), %cx # Size of arguments in 32-bit 109 # dwords 110 rep # Clear the arguments 111 stosl # to zero 112 orb $KARGS_FLAGS_PXE, 0x8(%bx) # kargs->bootflags |= 113 # KARGS_FLAGS_PXE 114 popl 0xc(%bx) # kargs->pxeinfo = *PXENV+ 115#ifdef ALWAYS_SERIAL 116/* 117 * set the RBX_SERIAL bit in the howto byte. 118 */ 119 orl $RB_SERIAL, (%bx) # enable serial console 120#endif 121#ifdef PROBE_KEYBOARD 122/* 123 * Look at the BIOS data area to see if we have an enhanced keyboard. If not, 124 * set the RBX_DUAL and RBX_SERIAL bits in the howto byte. 125 */ 126 testb $KEYBOARD_BIT, MEM_BIOS_KEYBOARD # keyboard present? 127 jnz keyb # yes, so skip 128 orl $(RB_MULTIPLE | RB_SERIAL), (%bx) # enable serial console 129keyb: 130#endif 131/* 132 * Turn on the A20 address line 133 */ 134 callw seta20 # Turn A20 on 135/* 136 * Relocate the loader and BTX using a very lazy protected mode 137 */ 138 movw $relocate_msg, %si # Display the 139 callw putstr # relocation message 140 movl end+AOUT_ENTRY, %edi # %edi is the destination 141 movl $(end+AOUT_HEADER), %esi # %esi is 142 # the start of the text 143 # segment 144 movl end+AOUT_TEXT, %ecx # %ecx = length of the text 145 # segment 146 lgdt gdtdesc # setup our own gdt 147 cli # turn off interrupts 148 movl %cr0, %eax # Turn on 149 orb $0x1, %al # protected 150 movl %eax, %cr0 # mode 151 ljmp $SEL_SCODE,$pm_start # long jump to clear the 152 # instruction pre-fetch queue 153 .code32 154pm_start: movw $SEL_SDATA, %ax # Initialize 155 movw %ax, %ds # %ds and 156 movw %ax, %es # %es to a flat selector 157 rep # Relocate the 158 movsb # text segment 159 addl $(MEM_PAGE_SIZE - 1), %edi # pad %edi out to a new page 160 andl $~(MEM_PAGE_SIZE - 1), %edi # for the data segment 161 movl end+AOUT_DATA, %ecx # size of the data segment 162 rep # Relocate the 163 movsb # data segment 164 movl end+AOUT_BSS, %ecx # size of the bss 165 xorl %eax, %eax # zero %eax 166 addb $3, %cl # round %ecx up to 167 shrl $2, %ecx # a multiple of 4 168 rep # zero the 169 stosl # bss 170 movl end+AOUT_ENTRY, %esi # %esi -> relocated loader 171 addl $MEM_BTX_OFFSET, %esi # %esi -> BTX in the loader 172 movl $MEM_BTX_ADDRESS, %edi # %edi -> where BTX needs to go 173 movzwl 0xa(%esi), %ecx # %ecx -> length of BTX 174 rep # Relocate 175 movsb # BTX 176 ljmp $SEL_SCODE16,$pm_16 # Jump to 16-bit PM 177 .code16 178pm_16: movw $SEL_RDATA, %ax # Initialize 179 movw %ax, %ds # %ds and 180 movw %ax, %es # %es to a real mode selector 181 movl %cr0, %eax # Turn off 182 andb $~0x1, %al # protected 183 movl %eax, %cr0 # mode 184 ljmp $0,$pm_end # Long jump to clear the 185 # instruction pre-fetch queue 186pm_end: sti # Turn interrupts back on now 187/* 188 * Copy the BTX client to MEM_BTX_CLIENT 189 */ 190 xorw %ax, %ax # zero %ax and set 191 movw %ax, %ds # %ds and %es 192 movw %ax, %es # to segment 0 193 movw $MEM_BTX_CLIENT, %di # Prepare to relocate 194 movw $btx_client, %si # the simple btx client 195 movw $(btx_client_end-btx_client), %cx # length of btx client 196 rep # Relocate the 197 movsb # simple BTX client 198/* 199 * Copy the boot[12] args to where the BTX client can see them 200 */ 201 movw $MEM_ARG, %si # where the args are at now 202 movw $MEM_ARG_BTX, %di # where the args are moving to 203 movw $(MEM_ARG_SIZE/4), %cx # size of the arguments in longs 204 rep # Relocate 205 movsl # the words 206/* 207 * Save the entry point so the client can get to it later on 208 */ 209 movl end+AOUT_ENTRY, %eax # load the entry point 210 stosl # add it to the end of the 211 # arguments 212/* 213 * Now we just start up BTX and let it do the rest 214 */ 215 movw $jump_message, %si # Display the 216 callw putstr # jump message 217 ljmp $0,$MEM_BTX_ENTRY # Jump to the BTX entry point 218 219/* 220 * Display a null-terminated string 221 */ 222putstr: lodsb # load %al from %ds:(%si) 223 testb %al,%al # stop at null 224 jnz putc # if the char != null, output it 225 retw # return when null is hit 226putc: movw $0x7,%bx # attribute for output 227 movb $0xe,%ah # BIOS: put_char 228 int $0x10 # call BIOS, print char in %al 229 jmp putstr # keep looping 230 231/* 232 * Enable A20. Put an upper limit on the amount of time we wait for the 233 * keyboard controller to get ready (65K x ISA access time). If 234 * we wait more than that amount, the hardware is probably 235 * legacy-free and simply doesn't have a keyboard controller. 236 * Thus, the A20 line is already enabled. 237 */ 238seta20: cli # Disable interrupts 239 xor %cx,%cx # Clear 240seta20.1: inc %cx # Increment, overflow? 241 jz seta20.3 # Yes 242 inb $0x64,%al # Get status 243 testb $0x2,%al # Busy? 244 jnz seta20.1 # Yes 245 movb $0xd1,%al # Command: Write 246 outb %al,$0x64 # output port 247seta20.2: inb $0x64,%al # Get status 248 testb $0x2,%al # Busy? 249 jnz seta20.2 # Yes 250 movb $0xdf,%al # Enable 251 outb %al,$0x60 # A20 252seta20.3: sti # Enable interrupts 253 retw # To caller 254 255/* 256 * BTX client to start btxldr 257 */ 258 .code32 259btx_client: movl $(MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE-4), %esi 260 # %ds:(%esi) -> end 261 # of boot[12] args 262 movl $(MEM_ARG_SIZE/4), %ecx # Number of words to push 263 std # Go backwards 264push_arg: lodsl # Read argument 265 pushl %eax # Push it onto the stack 266 loop push_arg # Push all of the arguments 267 cld # In case anyone depends on this 268 pushl MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE # Entry point of 269 # the loader 270 pushl %eax # Emulate a near call 271 movl $0x1, %eax # 'exec' system call 272 int $INT_SYS # BTX system call 273btx_client_end: 274 .code16 275 276 .p2align 4 277/* 278 * Global descriptor table. 279 */ 280gdt: .word 0x0,0x0,0x0,0x0 # Null entry 281 .word 0xffff,0x0,0x9200,0xcf # SEL_SDATA 282 .word 0xffff,0x0,0x9200,0x0 # SEL_RDATA 283 .word 0xffff,0x0,0x9a00,0xcf # SEL_SCODE (32-bit) 284 .word 0xffff,0x0,0x9a00,0x8f # SEL_SCODE16 (16-bit) 285gdt.1: 286/* 287 * Pseudo-descriptors. 288 */ 289gdtdesc: .word gdt.1-gdt-1 # Limit 290 .long gdt # Base 291 292welcome_msg: .asciz "PXE Loader 1.00\r\n\n" 293bootinfo_msg: .asciz "Building the boot loader arguments\r\n" 294relocate_msg: .asciz "Relocating the loader and the BTX\r\n" 295jump_message: .asciz "Starting the BTX loader\r\n" 296 297 .p2align 4 298end: 299