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>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
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.7 2005/09/03 23:52:47 dillon Exp $
32 #include <sys/param.h>
37 #include <netinet/in_systm.h>
38 #include <netinet/in.h>
39 #include <netinet/udp.h>
47 #include <bootstrap.h>
52 * Allocate the PXE buffers statically instead of sticking grimy fingers into
53 * BTX's private data area. The scratch buffer is used to send information to
54 * the PXE BIOS, and the data buffer is used to receive data from the PXE BIOS.
56 #define PXE_BUFFER_SIZE 0x2000
57 #define PXE_TFTP_BUFFER_SIZE 512
58 static char scratch_buffer[PXE_BUFFER_SIZE];
59 static char data_buffer[PXE_BUFFER_SIZE];
61 static pxenv_t *pxenv_p = NULL; /* PXENV+ */
62 static pxe_t *pxe_p = NULL; /* !PXE */
63 static BOOTPLAYER bootplayer; /* PXE Cached information. */
65 static int pxe_debug = 0;
66 static int pxe_sock = -1;
67 static int pxe_opens = 0;
69 void pxe_enable(void *pxeinfo);
70 static void (*pxe_call)(int func);
71 static void pxenv_call(int func);
72 static void bangpxe_call(int func);
74 static int pxe_init(void);
75 static int pxe_strategy(void *devdata, int flag, daddr_t dblk,
76 size_t size, char *buf, size_t *rsize);
77 static int pxe_open(struct open_file *f, ...);
78 static int pxe_close(struct open_file *f);
79 static void pxe_print(int verbose);
80 static void pxe_cleanup(void);
81 static void pxe_setnfshandle(char *rootpath);
83 static void pxe_perror(int error);
84 static int pxe_netif_match(struct netif *nif, void *machdep_hint);
85 static int pxe_netif_probe(struct netif *nif, void *machdep_hint);
86 static void pxe_netif_init(struct iodesc *desc, void *machdep_hint);
87 static int pxe_netif_get(struct iodesc *desc, void *pkt, size_t len,
89 static int pxe_netif_put(struct iodesc *desc, void *pkt, size_t len);
90 static void pxe_netif_end(struct netif *nif);
92 extern struct netif_stats pxe_st[];
93 extern u_int16_t __bangpxeseg;
94 extern u_int16_t __bangpxeoff;
95 extern void __bangpxeentry(void);
96 extern u_int16_t __pxenvseg;
97 extern u_int16_t __pxenvoff;
98 extern void __pxenventry(void);
100 struct netif_dif pxe_ifs[] = {
101 /* dif_unit dif_nsel dif_stats dif_private */
102 {0, 1, &pxe_st[0], 0}
105 struct netif_stats pxe_st[NENTS(pxe_ifs)];
107 struct netif_driver pxenetif = {
119 struct netif_driver *netif_drivers[] = {
124 struct devsw pxedisk = {
137 * This function is called by the loader to enable PXE support if we
138 * are booted by PXE. The passed in pointer is a pointer to the
142 pxe_enable(void *pxeinfo)
144 pxenv_p = (pxenv_t *)pxeinfo;
145 pxe_p = (pxe_t *)PTOV(pxenv_p->PXEPtr.segment * 16 +
146 pxenv_p->PXEPtr.offset);
151 * return true if pxe structures are found/initialized,
152 * also figures out our IP information via the pxe cached info struct
157 t_PXENV_GET_CACHED_INFO *gci_p;
165 /* look for "PXENV+" */
166 if (bcmp((void *)pxenv_p->Signature, S_SIZE("PXENV+"))) {
171 /* make sure the size is something we can handle */
172 if (pxenv_p->Length > sizeof(*pxenv_p)) {
173 printf("PXENV+ structure too large, ignoring\n");
180 * add up each byte in the structure, the total should be 0
183 checkptr = (uint8_t *) pxenv_p;
184 for (counter = 0; counter < pxenv_p->Length; counter++)
185 checksum += *checkptr++;
187 printf("PXENV+ structure failed checksum, ignoring\n");
194 * PXENV+ passed, so use that if !PXE is not available or
195 * the checksum fails.
197 pxe_call = pxenv_call;
198 if (pxenv_p->Version >= 0x0200) {
200 if (bcmp((void *)pxe_p->Signature, S_SIZE("!PXE"))) {
205 checkptr = (uint8_t *)pxe_p;
206 for (counter = 0; counter < pxe_p->StructLength;
208 checksum += *checkptr++;
213 pxe_call = bangpxe_call;
218 printf("\nPXE version %d.%d, real mode entry point ",
219 (uint8_t) (pxenv_p->Version >> 8),
220 (uint8_t) (pxenv_p->Version & 0xFF));
221 if (pxe_call == bangpxe_call)
222 printf("@%04x:%04x\n",
223 pxe_p->EntryPointSP.segment,
224 pxe_p->EntryPointSP.offset);
226 printf("@%04x:%04x\n",
227 pxenv_p->RMEntry.segment, pxenv_p->RMEntry.offset);
229 gci_p = (t_PXENV_GET_CACHED_INFO *) scratch_buffer;
230 bzero(gci_p, sizeof(*gci_p));
231 gci_p->PacketType = PXENV_PACKET_TYPE_BINL_REPLY;
232 pxe_call(PXENV_GET_CACHED_INFO);
233 if (gci_p->Status != 0) {
234 pxe_perror(gci_p->Status);
238 bcopy(PTOV((gci_p->Buffer.segment << 4) + gci_p->Buffer.offset),
239 &bootplayer, gci_p->BufferSize);
245 pxe_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
246 char *buf, size_t *rsize)
252 pxe_open(struct open_file *f, ...)
255 char *devname; /* Device part of file name (or NULL). */
256 char temp[FNAME_SIZE];
261 devname = va_arg(args, char*);
264 /* On first open, do netif open, mount, etc. */
265 if (pxe_opens == 0) {
266 /* Find network interface. */
268 pxe_sock = netif_open(devname);
270 printf("pxe_open: netif_open() failed\n");
274 printf("pxe_open: netif_open() succeeded\n");
276 if (rootip.s_addr == 0) {
278 * Do a bootp/dhcp request to find out where our
279 * NFS/TFTP server is. Even if we dont get back
280 * the proper information, fall back to the server
281 * which brought us to life and a default rootpath.
283 bootp(pxe_sock, BOOTP_PXE);
284 if (rootip.s_addr == 0)
285 rootip.s_addr = bootplayer.sip;
287 strcpy(rootpath, PXENFSROOTPATH);
289 for (i = 0; rootpath[i] != '\0' && i < FNAME_SIZE; i++) {
290 if (rootpath[i] == ':')
293 if (i && i != FNAME_SIZE && rootpath[i] == ':') {
294 rootpath[i++] = '\0';
295 if (inet_addr(&rootpath[0]) != INADDR_NONE)
296 rootip.s_addr = inet_addr(&rootpath[0]);
297 bcopy(&rootpath[i], &temp[0], strlen(&rootpath[i])+1);
298 bcopy(&temp[0], &rootpath[0], strlen(&rootpath[i])+1);
300 printf("pxe_open: ip address : %s\n", inet_ntoa(myip));
301 printf("pxe_open: ip netmask : %s\n", intoa(netmask));
302 printf("pxe_open: nfs root mount: %s:%s\n", inet_ntoa(rootip), rootpath);
303 printf("pxe_open: gateway ip: %s\n", inet_ntoa(gateip));
305 setenv("boot.netif.ip", inet_ntoa(myip), 1);
306 setenv("boot.netif.netmask", intoa(netmask), 1);
307 setenv("boot.netif.gateway", inet_ntoa(gateip), 1);
308 if (bootplayer.Hardware == ETHER_TYPE) {
309 sprintf(temp, "%6D", bootplayer.CAddr, ":");
310 setenv("boot.netif.hwaddr", temp, 1);
312 setenv("boot.nfsroot.server", inet_ntoa(rootip), 1);
313 setenv("boot.nfsroot.path", rootpath, 1);
317 f->f_devdata = &pxe_sock;
322 pxe_close(struct open_file *f)
327 printf("pxe_close: opens=%d\n", pxe_opens);
330 /* On last close, do netif close, etc. */
332 /* Extra close call? */
336 /* Not last close? */
340 /* get an NFS filehandle for our root filesystem */
341 pxe_setnfshandle(rootpath);
347 printf("pxe_close: calling netif_close()\n");
349 netif_close(pxe_sock);
356 pxe_print(int verbose)
358 if (pxe_call != NULL) {
359 if (*bootplayer.Sname == '\0') {
360 printf(" "IP_STR":%s\n",
361 IP_ARGS(htonl(bootplayer.sip)),
362 bootplayer.bootfile);
364 printf(" %s:%s\n", bootplayer.Sname,
365 bootplayer.bootfile);
376 t_PXENV_UNLOAD_STACK *unload_stack_p =
377 (t_PXENV_UNLOAD_STACK *)scratch_buffer;
378 t_PXENV_UNDI_SHUTDOWN *undi_shutdown_p =
379 (t_PXENV_UNDI_SHUTDOWN *)scratch_buffer;
382 if (pxe_call == NULL)
385 pxe_call(PXENV_UNDI_SHUTDOWN);
388 if (pxe_debug && undi_shutdown_p->Status != 0)
389 printf("pxe_cleanup: UNDI_SHUTDOWN failed %x\n",
390 undi_shutdown_p->Status);
393 pxe_call(PXENV_UNLOAD_STACK);
396 if (pxe_debug && unload_stack_p->Status != 0)
397 printf("pxe_cleanup: UNLOAD_STACK failed %x\n",
398 unload_stack_p->Status);
409 * Reach inside the libstand NFS code and dig out an NFS handle
410 * for the root filesystem. If there is no nfs handle but a NFS root
411 * path was dynamically requested (not just as a default), then try
412 * to get the handle. This occurs if we are compiled for TFTP operation
413 * but still want to pass an NFS root to the kernel.
416 struct iodesc *iodesc;
418 u_char fh[NFS_FHSIZE];
419 /* structure truncated here */
421 extern struct nfs_iodesc nfs_root_node;
424 pxe_setnfshandle(char *rootpath)
428 char buf[2 * NFS_FHSIZE + 3], *cp;
430 fh = &nfs_root_node.fh[0];
433 * If no file handle exists but a root path was dynamically
434 * requested, try to get a good handle.
436 for (i = 0; i < NFS_FHSIZE; ++i) {
440 if (i != NFS_FHSIZE) {
443 for (i = 0; i < NFS_FHSIZE; i++, cp += 2)
444 sprintf(cp, "%02x", fh[i]);
446 setenv("boot.nfsroot.nfshandle", buf, 1);
455 printf("pxenv_call %x\n", func);
458 bzero(&v86, sizeof(v86));
459 bzero(data_buffer, sizeof(data_buffer));
461 __pxenvseg = pxenv_p->RMEntry.segment;
462 __pxenvoff = pxenv_p->RMEntry.offset;
464 v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
465 v86.es = VTOPSEG(scratch_buffer);
466 v86.edi = VTOPOFF(scratch_buffer);
467 v86.addr = (VTOPSEG(__pxenventry) << 16) | VTOPOFF(__pxenventry);
474 bangpxe_call(int func)
478 printf("bangpxe_call %x\n", func);
481 bzero(&v86, sizeof(v86));
482 bzero(data_buffer, sizeof(data_buffer));
484 __bangpxeseg = pxe_p->EntryPointSP.segment;
485 __bangpxeoff = pxe_p->EntryPointSP.offset;
487 v86.ctl = V86_ADDR | V86_CALLF | V86_FLAGS;
488 v86.edx = VTOPSEG(scratch_buffer);
489 v86.eax = VTOPOFF(scratch_buffer);
490 v86.addr = (VTOPSEG(__bangpxeentry) << 16) | VTOPOFF(__bangpxeentry);
506 pxe_netif_match(struct netif *nif, void *machdep_hint)
513 pxe_netif_probe(struct netif *nif, void *machdep_hint)
515 t_PXENV_UDP_OPEN *udpopen_p = (t_PXENV_UDP_OPEN *)scratch_buffer;
517 if (pxe_call == NULL)
520 bzero(udpopen_p, sizeof(*udpopen_p));
521 udpopen_p->src_ip = bootplayer.yip;
522 pxe_call(PXENV_UDP_OPEN);
524 if (udpopen_p->status != 0) {
525 printf("pxe_netif_probe: failed %x\n", udpopen_p->status);
532 pxe_netif_end(struct netif *nif)
534 t_PXENV_UDP_CLOSE *udpclose_p = (t_PXENV_UDP_CLOSE *)scratch_buffer;
535 bzero(udpclose_p, sizeof(*udpclose_p));
537 pxe_call(PXENV_UDP_CLOSE);
538 if (udpclose_p->status != 0)
539 printf("pxe_end failed %x\n", udpclose_p->status);
543 pxe_netif_init(struct iodesc *desc, void *machdep_hint)
546 for (i = 0; i < 6; ++i)
547 desc->myea[i] = bootplayer.CAddr[i];
548 desc->xid = bootplayer.ident;
552 pxe_netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
558 pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
564 sendudp(struct iodesc *h, void *pkt, size_t len)
566 t_PXENV_UDP_WRITE *udpwrite_p = (t_PXENV_UDP_WRITE *)scratch_buffer;
567 bzero(udpwrite_p, sizeof(*udpwrite_p));
569 udpwrite_p->ip = h->destip.s_addr;
570 udpwrite_p->dst_port = h->destport;
571 udpwrite_p->src_port = h->myport;
572 udpwrite_p->buffer_size = len;
573 udpwrite_p->buffer.segment = VTOPSEG(pkt);
574 udpwrite_p->buffer.offset = VTOPOFF(pkt);
576 if (netmask == 0 || SAMENET(myip, h->destip, netmask))
579 udpwrite_p->gw = gateip.s_addr;
581 pxe_call(PXENV_UDP_WRITE);
584 /* XXX - I dont know why we need this. */
587 if (udpwrite_p->status != 0) {
588 /* XXX: This happens a lot. It shouldn't. */
589 if (udpwrite_p->status != 1)
590 printf("sendudp failed %x\n", udpwrite_p->status);
597 readudp(struct iodesc *h, void *pkt, size_t len, time_t timeout)
599 t_PXENV_UDP_READ *udpread_p = (t_PXENV_UDP_READ *)scratch_buffer;
600 struct udphdr *uh = NULL;
602 uh = (struct udphdr *) pkt - 1;
603 bzero(udpread_p, sizeof(*udpread_p));
605 udpread_p->dest_ip = h->myip.s_addr;
606 udpread_p->d_port = h->myport;
607 udpread_p->buffer_size = len;
608 udpread_p->buffer.segment = VTOPSEG(data_buffer);
609 udpread_p->buffer.offset = VTOPOFF(data_buffer);
611 pxe_call(PXENV_UDP_READ);
614 /* XXX - I dont know why we need this. */
617 if (udpread_p->status != 0) {
618 /* XXX: This happens a lot. It shouldn't. */
619 if (udpread_p->status != 1)
620 printf("readudp failed %x\n", udpread_p->status);
623 bcopy(data_buffer, pkt, udpread_p->buffer_size);
624 uh->uh_sport = udpread_p->s_port;
625 return udpread_p->buffer_size;