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
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  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                 setenv("dhcp.host-name", hostname, 1);
 312         }
 313     }
 314     pxe_opens++;
 315     f->f_devdata = &pxe_sock;
 316     return (error);
 317 }
 318
 319 static int
 320 pxe_close(struct open_file *f)
 321 {
 322
 323 #ifdef  PXE_DEBUG
 324     if (pxe_debug)
 325         printf("pxe_close: opens=%d\n", pxe_opens);
 326 #endif
 327
 328     /* On last close, do netif close, etc. */
 329     f->f_devdata = NULL;
 330     /* Extra close call? */
 331     if (pxe_opens <= 0)
 332         return (0);
 333     pxe_opens--;
 334     /* Not last close? */
 335     if (pxe_opens > 0)
 336         return(0);
 337
 338     /* get an NFS filehandle for our root filesystem */
 339     pxe_setnfshandle(rootpath);
 340
 341     if (pxe_sock >= 0) {
 342
 343 #ifdef PXE_DEBUG
 344         if (pxe_debug)
 345             printf("pxe_close: calling netif_close()\n");
 346 #endif
 347         netif_close(pxe_sock);
 348         pxe_sock = -1;
 349     }
 350     return (0);
 351 }
 352
 353 static void
 354 pxe_print(int verbose)
 355 {
 356         if (pxe_call != NULL) {
 357                 if (*bootplayer.Sname == '\0') {
 358                         printf("      "IP_STR":%s\n",
 359                                IP_ARGS(htonl(bootplayer.sip)),
 360                                bootplayer.bootfile);
 361                 } else {
 362                         printf("      %s:%s\n", bootplayer.Sname,
 363                                bootplayer.bootfile);
 364                 }
 365         }
 366
 367         return;
 368 }
 369
 370 static void
 371 pxe_cleanup(void)
 372 {
 373 #ifdef PXE_DEBUG
 374         t_PXENV_UNLOAD_STACK *unload_stack_p =
 375             (t_PXENV_UNLOAD_STACK *)scratch_buffer;
 376         t_PXENV_UNDI_SHUTDOWN *undi_shutdown_p =
 377             (t_PXENV_UNDI_SHUTDOWN *)scratch_buffer;
 378 #endif
 379
 380         if (pxe_call == NULL)
 381                 return;
 382
 383         pxe_call(PXENV_UNDI_SHUTDOWN);
 384
 385 #ifdef PXE_DEBUG
 386         if (pxe_debug && undi_shutdown_p->Status != 0)
 387                 printf("pxe_cleanup: UNDI_SHUTDOWN failed %x\n",
 388                        undi_shutdown_p->Status);
 389 #endif
 390
 391         pxe_call(PXENV_UNLOAD_STACK);
 392
 393 #ifdef PXE_DEBUG
 394         if (pxe_debug && unload_stack_p->Status != 0)
 395                 printf("pxe_cleanup: UNLOAD_STACK failed %x\n",
 396                     unload_stack_p->Status);
 397 #endif
 398 }
 399
 400 void
 401 pxe_perror(int err)
 402 {
 403         return;
 404 }
 405
 406 /*
 407  * Reach inside the libstand NFS code and dig out an NFS handle
 408  * for the root filesystem.
 409  */
 410 struct nfs_iodesc {
 411         struct  iodesc  *iodesc;
 412         off_t   off;
 413         u_char  fh[NFS_FHSIZE];
 414         /* structure truncated here */
 415 };
 416 extern struct   nfs_iodesc nfs_root_node;
 417 extern int      rpc_port;
 418
 419 static void
 420 pxe_rpcmountcall()
 421 {
 422         struct  iodesc *d;
 423         int     error;
 424
 425         if (!(d = socktodesc(pxe_sock)))
 426                 return;
 427         d->myport = htons(--rpc_port);
 428         d->destip = rootip;
 429         if ((error = nfs_getrootfh(d, rootpath, nfs_root_node.fh)) != 0)
 430                 printf("NFS MOUNT RPC error: %d\n", error);
 431         nfs_root_node.iodesc = d;
 432 }
 433
 434 static void
 435 pxe_setnfshandle(char *rootpath)
 436 {
 437         int     i;
 438         u_char  *fh;
 439         char    buf[2 * NFS_FHSIZE + 3], *cp;
 440
 441         /*
 442          * If NFS files were never opened, we need to do mount call
 443          * ourselves. Use nfs_root_node.iodesc as flag indicating
 444          * previous NFS usage.
 445          */
 446         if (nfs_root_node.iodesc == NULL)
 447                 pxe_rpcmountcall();
 448
 449         fh = &nfs_root_node.fh[0];
 450         buf[0] = 'X';
 451         cp = &buf[1];
 452         for (i = 0; i < NFS_FHSIZE; i++, cp += 2)
 453                 sprintf(cp, "%02x", fh[i]);
 454         sprintf(cp, "X");
 455         setenv("boot.nfsroot.nfshandle", buf, 1);
 456 }
 457
 458 void
 459 pxenv_call(int func)
 460 {
 461 #ifdef PXE_DEBUG
 462         if (pxe_debug)
 463                 printf("pxenv_call %x\n", func);
 464 #endif
 465
 466         bzero(&v86, sizeof(v86));
 467         bzero(data_buffer, sizeof(data_buffer));
 468
 469         __pxenvseg = pxenv_p->RMEntry.segment;
 470         __pxenvoff = pxenv_p->RMEntry.offset;
 471
 472         v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
 473         v86.es   = VTOPSEG(scratch_buffer);
 474         v86.edi  = VTOPOFF(scratch_buffer);
 475         v86.addr = (VTOPSEG(__pxenventry) << 16) | VTOPOFF(__pxenventry);
 476         v86.ebx  = func;
 477         v86int();
 478         v86.ctl  = V86_FLAGS;
 479 }
 480
 481 void
 482 bangpxe_call(int func)
 483 {
 484 #ifdef PXE_DEBUG
 485         if (pxe_debug)
 486                 printf("bangpxe_call %x\n", func);
 487 #endif
 488
 489         bzero(&v86, sizeof(v86));
 490         bzero(data_buffer, sizeof(data_buffer));
 491
 492         __bangpxeseg = pxe_p->EntryPointSP.segment;
 493         __bangpxeoff = pxe_p->EntryPointSP.offset;
 494
 495         v86.ctl  = V86_ADDR | V86_CALLF | V86_FLAGS;
 496         v86.edx  = VTOPSEG(scratch_buffer);
 497         v86.eax  = VTOPOFF(scratch_buffer);
 498         v86.addr = (VTOPSEG(__bangpxeentry) << 16) | VTOPOFF(__bangpxeentry);
 499         v86.ebx  = func;
 500         v86int();
 501         v86.ctl  = V86_FLAGS;
 502 }
 503
 504
 505 time_t
 506 getsecs()
 507 {
 508         time_t n = 0;
 509         time(&n);
 510         return n;
 511 }
 512
 513 static int
 514 pxe_netif_match(struct netif *nif, void *machdep_hint)
 515 {
 516         return 1;
 517 }
 518
 519
 520 static int
 521 pxe_netif_probe(struct netif *nif, void *machdep_hint)
 522 {
 523         t_PXENV_UDP_OPEN *udpopen_p = (t_PXENV_UDP_OPEN *)scratch_buffer;
 524
 525         if (pxe_call == NULL)
 526                 return -1;
 527
 528         bzero(udpopen_p, sizeof(*udpopen_p));
 529         udpopen_p->src_ip = bootplayer.yip;
 530         pxe_call(PXENV_UDP_OPEN);
 531
 532         if (udpopen_p->status != 0) {
 533                 printf("pxe_netif_probe: failed %x\n", udpopen_p->status);
 534                 return -1;
 535         }
 536         return 0;
 537 }
 538
 539 static void
 540 pxe_netif_end(struct netif *nif)
 541 {
 542         t_PXENV_UDP_CLOSE *udpclose_p = (t_PXENV_UDP_CLOSE *)scratch_buffer;
 543         bzero(udpclose_p, sizeof(*udpclose_p));
 544
 545         pxe_call(PXENV_UDP_CLOSE);
 546         if (udpclose_p->status != 0)
 547                 printf("pxe_end failed %x\n", udpclose_p->status);
 548 }
 549
 550 static void
 551 pxe_netif_init(struct iodesc *desc, void *machdep_hint)
 552 {
 553         int i;
 554         for (i = 0; i < 6; ++i)
 555                 desc->myea[i] = bootplayer.CAddr[i];
 556         desc->xid = bootplayer.ident;
 557 }
 558
 559 static int
 560 pxe_netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
 561 {
 562         return len;
 563 }
 564
 565 static int
 566 pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
 567 {
 568         return len;
 569 }
 570
 571 ssize_t
 572 sendudp(struct iodesc *h, void *pkt, size_t len)
 573 {
 574         t_PXENV_UDP_WRITE *udpwrite_p = (t_PXENV_UDP_WRITE *)scratch_buffer;
 575         bzero(udpwrite_p, sizeof(*udpwrite_p));
 576
 577         udpwrite_p->ip             = h->destip.s_addr;
 578         udpwrite_p->dst_port       = h->destport;
 579         udpwrite_p->src_port       = h->myport;
 580         udpwrite_p->buffer_size    = len;
 581         udpwrite_p->buffer.segment = VTOPSEG(pkt);
 582         udpwrite_p->buffer.offset  = VTOPOFF(pkt);
 583
 584         if (netmask == 0 || SAMENET(myip, h->destip, netmask))
 585                 udpwrite_p->gw = 0;
 586         else
 587                 udpwrite_p->gw = gateip.s_addr;
 588
 589         pxe_call(PXENV_UDP_WRITE);
 590
 591 #if 0
 592         /* XXX - I dont know why we need this. */
 593         delay(1000);
 594 #endif
 595         if (udpwrite_p->status != 0) {
 596                 /* XXX: This happens a lot.  It shouldn't. */
 597                 if (udpwrite_p->status != 1)
 598                         printf("sendudp failed %x\n", udpwrite_p->status);
 599                 return -1;
 600         }
 601         return len;
 602 }
 603
 604 ssize_t
 605 readudp(struct iodesc *h, void *pkt, size_t len, time_t timeout)
 606 {
 607         t_PXENV_UDP_READ *udpread_p = (t_PXENV_UDP_READ *)scratch_buffer;
 608         struct udphdr *uh = NULL;
 609
 610         uh = (struct udphdr *) pkt - 1;
 611         bzero(udpread_p, sizeof(*udpread_p));
 612
 613         udpread_p->dest_ip        = h->myip.s_addr;
 614         udpread_p->d_port         = h->myport;
 615         udpread_p->buffer_size    = len;
 616         udpread_p->buffer.segment = VTOPSEG(data_buffer);
 617         udpread_p->buffer.offset  = VTOPOFF(data_buffer);
 618
 619         pxe_call(PXENV_UDP_READ);
 620
 621 #if 0
 622         /* XXX - I dont know why we need this. */
 623         delay(1000);
 624 #endif
 625         if (udpread_p->status != 0) {
 626                 /* XXX: This happens a lot.  It shouldn't. */
 627                 if (udpread_p->status != 1)
 628                         printf("readudp failed %x\n", udpread_p->status);
 629                 return -1;
 630         }
 631         bcopy(data_buffer, pkt, udpread_p->buffer_size);
 632         uh->uh_sport = udpread_p->s_port;
 633         return udpread_p->buffer_size;
 634 }