sys/boot/i386/libi386/pxe.c

   1 /*-
   2  * Copyright (c) 2000 Alfred Perlstein <alfred@freebsd.org>
   3  * Copyright (c) 2000 Paul Saab <ps@freebsd.org>
   4  * Copyright (c) 2000 John Baldwin <jhb@freebsd.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/boot/i386/libi386/pxe.c,v 1.20 2003/08/25 23:28:31 obrien Exp $
  29  * $DragonFly: src/sys/boot/i386/libi386/Attic/pxe.c,v 1.4 2003/11/10 06:08:36 dillon Exp $
  30  */
  31
  32 #include <stand.h>
  33 #include <string.h>
  34 #include <stdarg.h>
  35
  36 #include <netinet/in_systm.h>
  37 #include <netinet/in.h>
  38 #include <netinet/udp.h>
  39
  40 #include <net.h>
  41 #include <netif.h>
  42 #include <nfsv2.h>
  43 #include <iodesc.h>
  44
  45 #include <bootp.h>
  46 #include <bootstrap.h>
  47 #include "btxv86.h"
  48 #include "pxe.h"
  49
  50 /*
  51  * Allocate the PXE buffers statically instead of sticking grimy fingers into
  52  * BTX's private data area.  The scratch buffer is used to send information to
  53  * the PXE BIOS, and the data buffer is used to receive data from the PXE BIOS.
  54  */
  55 #define PXE_BUFFER_SIZE         0x2000
  56 #define PXE_TFTP_BUFFER_SIZE    512
  57 static char     scratch_buffer[PXE_BUFFER_SIZE];
  58 static char     data_buffer[PXE_BUFFER_SIZE];
  59
  60 static pxenv_t  *pxenv_p = NULL;        /* PXENV+ */
  61 static pxe_t    *pxe_p   = NULL;        /* !PXE */
  62 static BOOTPLAYER       bootplayer;     /* PXE Cached information. */
  63
  64 static int      pxe_debug = 0;
  65 static int      pxe_sock = -1;
  66 static int      pxe_opens = 0;
  67
  68 void            pxe_enable(void *pxeinfo);
  69 static void     (*pxe_call)(int func);
  70 static void     pxenv_call(int func);
  71 static void     bangpxe_call(int func);
  72
  73 static int      pxe_init(void);
  74 static int      pxe_strategy(void *devdata, int flag, daddr_t dblk,
  75                              size_t size, char *buf, size_t *rsize);
  76 static int      pxe_open(struct open_file *f, ...);
  77 static int      pxe_close(struct open_file *f);
  78 static void     pxe_print(int verbose);
  79 static void     pxe_cleanup(void);
  80 static void     pxe_setnfshandle(char *rootpath);
  81
  82 static void     pxe_perror(int error);
  83 static int      pxe_netif_match(struct netif *nif, void *machdep_hint);
  84 static int      pxe_netif_probe(struct netif *nif, void *machdep_hint);
  85 static void     pxe_netif_init(struct iodesc *desc, void *machdep_hint);
  86 static int      pxe_netif_get(struct iodesc *desc, void *pkt, size_t len,
  87                               time_t timeout);
  88 static int      pxe_netif_put(struct iodesc *desc, void *pkt, size_t len);
  89 static void     pxe_netif_end(struct netif *nif);
  90
  91 extern struct netif_stats       pxe_st[];
  92 extern u_int16_t                __bangpxeseg;
  93 extern u_int16_t                __bangpxeoff;
  94 extern void                     __bangpxeentry(void);
  95 extern u_int16_t                __pxenvseg;
  96 extern u_int16_t                __pxenvoff;
  97 extern void                     __pxenventry(void);
  98
  99 struct netif_dif pxe_ifs[] = {
 100 /*      dif_unit        dif_nsel        dif_stats       dif_private     */
 101         {0,             1,              &pxe_st[0],     0}
 102 };
 103
 104 struct netif_stats pxe_st[NENTS(pxe_ifs)];
 105
 106 struct netif_driver pxenetif = {
 107         "pxenet",
 108         pxe_netif_match,
 109         pxe_netif_probe,
 110         pxe_netif_init,
 111         pxe_netif_get,
 112         pxe_netif_put,
 113         pxe_netif_end,
 114         pxe_ifs,
 115         NENTS(pxe_ifs)
 116 };
 117
 118 struct netif_driver *netif_drivers[] = {
 119         &pxenetif,
 120         NULL
 121 };
 122
 123 struct devsw pxedisk = {
 124         "pxe",
 125         DEVT_NET,
 126         pxe_init,
 127         pxe_strategy,
 128         pxe_open,
 129         pxe_close,
 130         noioctl,
 131         pxe_print,
 132         pxe_cleanup
 133 };
 134
 135 /*
 136  * This function is called by the loader to enable PXE support if we
 137  * are booted by PXE.  The passed in pointer is a pointer to the
 138  * PXENV+ structure.
 139  */
 140 void
 141 pxe_enable(void *pxeinfo)
 142 {
 143         pxenv_p  = (pxenv_t *)pxeinfo;
 144         pxe_p    = (pxe_t *)PTOV(pxenv_p->PXEPtr.segment * 16 +
 145                                  pxenv_p->PXEPtr.offset);
 146         pxe_call = NULL;
 147 }
 148
 149 /*
 150  * return true if pxe structures are found/initialized,
 151  * also figures out our IP information via the pxe cached info struct
 152  */
 153 static int
 154 pxe_init(void)
 155 {
 156         t_PXENV_GET_CACHED_INFO *gci_p;
 157         int     counter;
 158         uint8_t checksum;
 159         uint8_t *checkptr;
 160
 161         if(pxenv_p == NULL)
 162                 return (0);
 163
 164         /*  look for "PXENV+" */
 165         if (bcmp((void *)pxenv_p->Signature, S_SIZE("PXENV+"))) {
 166                 pxenv_p = NULL;
 167                 return (0);
 168         }
 169
 170         /* make sure the size is something we can handle */
 171         if (pxenv_p->Length > sizeof(*pxenv_p)) {
 172                 printf("PXENV+ structure too large, ignoring\n");
 173                 pxenv_p = NULL;
 174                 return (0);
 175         }
 176
 177         /*
 178          * do byte checksum:
 179          * add up each byte in the structure, the total should be 0
 180          */
 181         checksum = 0;
 182         checkptr = (uint8_t *) pxenv_p;
 183         for (counter = 0; counter < pxenv_p->Length; counter++)
 184                 checksum += *checkptr++;
 185         if (checksum != 0) {
 186                 printf("PXENV+ structure failed checksum, ignoring\n");
 187                 pxenv_p = NULL;
 188                 return (0);
 189         }
 190
 191
 192         /*
 193          * PXENV+ passed, so use that if !PXE is not available or
 194          * the checksum fails.
 195          */
 196         pxe_call = pxenv_call;
 197         if (pxenv_p->Version >= 0x0200) {
 198                 for (;;) {
 199                         if (bcmp((void *)pxe_p->Signature, S_SIZE("!PXE"))) {
 200                                 pxe_p = NULL;
 201                                 break;
 202                         }
 203                         checksum = 0;
 204                         checkptr = (uint8_t *)pxe_p;
 205                         for (counter = 0; counter < pxe_p->StructLength;
 206                              counter++)
 207                                 checksum += *checkptr++;
 208                         if (checksum != 0) {
 209                                 pxe_p = NULL;
 210                                 break;
 211                         }
 212                         pxe_call = bangpxe_call;
 213                         break;
 214                 }
 215         }
 216
 217         printf("\nPXE version %d.%d, real mode entry point ",
 218                (uint8_t) (pxenv_p->Version >> 8),
 219                (uint8_t) (pxenv_p->Version & 0xFF));
 220         if (pxe_call == bangpxe_call)
 221                 printf("@%04x:%04x\n",
 222                        pxe_p->EntryPointSP.segment,
 223                        pxe_p->EntryPointSP.offset);
 224         else
 225                 printf("@%04x:%04x\n",
 226                        pxenv_p->RMEntry.segment, pxenv_p->RMEntry.offset);
 227
 228         gci_p = (t_PXENV_GET_CACHED_INFO *) scratch_buffer;
 229         bzero(gci_p, sizeof(*gci_p));
 230         gci_p->PacketType =  PXENV_PACKET_TYPE_BINL_REPLY;
 231         pxe_call(PXENV_GET_CACHED_INFO);
 232         if (gci_p->Status != 0) {
 233                 pxe_perror(gci_p->Status);
 234                 pxe_p = NULL;
 235                 return (0);
 236         }
 237         bcopy(PTOV((gci_p->Buffer.segment << 4) + gci_p->Buffer.offset),
 238               &bootplayer, gci_p->BufferSize);
 239         return (1);
 240 }
 241
 242
 243 static int
 244 pxe_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
 245                 char *buf, size_t *rsize)
 246 {
 247         return (EIO);
 248 }
 249
 250 static int
 251 pxe_open(struct open_file *f, ...)
 252 {
 253     va_list args;
 254     char *devname;              /* Device part of file name (or NULL). */
 255     char temp[FNAME_SIZE];
 256     int error = 0;
 257     int i;
 258
 259     va_start(args, f);
 260     devname = va_arg(args, char*);
 261     va_end(args);
 262
 263     /* On first open, do netif open, mount, etc. */
 264     if (pxe_opens == 0) {
 265         /* Find network interface. */
 266         if (pxe_sock < 0) {
 267             pxe_sock = netif_open(devname);
 268             if (pxe_sock < 0) {
 269                 printf("pxe_open: netif_open() failed\n");
 270                 return (ENXIO);
 271             }
 272             if (pxe_debug)
 273                 printf("pxe_open: netif_open() succeeded\n");
 274         }
 275         if (rootip.s_addr == 0) {
 276                 /*
 277                  * Do a bootp/dhcp request to find out where our
 278                  * NFS/TFTP server is.  Even if we dont get back
 279                  * the proper information, fall back to the server
 280                  * which brought us to life and a default rootpath.
 281                  */
 282                 bootp(pxe_sock, BOOTP_PXE);
 283                 if (rootip.s_addr == 0)
 284                         rootip.s_addr = bootplayer.sip;
 285                 if (!rootpath[1])
 286                         strcpy(rootpath, PXENFSROOTPATH);
 287
 288                 for (i = 0; rootpath[i] != '\0' && i < FNAME_SIZE; i++)
 289                         if (rootpath[i] == ':')
 290                                 break;
 291                 if (i && i != FNAME_SIZE && rootpath[i] == ':') {
 292                         rootpath[i++] = '\0';
 293                         if (inet_addr(&rootpath[0]) != INADDR_NONE)
 294                                 rootip.s_addr = inet_addr(&rootpath[0]);
 295                         bcopy(&rootpath[i], &temp[0], strlen(&rootpath[i])+1);
 296                         bcopy(&temp[0], &rootpath[0], strlen(&rootpath[i])+1);
 297                 }
 298                 printf("pxe_open: server addr: %s\n", inet_ntoa(rootip));
 299                 printf("pxe_open: server path: %s\n", rootpath);
 300                 printf("pxe_open: gateway ip:  %s\n", inet_ntoa(gateip));
 301
 302                 setenv("boot.netif.ip", inet_ntoa(myip), 1);
 303                 setenv("boot.netif.netmask", intoa(netmask), 1);
 304                 setenv("boot.netif.gateway", inet_ntoa(gateip), 1);
 305                 if (bootplayer.Hardware == ETHER_TYPE) {
 306                     sprintf(temp, "%6D", bootplayer.CAddr, ":");
 307                     setenv("boot.netif.hwaddr", temp, 1);
 308                 }
 309                 setenv("boot.nfsroot.server", inet_ntoa(rootip), 1);
 310                 setenv("boot.nfsroot.path", rootpath, 1);
 311         }
 312     }
 313     pxe_opens++;
 314     f->f_devdata = &pxe_sock;
 315     return (error);
 316 }
 317
 318 static int
 319 pxe_close(struct open_file *f)
 320 {
 321
 322 #ifdef  PXE_DEBUG
 323     if (pxe_debug)
 324         printf("pxe_close: opens=%d\n", pxe_opens);
 325 #endif
 326
 327     /* On last close, do netif close, etc. */
 328     f->f_devdata = NULL;
 329     /* Extra close call? */
 330     if (pxe_opens <= 0)
 331         return (0);
 332     pxe_opens--;
 333     /* Not last close? */
 334     if (pxe_opens > 0)
 335         return(0);
 336
 337     /* get an NFS filehandle for our root filesystem */
 338     pxe_setnfshandle(rootpath);
 339
 340     if (pxe_sock >= 0) {
 341
 342 #ifdef PXE_DEBUG
 343         if (pxe_debug)
 344             printf("pxe_close: calling netif_close()\n");
 345 #endif
 346         netif_close(pxe_sock);
 347         pxe_sock = -1;
 348     }
 349     return (0);
 350 }
 351
 352 static void
 353 pxe_print(int verbose)
 354 {
 355         if (pxe_call != NULL) {
 356                 if (*bootplayer.Sname == '\0') {
 357                         printf("      "IP_STR":%s\n",
 358                                IP_ARGS(htonl(bootplayer.sip)),
 359                                bootplayer.bootfile);
 360                 } else {
 361                         printf("      %s:%s\n", bootplayer.Sname,
 362                                bootplayer.bootfile);
 363                 }
 364         }
 365
 366         return;
 367 }
 368
 369 static void
 370 pxe_cleanup(void)
 371 {
 372 #ifdef PXE_DEBUG
 373         t_PXENV_UNLOAD_STACK *unload_stack_p =
 374             (t_PXENV_UNLOAD_STACK *)scratch_buffer;
 375         t_PXENV_UNDI_SHUTDOWN *undi_shutdown_p =
 376             (t_PXENV_UNDI_SHUTDOWN *)scratch_buffer;
 377 #endif
 378
 379         if (pxe_call == NULL)
 380                 return;
 381
 382         pxe_call(PXENV_UNDI_SHUTDOWN);
 383
 384 #ifdef PXE_DEBUG
 385         if (pxe_debug && undi_shutdown_p->Status != 0)
 386                 printf("pxe_cleanup: UNDI_SHUTDOWN failed %x\n",
 387                        undi_shutdown_p->Status);
 388 #endif
 389
 390         pxe_call(PXENV_UNLOAD_STACK);
 391
 392 #ifdef PXE_DEBUG
 393         if (pxe_debug && unload_stack_p->Status != 0)
 394                 printf("pxe_cleanup: UNLOAD_STACK failed %x\n",
 395                     unload_stack_p->Status);
 396 #endif
 397 }
 398
 399 void
 400 pxe_perror(int err)
 401 {
 402         return;
 403 }
 404
 405 /*
 406  * Reach inside the libstand NFS code and dig out an NFS handle
 407  * for the root filesystem.
 408  */
 409 struct nfs_iodesc {
 410         struct  iodesc  *iodesc;
 411         off_t   off;
 412         u_char  fh[NFS_FHSIZE];
 413         /* structure truncated here */
 414 };
 415 extern struct   nfs_iodesc nfs_root_node;
 416
 417 static void
 418 pxe_setnfshandle(char *rootpath)
 419 {
 420         int     i;
 421         u_char  *fh;
 422         char    buf[2 * NFS_FHSIZE + 3], *cp;
 423
 424         fh = &nfs_root_node.fh[0];
 425         buf[0] = 'X';
 426         cp = &buf[1];
 427         for (i = 0; i < NFS_FHSIZE; i++, cp += 2)
 428                 sprintf(cp, "%02x", fh[i]);
 429         sprintf(cp, "X");
 430         setenv("boot.nfsroot.nfshandle", buf, 1);
 431 }
 432
 433 void
 434 pxenv_call(int func)
 435 {
 436 #ifdef PXE_DEBUG
 437         if (pxe_debug)
 438                 printf("pxenv_call %x\n", func);
 439 #endif
 440
 441         bzero(&v86, sizeof(v86));
 442         bzero(data_buffer, sizeof(data_buffer));
 443
 444         __pxenvseg = pxenv_p->RMEntry.segment;
 445         __pxenvoff = pxenv_p->RMEntry.offset;
 446
 447         v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
 448         v86.es   = VTOPSEG(scratch_buffer);
 449         v86.edi  = VTOPOFF(scratch_buffer);
 450         v86.addr = (VTOPSEG(__pxenventry) << 16) | VTOPOFF(__pxenventry);
 451         v86.ebx  = func;
 452         v86int();
 453         v86.ctl  = V86_FLAGS;
 454 }
 455
 456 void
 457 bangpxe_call(int func)
 458 {
 459 #ifdef PXE_DEBUG
 460         if (pxe_debug)
 461                 printf("bangpxe_call %x\n", func);
 462 #endif
 463
 464         bzero(&v86, sizeof(v86));
 465         bzero(data_buffer, sizeof(data_buffer));
 466
 467         __bangpxeseg = pxe_p->EntryPointSP.segment;
 468         __bangpxeoff = pxe_p->EntryPointSP.offset;
 469
 470         v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
 471         v86.edx  = VTOPSEG(scratch_buffer);
 472         v86.eax  = VTOPOFF(scratch_buffer);
 473         v86.addr = (VTOPSEG(__bangpxeentry) << 16) | VTOPOFF(__bangpxeentry);
 474         v86.ebx  = func;
 475         v86int();
 476         v86.ctl  = V86_FLAGS;
 477 }
 478
 479
 480 time_t
 481 getsecs()
 482 {
 483         time_t n = 0;
 484         time(&n);
 485         return n;
 486 }
 487
 488 static int
 489 pxe_netif_match(struct netif *nif, void *machdep_hint)
 490 {
 491         return 1;
 492 }
 493
 494
 495 static int
 496 pxe_netif_probe(struct netif *nif, void *machdep_hint)
 497 {
 498         t_PXENV_UDP_OPEN *udpopen_p = (t_PXENV_UDP_OPEN *)scratch_buffer;
 499
 500         if (pxe_call == NULL)
 501                 return -1;
 502
 503         bzero(udpopen_p, sizeof(*udpopen_p));
 504         udpopen_p->src_ip = bootplayer.yip;
 505         pxe_call(PXENV_UDP_OPEN);
 506
 507         if (udpopen_p->status != 0) {
 508                 printf("pxe_netif_probe: failed %x\n", udpopen_p->status);
 509                 return -1;
 510         }
 511         return 0;
 512 }
 513
 514 static void
 515 pxe_netif_end(struct netif *nif)
 516 {
 517         t_PXENV_UDP_CLOSE *udpclose_p = (t_PXENV_UDP_CLOSE *)scratch_buffer;
 518         bzero(udpclose_p, sizeof(*udpclose_p));
 519
 520         pxe_call(PXENV_UDP_CLOSE);
 521         if (udpclose_p->status != 0)
 522                 printf("pxe_end failed %x\n", udpclose_p->status);
 523 }
 524
 525 static void
 526 pxe_netif_init(struct iodesc *desc, void *machdep_hint)
 527 {
 528         int i;
 529         for (i = 0; i < 6; ++i)
 530                 desc->myea[i] = bootplayer.CAddr[i];
 531         desc->xid = bootplayer.ident;
 532 }
 533
 534 static int
 535 pxe_netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
 536 {
 537         return len;
 538 }
 539
 540 static int
 541 pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
 542 {
 543         return len;
 544 }
 545
 546 ssize_t
 547 sendudp(struct iodesc *h, void *pkt, size_t len)
 548 {
 549         t_PXENV_UDP_WRITE *udpwrite_p = (t_PXENV_UDP_WRITE *)scratch_buffer;
 550         bzero(udpwrite_p, sizeof(*udpwrite_p));
 551
 552         udpwrite_p->ip             = h->destip.s_addr;
 553         udpwrite_p->dst_port       = h->destport;
 554         udpwrite_p->src_port       = h->myport;
 555         udpwrite_p->buffer_size    = len;
 556         udpwrite_p->buffer.segment = VTOPSEG(pkt);
 557         udpwrite_p->buffer.offset  = VTOPOFF(pkt);
 558
 559         if (netmask == 0 || SAMENET(myip, h->destip, netmask))
 560                 udpwrite_p->gw = 0;
 561         else
 562                 udpwrite_p->gw = gateip.s_addr;
 563
 564         pxe_call(PXENV_UDP_WRITE);
 565
 566 #if 0
 567         /* XXX - I dont know why we need this. */
 568         delay(1000);
 569 #endif
 570         if (udpwrite_p->status != 0) {
 571                 /* XXX: This happens a lot.  It shouldn't. */
 572                 if (udpwrite_p->status != 1)
 573                         printf("sendudp failed %x\n", udpwrite_p->status);
 574                 return -1;
 575         }
 576         return len;
 577 }
 578
 579 ssize_t
 580 readudp(struct iodesc *h, void *pkt, size_t len, time_t timeout)
 581 {
 582         t_PXENV_UDP_READ *udpread_p = (t_PXENV_UDP_READ *)scratch_buffer;
 583         struct udphdr *uh = NULL;
 584
 585         uh = (struct udphdr *) pkt - 1;
 586         bzero(udpread_p, sizeof(*udpread_p));
 587
 588         udpread_p->dest_ip        = h->myip.s_addr;
 589         udpread_p->d_port         = h->myport;
 590         udpread_p->buffer_size    = len;
 591         udpread_p->buffer.segment = VTOPSEG(data_buffer);
 592         udpread_p->buffer.offset  = VTOPOFF(data_buffer);
 593
 594         pxe_call(PXENV_UDP_READ);
 595
 596 #if 0
 597         /* XXX - I dont know why we need this. */
 598         delay(1000);
 599 #endif
 600         if (udpread_p->status != 0) {
 601                 /* XXX: This happens a lot.  It shouldn't. */
 602                 if (udpread_p->status != 1)
 603                         printf("readudp failed %x\n", udpread_p->status);
 604                 return -1;
 605         }
 606         bcopy(data_buffer, pkt, udpread_p->buffer_size);
 607         uh->uh_sport = udpread_p->s_port;
 608         return udpread_p->buffer_size;
 609 }