path: root/sys/arch/i386/netboot/main.c

/*	$OpenBSD: main.c,v 1.4 1996/04/26 18:23:03 mickey Exp $	*/
/*	$NetBSD: main.c,v 1.6 1996/02/02 18:06:17 mycroft Exp $	*/

/*
 * source code in this file is from:
 * 386BSD boot blocks by Julian Elischer (julian@tfs.com)
 * 386BSD Adaptec 1542 SCSI boot blocks by Pace Willisson (pace@blitz.com)
 *
 * Mach Operating System
 * Copyright (c) 1992, 1991 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */

/*
  Copyright 1988, 1989, 1990, 1991, 1992 
   by Intel Corporation, Santa Clara, California.

                All Rights Reserved

Permission to use, copy, modify, and distribute this software and
its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appears in all
copies and that both the copyright notice and this permission notice
appear in supporting documentation, and that the name of Intel
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.

INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/


#include "config.h"
#include "nbtypes.h"
#include "assert.h"
#include "param.h"
#include "packet.h"
#include "ether.h"
#include "inet.h"
#include "arp.h"
#include "tftp.h"

#include "proto.h"


u_long work_area_org = RELOC;
u_long kernel_size;
u_short real_cs;
u_long howto = 0;
u_char vendor_area[64];

enum LoadErr {
  load_success,
  load_no_answer,
  load_bad_format,
  load_bad_size,
};

static inline enum LoadErr
LoadProgFromServer(ipaddr_t server, ipaddr_t gateway, char *file_name) {
  /* TBD - fail (or at least warn) if we don't get the entire file */
  u_long start_addr;
  u_long boot_area_org;
  u_long tmp_reloc_org;
  u_long kern_copy_org;
  u_long kern_copy_p;
  struct exec head;
  u_long boot_argv[4];
#if 1 /* ndef USE_BUFFER */
  u_char tmpbuf[4096]; /* we need to load the first 4k here */
#endif

  SetTftpParms(server, gateway, file_name);

  /* TBD - heuristics about what we are loading - load linux, ... also */

  if (Read(&head, sizeof(head)) != sizeof(head))
    return load_bad_size;

  if (N_GETMAGIC(head) != ZMAGIC) {
    printf("Invalid format!\n");
    return load_bad_format;
  }

  /* Load/tftp the executable to a temporary area beyond 640k - after
     successful load, copy to correct area. If load fails or is interrrupted,
     we can recover gracefully
     */

  start_addr = (u_long)head.a_entry;
  boot_area_org = start_addr & 0x00f00000; /* some MEG boundary */
  tmp_reloc_org = 0x00100000;
#ifdef USE_BUFFER
  kern_copy_org = tmp_reloc_org + WORK_AREA_SIZE; /* leave free for relocation */
#else
  kern_copy_org = boot_area_org; /* leave free for relocation */
#endif
  kern_copy_p = kern_copy_org;
  kernel_size = head.a_text + head.a_data + head.a_bss;

  printf("Loading ");
  IpPrintAddr(server);
  printf(":%s @ 0x%x\n", file_name, boot_area_org);
#ifndef USE_BUFFER
  if(boot_area_org < work_area_org) {
    if((boot_area_org + head.a_text + head.a_data) > work_area_org) {
      printf("kernel will not fit below loader\n");
      return load_bad_size;
    }
    if((boot_area_org + head.a_text + head.a_data + head.a_bss) > 0xa0000) {
      printf("kernel too big, won't fit in 640K with bss\n");
      printf("Only hope is to link the kernel for > 1MB\n");
      return load_bad_size;
    }
    if(boot_area_org + kernel_size > work_area_org) {
      printf("loader overlaps bss, kernel must bzero\n");
    }
  }
#else
  if(boot_area_org + kernel_size > 0xa0000) {
    printf("kernel too big, won't fit in 640K with bss\n");
    printf("Only hope is to link the kernel for > 1MB\n");
    return load_bad_size;
  }
  /* check if too large for tmp buffer (TBD) */
#endif
  printf("text=0x%x", head.a_text);

#if 01
  /* skip to first 4k boundry */
  Read(tmpbuf, 4096-sizeof(head));
#endif

#if 0 /* ndef USE_BUFFER */
  /********************************************************/
  /* LOAD THE TEXT SEGMENT				*/
  /* don't clobber the first 4k yet (BIOS NEEDS IT) 	*/
  /********************************************************/
  Read(tmpbuf, sizeof(tmpbuf));
  kern_copy_p += sizeof(tmpbuf);
  PhysRead(kern_copy_p, head.a_text - sizeof(tmpbuf));
  kern_copy_p += head.a_text - sizeof(tmpbuf);
#else
  /********************************************************/
  /* LOAD THE TEXT SEGMENT				*/
  /********************************************************/
  PhysRead(kern_copy_p, head.a_text);
  kern_copy_p += head.a_text;
#endif

  /********************************************************/
  /* Load the Initialised data after the text		*/
  /********************************************************/
/* TBD - this is bogus - file system oriented */
#define CLSIZE 1
#define NBPG 4096            /* bytes/page */
#define CLOFSET (CLSIZE*NBPG-1) /* for clusters, like PGOFSET */

  while (kern_copy_p & CLOFSET)
    *(char *)kern_copy_p++ = 0;

  printf(" data=0x%x", head.a_data);
  PhysRead(kern_copy_p, head.a_data);
  kern_copy_p += head.a_data;

  /********************************************************/
  /* Skip over the uninitialised data			*/
  /* (but clear it)					*/
  /********************************************************/
  printf(" bss=0x%x", head.a_bss);
  if (kern_copy_p < RELOC &&
     (kern_copy_p + head.a_bss) > RELOC) {
    PhysBzero(kern_copy_p, RELOC-(u_int)kern_copy_p);
  } else {
    PhysBzero(kern_copy_p, head.a_bss);
  }

#ifdef LOADSYMS /* not yet, haven't worked this out yet */
  if (kern_copy_p > 0x100000) {
    /********************************************************/
    /*copy in the symbol header				*/
    /********************************************************/
    PhysBcopy(&head.a_syms, kern_copy_p, sizeof(head.a_syms));
    kern_copy_p += sizeof(head.a_syms);

    /********************************************************/
    /* READ in the symbol table				*/
    /********************************************************/
    printf(" symbols=[+0x%x", head.a_syms);
    Read(kern_copy_p, head.a_syms);
    kern_copy_p += head.a_syms;

    /********************************************************/
    /* Followed by the next integer (another header)	*/
    /* more debug symbols?					*/
    /********************************************************/
    read(&i, sizeof(u_int));
    PhysBcopy(&i, kern_copy_p, sizeof(u_int));
    i -= sizeof(u_int);
    kern_copy_p += sizeof(u_int);

    /********************************************************/
    /* and that many bytes of (debug symbols?)		*/
    /********************************************************/
    printf("+0x%x]", i);
    Read(kern_copy_p, i);
    kern_copy_p += i;
  }
#endif	LOADSYMS

  /********************************************************/
  /* and note the end address of all this			*/
  /********************************************************/

  printf(" total=0x%x",kern_copy_p - kern_copy_org);

  boot_argv[0] = 0;
  boot_argv[1] = howto;
  boot_argv[2] = 0;
  boot_argv[3] = 0;

/* TBD - place vendor_area on stack */

  printf(" entry point=0x%x\n" ,((u_int)start_addr) & 0xffffff);

  if (howto) {
    static char *rb_option_name[9] = {
      "askname",
      "single",
      "nosync",
      "halt",
      "initname",
      "dfltroot",
      "kdb",
      "rdonly",
      "dump",
      };
    int i;
    printf("Starting kernel with options (0x%x): ", howto);
    for (i=0; i<9; i++) {
      if (howto & (1<<i)) {
	printf("%s ", rb_option_name[i]);
      }
    }
    printf("\n");
  }

#if 0 /* ndef USE_BUFFER */
  PhysBcopy(tmpbuf, boot_area_org, sizeof(tmpbuf));
#endif

  StartProg(start_addr & 0xffffff, boot_argv);

  return load_success; /* hah! */
}

int GetHex(int old) {
  int r, c, ch;
  r = 0;
  ch = 0;
  while((c=getchar()) != '\n') {
    ch = 1;
    if (c>='0' && c<='9')
      r = r*16 + (c-'0');
    else if (c>='a' && c<='f')
      r = r*16 + (c+10-'a');
  }
  if (ch)
    return r;
  else
    return old;
}

static char
ToHex(int n) {
  n &= 0x0F;
  return n >= 10 ? n - 10 + 'A' : n + '0';
}

static char name_set[][9] = {
  "xxxxxxxx",
  "default",
};

static char *ext_set[] = {
  ".bsd",
  ".bsd.old",
  ".vmunix",
  ".vmunix.old",
};

static ipaddr_t server_set[2] = {
  0,
  IP_BCASTADDR,
};

static inline void
TryToLoadSomething(void) {
  int nserver;
  for (nserver=0; nserver<nelt(server_set); nserver++) {
    int nname;
    char file_name[MAX_FILE_NAME_LEN+1];
    file_name[0] = '\0';
    if (GetIpAddress(&server_set[nserver], &ip_myaddr, &ip_gateway, file_name)) {
      if (*file_name) {
	LoadProgFromServer(server_set[nserver], ip_gateway, file_name);
      }
      else {
	/* no file name supplied from server, synthesize one */
	inetaddr_t ip;
	ip.a = ip_myaddr;
	name_set[0][0] = ToHex(ip.s.a0 >> 4);
	name_set[0][1] = ToHex(ip.s.a0);
	name_set[0][2] = ToHex(ip.s.a1 >> 4);
	name_set[0][3] = ToHex(ip.s.a1);
	name_set[0][4] = ToHex(ip.s.a2 >> 4);
	name_set[0][5] = ToHex(ip.s.a2);
	name_set[0][6] = ToHex(ip.s.a3 >> 4);
	name_set[0][7] = ToHex(ip.s.a3);
	name_set[0][8] = 0;
	for (nname=0; nname<nelt(name_set); nname++) {
	  int next;
	  for (next=0; next<nelt(ext_set); next++) {
	    strncpy(file_name, name_set[nname], MAX_FILE_NAME_LEN);
	    strncat(file_name, ext_set[next], MAX_FILE_NAME_LEN-strlen(file_name));
	    LoadProgFromServer(server_set[nserver], ip_gateway, file_name);
	  }
	}
      }
    }
  }
}


static char *
DecimalToByte(char *s, u_char *n) {
  for (*n = 0; *s >= '0' && *s <= '9'; s++)
    *n = (*n * 10) + *s - '0';
  return s;
}

static ipaddr_t
IpConvertAddr(char *p) {
  inetaddr_t addr;

  if (p == (char *)0 || *p == '\0')
    return IP_ANYADDR;
  p = DecimalToByte(p, &addr.s.a0);
  if (*p == '\0' || *p++ != '.')
    return IP_ANYADDR;
  p = DecimalToByte(p, &addr.s.a1);
  if (*p == '\0' || *p++ != '.')
    return IP_ANYADDR;
  p = DecimalToByte(p, &addr.s.a2);
  if (*p == '\0' || *p++ != '.')
    return IP_ANYADDR;
  p = DecimalToByte(p, &addr.s.a3);
  if (*p != '\0')
    return IP_ANYADDR;
  return addr.a;
}

static int
GetLine(char **argv, int argvsize) {
  char *p, ch;
  static char line[128];
  int argc;

  /*
   * Read command line, implement some simple editing features
   */
  p = line;
  while ((ch = getchar()) != '\r' && ch != '\n' && (p-line) < sizeof(line)) {
    if (ch == '\b') {
      if (p > line) {
	p--;
	printf(" \b");
      }
    } else
      *p++ = ch;
  }
  *p = '\0';

  /*
   * Break command line up into an argument vector
   */
  argc = 0;
  for (p = line; *p == ' ' || *p == '\t'; p++)
    /* skip white spaces */;
  while (*p != ' ' && *p != '\t' && *p != '\n' && *p != '\0') {
    if (argc > argvsize) break;
    argv[(argc)++] = p;
    for (; *p != ' ' && *p != '\t' && *p != '\n' && *p != '\0'; p++)
      /* skip word */;
    if (*p != '\0') *p++ ='\0';
    for (; *p == ' ' || *p == '\t'; p++)
      /* skip white spaces */;
  }
  argv[(argc)] = (char *)0;
  return argc;
}

enum cmd_token_type {
  CMD_GO,
  CMD_HELP,
  CMD_RESET,
  CMD_AUTO,
  CMD_WHO,
  CMD_REBOOT,
  CMD_DISKBOOT,
  CMD_ADDRESS,
  CMD_GATEWAY,
  CMD_TFTP,
  CMD_DEBUG,
  CMD_SINGLE,
  CMD_FILE,
  CMD_SERVER,
};

struct commands {
  enum cmd_token_type cmd_token;
  char *cmd_name;
  char *cmd_help;
} commands[] = {
  {CMD_GO, 	"go",		"                       start loaded binary"},
  {CMD_HELP,	"help",		"                     this help message"},
  {CMD_RESET,	"reset",	"                    reset ethernet board"},
  {CMD_AUTO,	"auto",		"                     continue with auto boot"},
  {CMD_WHO,	"whoami",	"                       get IP address"},
  {CMD_REBOOT,	"reboot",	"                   hard reboot"},
  {CMD_DISKBOOT,	"diskboot",	"                 soft reboot (from disk)"},
  {CMD_ADDRESS,  "address",	"[<addr>]          set IP address"},
  {CMD_GATEWAY,  "gateway",	"[<addr>]          set IP gateway"},
  {CMD_SERVER, "server", "[<addr>]           set server IP address"},
  {CMD_FILE, "file", "[<name>]             set boot file name"},
  {CMD_TFTP,	"tftp",		"                     TFTP download"},
  {CMD_DEBUG, "debug", "                    enter kernel debugger at boot"},
  {CMD_SINGLE, "single", "                   enter single user at boot"},
};

#define ARGVECSIZE 100

/*
 * A very simple and terse monitor
 */
static void
Monitor(void) {
  char *argv[ARGVECSIZE];
  static char file_name[MAX_FILE_NAME_LEN+1] = "default.bsd386";
  int loaded, argc;
  int i;
  int token;
  static ipaddr_t ip_servaddr = IP_ANYADDR;

  loaded = 0;
  printf("\n"
#ifdef USE_BOOTP
	 "BOOTP/"
#endif
#ifdef USE_RARP
	 "RARP/"
#endif
	 "TFTP monitor mode\n");
  for (;;) {
    char filename[MAX_FILE_NAME_LEN+1];
    ipaddr_t gateway;
    printf("ethernet boot monitor: ");
    if ((argc = GetLine(argv, ARGVECSIZE)) > 0) {

      for (token = -1, i = 0; i < nelt(commands); i++) {
	if (strcmp(argv[0], commands[i].cmd_name) == 0) {
	  token = commands[i].cmd_token;
	  break;
	}
      }
      switch (token) {
      case CMD_HELP:
	for (i = 0; i < nelt(commands); i++)
	  printf("%s %s\n", commands[i].cmd_name, commands[i].cmd_help);
	break;
      case CMD_RESET:
	PktInit();
	EtherReset();
	break;
      case CMD_REBOOT:
	EtherStop();
	ResetCpu();
	break;
      case CMD_DISKBOOT:
	EtherStop();
	exit(0);
	break;
      case CMD_AUTO:
	return;
      case CMD_WHO:
	(void) GetIpAddress(&ip_servaddr, &ip_myaddr, &gateway, filename);
	break;
      case CMD_ADDRESS:
	if (argc != 2) {
	  printf("My IP address is ");
	  IpPrintAddr(ip_myaddr);
	  printf("\n");
	} else
	  ip_myaddr = IpConvertAddr(argv[1]);
	break;
      case CMD_SERVER:
	if (argc != 2) {
	  printf("Server's IP address is ");
	  IpPrintAddr(ip_servaddr);
	  printf("\n");
	} else
	  ip_servaddr = IpConvertAddr(argv[1]);
	break;
      case CMD_FILE:
	if (argc != 2) {
	  printf("File name is \"%s\"\n", file_name);
	} else
	  strncpy(file_name, argv[1], MAX_FILE_NAME_LEN);
	break;
      case CMD_GATEWAY:
	if (argc != 2) {
	  printf("Gateway IP address is ");
	  IpPrintAddr(ip_gateway);
	  printf("\n");
	} else
	  ip_gateway = IpConvertAddr(argv[1]);
	break;
      case CMD_DEBUG:
	howto ^= RB_KDB;
	break;
      case CMD_SINGLE:
	howto ^= RB_SINGLE;
	break;
      case CMD_TFTP:
	if (ip_myaddr == IP_ANYADDR) {
	  printf("This machine's IP address must be set first.\n");
	  goto complain;
	}
	loaded = LoadProgFromServer(ip_servaddr, ip_gateway, file_name);
	printf("File could not be loaded, giving up.\n");
	break;
      default:
	goto complain;
      }
    } else
    complain:
      printf("Invalid or incorrect command. Type \"help\" for help.\n");
  }
}

static jmp_buf jmp_env;

void
HandleKbdAttn(void) {
  if (IsKbdCharReady())
    if (getc() == 0x1b) {
      EtherReset();
      PktInit();
      longjmp(jmp_env, 1);
    }
}

int time_zero;

void
main(void) {

  extern char edata[], end[];
  char volatile * volatile p;

  /* clear bss */
  for (p = edata; p < end; p++)
    *p = 0;

  printf(
#ifdef USE_BOOTP
	 "BOOTP/"
#endif
#ifdef USE_RARP
	 "RARP/"
#endif
	 "TFTP bootstrap loader @0x%x: %d/%d k of memory. ^] for attn.\n",
	 work_area_org,
	 GetMemSize(0),
	 GetMemSize(1));

  gateA20();

  PktInit();
  if (!EtherInit()) {
    printf("No ethernet board found\n");
    exit(1);
  }
  srand((time_zero=timer()) ^ eth_myaddr[5]);

  printf("Ethernet address is ");
  EtherPrintAddr(eth_myaddr);
  printf("\n");

  for (;;) {
    if (setjmp(jmp_env))
      Monitor();
    else {
      TryToLoadSomething();
    }
  }
}

#ifdef __GNUC__
void
__main(void) {
}
#endif