Fully synchronize sys/boot from FreeBSD-5.x, but add / to the module path
[dragonfly.git] / sys / boot / i386 / libi386 / pxe.c
CommitLineData
5ee58eed 1/*-
984263bc 2 * Copyright (c) 2000 Alfred Perlstein <alfred@freebsd.org>
984263bc 3 * Copyright (c) 2000 Paul Saab <ps@freebsd.org>
984263bc
MD
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 *
5ee58eed
MD
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 $
984263bc
MD
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
57static char scratch_buffer[PXE_BUFFER_SIZE];
58static char data_buffer[PXE_BUFFER_SIZE];
59
60static pxenv_t *pxenv_p = NULL; /* PXENV+ */
61static pxe_t *pxe_p = NULL; /* !PXE */
62static BOOTPLAYER bootplayer; /* PXE Cached information. */
63
64static int pxe_debug = 0;
65static int pxe_sock = -1;
66static int pxe_opens = 0;
67
68void pxe_enable(void *pxeinfo);
69static void (*pxe_call)(int func);
70static void pxenv_call(int func);
71static void bangpxe_call(int func);
72
73static int pxe_init(void);
74static int pxe_strategy(void *devdata, int flag, daddr_t dblk,
75 size_t size, char *buf, size_t *rsize);
76static int pxe_open(struct open_file *f, ...);
77static int pxe_close(struct open_file *f);
78static void pxe_print(int verbose);
79static void pxe_cleanup(void);
80static void pxe_setnfshandle(char *rootpath);
81
82static void pxe_perror(int error);
83static int pxe_netif_match(struct netif *nif, void *machdep_hint);
84static int pxe_netif_probe(struct netif *nif, void *machdep_hint);
85static void pxe_netif_init(struct iodesc *desc, void *machdep_hint);
86static int pxe_netif_get(struct iodesc *desc, void *pkt, size_t len,
87 time_t timeout);
88static int pxe_netif_put(struct iodesc *desc, void *pkt, size_t len);
89static void pxe_netif_end(struct netif *nif);
90
91extern struct netif_stats pxe_st[];
92extern u_int16_t __bangpxeseg;
93extern u_int16_t __bangpxeoff;
94extern void __bangpxeentry(void);
95extern u_int16_t __pxenvseg;
96extern u_int16_t __pxenvoff;
97extern void __pxenventry(void);
98
99struct netif_dif pxe_ifs[] = {
100/* dif_unit dif_nsel dif_stats dif_private */
101 {0, 1, &pxe_st[0], 0}
102};
103
104struct netif_stats pxe_st[NENTS(pxe_ifs)];
105
106struct 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
118struct netif_driver *netif_drivers[] = {
119 &pxenetif,
120 NULL
121};
122
123struct 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 */
140void
141pxe_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 */
153static int
154pxe_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
243static int
244pxe_strategy(void *devdata, int flag, daddr_t dblk, size_t size,
245 char *buf, size_t *rsize)
246{
247 return (EIO);
248}
249
250static int
251pxe_open(struct open_file *f, ...)
252{
5ee58eed 253 va_list args;
984263bc
MD
254 char *devname; /* Device part of file name (or NULL). */
255 char temp[FNAME_SIZE];
256 int error = 0;
257 int i;
258
5ee58eed
MD
259 va_start(args, f);
260 devname = va_arg(args, char*);
261 va_end(args);
984263bc
MD
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
5ee58eed 288 for (i = 0; rootpath[i] != '\0' && i < FNAME_SIZE; i++)
984263bc
MD
289 if (rootpath[i] == ':')
290 break;
5ee58eed 291 if (i && i != FNAME_SIZE && rootpath[i] == ':') {
984263bc
MD
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
318static int
319pxe_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
352static void
353pxe_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
369static void
370pxe_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
399void
400pxe_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 */
409struct nfs_iodesc {
410 struct iodesc *iodesc;
411 off_t off;
412 u_char fh[NFS_FHSIZE];
413 /* structure truncated here */
414};
415extern struct nfs_iodesc nfs_root_node;
416
417static void
418pxe_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
433void
434pxenv_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
456void
457bangpxe_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
480time_t
481getsecs()
482{
483 time_t n = 0;
484 time(&n);
485 return n;
486}
487
488static int
489pxe_netif_match(struct netif *nif, void *machdep_hint)
490{
491 return 1;
492}
493
494
495static int
496pxe_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
514static void
515pxe_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
525static void
526pxe_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
534static int
535pxe_netif_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
536{
537 return len;
538}
539
540static int
541pxe_netif_put(struct iodesc *desc, void *pkt, size_t len)
542{
543 return len;
544}
545
546ssize_t
547sendudp(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
579ssize_t
580readudp(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}